@nativescript/vite 8.0.0-alpha.7 → 8.0.0-alpha.70

package/hmr/client/index.js

@@ -1,1998 +1,101 @@
 /**
- * Robust HMR client for NativeScript.
+ * HMR client entry for NativeScript devices.
  *
  * Avoid importing from '@nativescript/core' and other framework modules here to prevent creating a second module realm via HTTP ESM.
  * Always resolve core classes and Application from the vendor realm or globalThis at runtime.
  * The HMR client is evaluated via HTTP ESM on device; static imports would create secondary instances.
+ *
+ * This entry owns boot-time side effects (core aliases, launch-notification
+ * bridge, CSS register) and wires the seams together:
+ * - `ws-transport.ts` — socket connect/reconnect + connection overlay
+ * - `protocol-dispatch.ts` — routes parsed wire messages
+ * - `update-pipeline.ts` — graph state + evict-then-reimport queue
+ * - `root-reset.ts` — root-view replacement
+ * - `strategy-loader.ts` — flavor detection + framework strategy loading
  */
-import { setHMRWsUrl, getHMRWsUrl, pendingModuleFetches, deriveHttpOrigin, setHttpOriginForVite, moduleFetchCache, requestModuleFromServer, getHttpOriginForVite, normalizeSpec, hmrMetrics, graph, setGraphVersion, getGraphVersion, getCurrentApp, getRootFrame, setCurrentApp, setRootFrame, getCore, hasExplicitEviction, invalidateModulesByUrls, buildEvictionUrls, emitHmrModeBannerOnce } from './utils.js';
-import { handleCssUpdates } from './css-handler.js';
-const VERBOSE = typeof __NS_ENV_VERBOSE__ !== 'undefined' && __NS_ENV_VERBOSE__;
-function resolveTargetFlavor() {
-    try {
-        if (typeof __NS_TARGET_FLAVOR__ !== 'undefined' && __NS_TARGET_FLAVOR__) {
-            return __NS_TARGET_FLAVOR__;
-        }
-    }
-    catch { }
-    try {
-        const g = globalThis;
-        if (typeof g.__NS_TARGET_FLAVOR__ === 'string' && g.__NS_TARGET_FLAVOR__) {
-            return g.__NS_TARGET_FLAVOR__;
-        }
-        if (typeof g.__NS_HMR_BROWSER_RUNTIME_TARGET_FLAVOR__ === 'string' && g.__NS_HMR_BROWSER_RUNTIME_TARGET_FLAVOR__) {
-            return g.__NS_HMR_BROWSER_RUNTIME_TARGET_FLAVOR__;
-        }
-        if (typeof g.__reboot_ng_modules__ === 'function') {
-            return 'angular';
-        }
-        if (g.__VUE_HMR_RUNTIME__ || g.__NS_HMR_VUE_SFC_REGISTRY__) {
-            return 'vue';
-        }
-    }
-    catch { }
-    return undefined;
-}
-const TARGET_FLAVOR = resolveTargetFlavor();
-try {
-    if (TARGET_FLAVOR && !globalThis.__NS_TARGET_FLAVOR__) {
-        globalThis.__NS_TARGET_FLAVOR__ = TARGET_FLAVOR;
-    }
-}
-catch { }
-const APP_ROOT_VIRTUAL = typeof __NS_APP_ROOT_VIRTUAL__ === 'string' && __NS_APP_ROOT_VIRTUAL__ ? __NS_APP_ROOT_VIRTUAL__ : '/src';
-const APP_VIRTUAL_WITH_SLASH = APP_ROOT_VIRTUAL.endsWith('/') ? APP_ROOT_VIRTUAL : `${APP_ROOT_VIRTUAL}/`;
-const APP_MAIN_ENTRY_SPEC = `${APP_VIRTUAL_WITH_SLASH}app.ts`;
-// Policy: by default, let the app's own main entry mount initially; HMR client handles updates/remounts only.
-// Flip this to true via global __NS_HMR_ALLOW_INITIAL_MOUNT__ if you need the client to perform the first mount.
-const ALLOW_INITIAL_MOUNT = !!globalThis.__NS_HMR_ALLOW_INITIAL_MOUNT__;
-// Ensure core aliases are present on globalThis early so that /ns/rt exports resolve to functions
+import { setHMRWsUrl, getHMRWsUrl, getCore, ENV_VERBOSE } from './utils.js';
+import { applyCssText } from './css-handler.js';
+import { getGlobalScope } from '../shared/runtime/global-scope.js';
+import { installLaunchNotificationBridge } from '../shared/runtime/launch-bridge.js';
+import { connectHmr, setHmrMessageHandler } from './ws-transport.js';
+import { handleHmrMessage } from './protocol-dispatch.js';
+import { ensureCoreAliasesOnGlobalThis, performResetRoot } from './root-reset.js';
+import { CLIENT_STRATEGY_READY, getClientStrategy } from './strategy-loader.js';
+const VERBOSE = ENV_VERBOSE;
+// Apply once on module evaluation so that /ns/rt exports resolve to functions
 // before any SFCs are evaluated during HTTP-only dev boot.
-function ensureCoreAliasesOnGlobalThis() {
-    const g = globalThis;
-    try {
-        const F = getCore('Frame') || g.Frame;
-        const A = getCore('Application') || g.Application;
-        const P = getCore('Page') || g.Page;
-        // Publish to globalThis if missing
-        try {
-            if (F && !g.Frame)
-                g.Frame = F;
-        }
-        catch { }
-        try {
-            if (A && (!g.Application || typeof g.Application.run !== 'function' || typeof g.Application.on !== 'function' || typeof g.Application.resetRootView !== 'function')) {
-                g.Application = A;
-            }
-        }
-        catch { }
-        try {
-            if (P && !g.Page)
-                g.Page = P;
-        }
-        catch { }
-    }
-    catch { }
-}
-// Apply once on module evaluation
 ensureCoreAliasesOnGlobalThis();
-function getHmrOverlayApi() {
-    try {
-        return globalThis.__NS_HMR_DEV_OVERLAY__ || null;
-    }
-    catch { }
-    return null;
-}
-function setConnectionOverlayStage(stage, detail) {
-    try {
-        const api = getHmrOverlayApi();
-        if (api && typeof api.setConnectionStage === 'function') {
-            api.setConnectionStage(stage, { detail });
-        }
-    }
-    catch { }
-}
-function hideConnectionOverlay() {
-    try {
-        const api = getHmrOverlayApi();
-        if (api && typeof api.hide === 'function') {
-            api.hide('healthy');
-        }
-    }
-    catch { }
-}
-// Eagerly drive the HMR-applying overlay's 'received' frame as soon
-// as the server emits `ns:hmr-pending`, BEFORE the framework-specific
-// (`ns:angular-update` / `ns:css-updates`) payload arrives. The
-// flavor-specific handler later walks through 'evicting' →
-// 'reimporting' → 'rebooting' → 'complete'. Calling 'received' twice
-// in the same cycle is safe: the overlay preserves
-// `updateCycleStartedAt` when a 'received' frame replaces an existing
-// 'received' frame so the minimum-visible window is still timed
-// against the FIRST frame.
+// Late-registration bridge for one-shot iOS launch notifications
+// (see shared/runtime/launch-bridge.ts).
 //
-// Soft-fails when the overlay isn't installed (production builds,
-// vitest, etc.) or when the user opted out via
-// `__NS_HMR_PROGRESS_OVERLAY_ENABLED__ === false`.
-import { applyHmrPendingFrame } from './hmr-pending-overlay.js';
-function setHmrPendingOverlay(filePath) {
-    applyHmrPendingFrame(filePath, { getOverlay: getHmrOverlayApi });
-}
-let connectionOverlayTimer = null;
-let connectionOverlayVisible = false;
-let hasOpenedHmrSocket = false;
-let awaitingHealthyHmrMessage = false;
-let pendingConnectionOverlayStage = 'connecting';
-let pendingConnectionOverlayDetail = '';
-function clearConnectionOverlayTimer() {
-    if (connectionOverlayTimer) {
-        clearTimeout(connectionOverlayTimer);
-        connectionOverlayTimer = null;
-    }
-}
-function showConnectionOverlayNow(stage, detail) {
-    pendingConnectionOverlayStage = stage;
-    pendingConnectionOverlayDetail = detail || '';
-    connectionOverlayVisible = true;
-    setConnectionOverlayStage(stage, detail);
-}
-function scheduleConnectionOverlay(stage, detail, delayMs = 1200) {
-    pendingConnectionOverlayStage = stage;
-    pendingConnectionOverlayDetail = detail || '';
-    clearConnectionOverlayTimer();
-    connectionOverlayTimer = setTimeout(() => {
-        showConnectionOverlayNow(pendingConnectionOverlayStage, pendingConnectionOverlayDetail);
-    }, delayMs);
-}
-function updateConnectionOverlay(stage, detail) {
-    pendingConnectionOverlayStage = stage;
-    pendingConnectionOverlayDetail = detail || '';
-    if (connectionOverlayVisible) {
-        showConnectionOverlayNow(stage, detail);
-    }
-}
-function markHmrConnectionHealthy() {
-    awaitingHealthyHmrMessage = false;
-    clearConnectionOverlayTimer();
-    if (connectionOverlayVisible) {
-        connectionOverlayVisible = false;
-        hideConnectionOverlay();
-    }
-}
-/**
- * Flavor hooks
- */
-import { installNsVueDevShims, ensureBackWrapperInstalled, getRootForVue, loadSfcComponent, ensureVueGlobals, ensurePiniaOnApp, addSfcMapping, recordVuePayloadChanges, handleVueSfcRegistry, handleVueSfcRegistryUpdate, sfcArtifactMap } from '../frameworks/vue/client/index.js';
-import { handleAngularHotUpdateMessage, installAngularHmrClientHooks } from '../frameworks/angular/client/index.js';
-switch (TARGET_FLAVOR) {
-    case 'vue':
-        installNsVueDevShims();
-        break;
-    case 'angular':
-        installAngularHmrClientHooks();
-        break;
-}
-// Track whether we've mounted an initial app root yet in HTTP-only boot
-let initialMounted = !!globalThis.__NS_HMR_BOOT_COMPLETE__;
-// Prevent duplicate initial-mount scheduling across rapid full-graph broadcasts and re-evaluations
-let initialMounting = !!globalThis.__NS_HMR_INITIAL_MOUNT_IN_PROGRESS__;
-// Track whether the first full-graph has been received. Before the full-graph,
-// delta messages are just the server discovering modules during initial boot —
-// NOT actual code changes. Re-imports must be gated behind this flag.
-let hasReceivedFullGraph = false;
-// TypeScript flavor: track registry modules and inferred main id
-let tsModuleSet = null;
-let tsMainId = null;
-const changedQueue = [];
-let processingQueue = false;
-let processingPromise = null;
-// Detect whether the early placeholder root is still active on screen
-function isPlaceholderActive() {
-    try {
-        const g = globalThis;
-        if (g.__NS_DEV_PLACEHOLDER_ROOT_VIEW__)
-            return true;
-        if (g.__NS_DEV_PLACEHOLDER_ROOT_EARLY__)
-            return true;
-    }
-    catch { }
-    return false;
-}
-// Navigation queue removed: we navigate immediately or throw with a clear error
-// Robust navigation fallback: create a sub-app and mount it on a new Page, then navigate there.
-// __nsNavigateWithSubApp removed: no navigation fallbacks are used
-function applyFullGraph(payload) {
-    if (typeof payload.version !== 'number' || !Array.isArray(payload.modules))
-        return;
-    graph.clear();
-    payload.modules.forEach((m) => {
-        if (m && m.id)
-            graph.set(m.id, { id: m.id, deps: m.deps || [], hash: m.hash || '' });
-    });
-    setGraphVersion(payload.version);
-    if (VERBOSE)
-        console.log('[hmr][graph] full graph applied version', getGraphVersion(), 'modules=', graph.size);
-    // Guarded initial mount rescue: if app hasn't replaced the placeholder shortly after graph arrives,
-    // perform a one-time mount. This waits briefly to let the app's main entry start() run first to avoid double mounts.
-    // TypeScript flavor: skip the rescue entirely. The HTTP boot will load main.ts which
-    // calls Application.run() (patched to resetRootView) — the rescue is redundant and
-    // causes a double-mount race (rescue fires at 450ms, then main.ts fires ~1s later,
-    // causing a visual flash and leaving the app in an inconsistent state).
-    try {
-        const g = globalThis;
-        const bootDone = !!g.__NS_HMR_BOOT_COMPLETE__;
-        if (!bootDone && !initialMounted && !initialMounting && !g.__NS_HMR_RESCUE_SCHEDULED__ && TARGET_FLAVOR !== 'typescript') {
-            // simple snapshot helpers
-            const getTopmost = () => {
-                try {
-                    const F = getCore('Frame') || g.Frame;
-                    return F?.topmost?.() || null;
-                }
-                catch {
-                    return null;
-                }
-            };
-            const isPlaceholderView = (v) => {
-                try {
-                    if (!v)
-                        return false;
-                    if (v === (g.__NS_DEV_PLACEHOLDER_ROOT_VIEW__ || null))
-                        return true;
-                    return !!v.__ns_dev_placeholder;
-                }
-                catch {
-                    return false;
-                }
-            };
-            const hasRealRoot = () => {
-                try {
-                    const fr = getTopmost();
-                    if (!fr)
-                        return false;
-                    if (isPlaceholderView(fr))
-                        return false;
-                    const pg = fr.currentPage || fr._currentEntry?.resolvedPage;
-                    if (!pg)
-                        return false;
-                    if (isPlaceholderView(pg))
-                        return false;
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            };
-            try {
-                g.__NS_HMR_RESCUE_SCHEDULED__ = true;
-            }
-            catch { }
-            setTimeout(() => {
-                try {
-                    if (g.__NS_HMR_BOOT_COMPLETE__)
-                        return; // app already mounted
-                    if (hasRealRoot()) {
-                        try {
-                            g.__NS_HMR_BOOT_COMPLETE__ = true;
-                        }
-                        catch { }
-                        if (VERBOSE)
-                            console.log('[hmr][init] detected real root after delay; skipping client initial mount');
-                        // Detach placeholder handler if still present
-                        try {
-                            const restore = g.__NS_DEV_RESTORE_PLACEHOLDER__;
-                            if (typeof restore === 'function')
-                                restore();
-                        }
-                        catch { }
-                        return;
-                    }
-                    // If placeholder still active and no real root, try a one-time gentle initial mount.
-                    // Vue: prefer SFCs; TypeScript: import the app main TS module and let performResetRoot handle it once.
-                    const placeholderActive = isPlaceholderActive();
-                    if (!placeholderActive)
-                        return;
-                    if (VERBOSE)
-                        console.log('[hmr][init] placeholder persists after delay; evaluating rescue policy');
-                    // Flavor-specific rescue handling
-                    if (TARGET_FLAVOR === 'typescript') {
-                        // For TS apps, perform a one-time resetRootView to the conventional
-                        // app root module. This mimics what Application.run would do and
-                        // replaces the placeholder with the real UI without trying to
-                        // treat app.ts as a component.
-                        try {
-                            const App = getCore('Application') || g.Application;
-                            if (App && typeof App.resetRootView === 'function') {
-                                if (VERBOSE)
-                                    console.log('[hmr][init] TS flavor: performing rescue resetRootView to moduleName=app-root');
-                                initialMounting = true;
-                                try {
-                                    g.__NS_HMR_INITIAL_MOUNT_IN_PROGRESS__ = true;
-                                }
-                                catch { }
-                                App.resetRootView({ moduleName: 'app-root' });
-                                initialMounted = true;
-                                try {
-                                    g.__NS_HMR_BOOT_COMPLETE__ = true;
-                                }
-                                catch { }
-                                if (VERBOSE)
-                                    console.log('[hmr][init] TS rescue resetRootView complete');
-                            }
-                            else if (VERBOSE) {
-                                console.warn('[hmr][init] TS flavor: Application.resetRootView unavailable; cannot perform rescue');
-                            }
-                        }
-                        catch (e) {
-                            console.warn('[hmr][init] TS rescue resetRootView failed', e);
-                        }
-                        finally {
-                            initialMounting = false;
-                            try {
-                                g.__NS_HMR_INITIAL_MOUNT_IN_PROGRESS__ = false;
-                            }
-                            catch { }
-                        }
-                        return;
-                    }
-                    let candidate = null;
-                    switch (TARGET_FLAVOR) {
-                        case 'vue': {
-                            const appEntry = graph.get(APP_MAIN_ENTRY_SPEC);
-                            if (appEntry && Array.isArray(appEntry.deps)) {
-                                const vueDep = appEntry.deps.find((d) => typeof d === 'string' && /\.vue$/i.test(d));
-                                if (vueDep)
-                                    candidate = vueDep;
-                            }
-                            if (!candidate) {
-                                for (const id of graph.keys()) {
-                                    if (/\.vue$/i.test(id)) {
-                                        candidate = id;
-                                        break;
-                                    }
-                                }
-                            }
-                            // Fallback: when the module graph is empty (Vite 7+ may not populate it
-                            // before the first full-graph broadcast), check the SFC artifact registry
-                            // which is populated from the ns:vue-sfc-registry message.
-                            if (!candidate && sfcArtifactMap.size > 0) {
-                                for (const id of sfcArtifactMap.keys()) {
-                                    if (/\.vue$/i.test(id)) {
-                                        candidate = id;
-                                        if (VERBOSE)
-                                            console.log('[hmr][init] rescue candidate from SFC registry:', id);
-                                        break;
-                                    }
-                                }
-                            }
-                            break;
-                        }
-                    }
-                    if (!candidate)
-                        return;
-                    initialMounting = true;
-                    try {
-                        g.__NS_HMR_INITIAL_MOUNT_IN_PROGRESS__ = true;
-                    }
-                    catch { }
-                    (async () => {
-                        try {
-                            let comp = null;
-                            switch (TARGET_FLAVOR) {
-                                case 'vue':
-                                    comp = await loadSfcComponent(candidate, 'initial_mount_rescue');
-                                    break;
-                            }
-                            if (!comp)
-                                return;
-                            const ok = await performResetRoot(comp);
-                            if (ok) {
-                                initialMounted = true;
-                                try {
-                                    g.__NS_HMR_BOOT_COMPLETE__ = true;
-                                }
-                                catch { }
-                                if (VERBOSE)
-                                    console.log('[hmr][init] initial mount (rescue) complete');
-                            }
-                        }
-                        catch (e) {
-                            console.warn('[hmr][init] initial mount (rescue) error', e);
-                        }
-                        finally {
-                            initialMounting = false;
-                            try {
-                                g.__NS_HMR_INITIAL_MOUNT_IN_PROGRESS__ = false;
-                            }
-                            catch { }
-                        }
-                    })();
-                }
-                catch { }
-            }, 450);
-        }
-    }
-    catch { }
-    // On first full graph, if we have not mounted yet, attempt an initial mount
-    // by choosing a likely root component for the active flavor and performing a resetRootView with it.
-    try {
-        // Short-circuit if boot is complete or an initial mount is already underway (across realms/evals)
-        const bootDone = !!globalThis.__NS_HMR_BOOT_COMPLETE__;
-        const bootInProgress = !!globalThis.__NS_HMR_INITIAL_MOUNT_IN_PROGRESS__ || initialMounting;
-        // Only allow initial mount when explicitly enabled. Rely on the app's own main entry start() for the first mount
-        // to avoid double-mount races that can cause duplicate navigation logs.
-        if (ALLOW_INITIAL_MOUNT && !initialMounted && !bootDone && !bootInProgress && !getCurrentApp() && !getRootFrame()) {
-            let candidate = null;
-            switch (TARGET_FLAVOR) {
-                case 'vue': {
-                    const appEntry = graph.get(APP_MAIN_ENTRY_SPEC);
-                    if (appEntry && Array.isArray(appEntry.deps)) {
-                        const vueDep = appEntry.deps.find((d) => typeof d === 'string' && /\.vue$/i.test(d));
-                        if (vueDep)
-                            candidate = vueDep;
-                    }
-                    if (!candidate) {
-                        for (const id of graph.keys()) {
-                            if (/\.vue$/i.test(id)) {
-                                candidate = id;
-                                break;
-                            }
-                        }
-                    }
-                    // Fallback: SFC registry (same as rescue mount above)
-                    if (!candidate && sfcArtifactMap.size > 0) {
-                        for (const id of sfcArtifactMap.keys()) {
-                            if (/\.vue$/i.test(id)) {
-                                candidate = id;
-                                if (VERBOSE)
-                                    console.log('[hmr][init] initial mount candidate from SFC registry:', id);
-                                break;
-                            }
-                        }
-                    }
-                    break;
-                }
-                case 'typescript': {
-                    // For TS flavor, do not perform client-driven initial mount; rely on Application.run.
-                    return;
-                }
-            }
-            if (candidate) {
-                // Mark initial-mount in progress (both module-local and global) BEFORE scheduling async work
-                initialMounting = true;
-                try {
-                    globalThis.__NS_HMR_INITIAL_MOUNT_IN_PROGRESS__ = true;
-                }
-                catch { }
-                (async () => {
-                    try {
-                        if (VERBOSE)
-                            console.log('[hmr][init] mounting initial root from', candidate, 'flavor=', TARGET_FLAVOR);
-                        // Android-only: avoid racing entry-runtime reset and Activity bring-up
-                        try {
-                            const g = globalThis;
-                            const App = getCore('Application') || g.Application;
-                            const isAndroid = !!(App && App.android !== undefined);
-                            if (isAndroid) {
-                                const ready = async (ms = 8000, step = 60) => {
-                                    const start = Date.now();
-                                    const ok = () => {
-                                        try {
-                                            const a = App.android;
-                                            const act = a && (a.foregroundActivity || a.startActivity);
-                                            const inProg = !!g.__NS_DEV_RESET_IN_PROGRESS__;
-                                            return !!act && !inProg;
-                                        }
-                                        catch {
-                                            return false;
-                                        }
-                                    };
-                                    while (Date.now() - start < ms) {
-                                        if (ok())
-                                            return true;
-                                        await new Promise((r) => setTimeout(r, step));
-                                    }
-                                    return ok();
-                                };
-                                const ok = await ready(8000, 60);
-                                if (!ok && VERBOSE)
-                                    console.warn('[hmr][init] proceeding without explicit boot-ready signal (timeout)');
-                            }
-                        }
-                        catch { }
-                        let comp = null;
-                        switch (TARGET_FLAVOR) {
-                            case 'vue':
-                                comp = await loadSfcComponent(candidate, 'initial_mount');
-                                break;
-                            case 'typescript':
-                                try {
-                                    const url = await requestModuleFromServer(candidate);
-                                    const mod = await import(/* @vite-ignore */ url);
-                                    comp = mod && (mod.default || mod);
-                                }
-                                catch (e) {
-                                    if (VERBOSE)
-                                        console.warn('[hmr][init] TS initial mount failed to import', candidate, e);
-                                }
-                                break;
-                        }
-                        if (comp) {
-                            const ok = await performResetRoot(comp);
-                            if (ok) {
-                                initialMounted = true;
-                                try {
-                                    globalThis.__NS_HMR_BOOT_COMPLETE__ = true;
-                                }
-                                catch { }
-                                if (VERBOSE)
-                                    console.log('[hmr][init] initial mount complete');
-                            }
-                            else if (VERBOSE) {
-                                console.warn('[hmr][init] initial mount did not verify; will rely on subsequent retries');
-                            }
-                        }
-                        else if (VERBOSE) {
-                            console.warn('[hmr][init] failed to load initial component from', candidate);
-                        }
-                    }
-                    catch (e) {
-                        console.warn('[hmr][init] initial mount error', e);
-                    }
-                    finally {
-                        // Clear in-progress flag regardless of outcome to allow future retries if needed
-                        initialMounting = false;
-                        try {
-                            globalThis.__NS_HMR_INITIAL_MOUNT_IN_PROGRESS__ = false;
-                        }
-                        catch { }
-                    }
-                })();
-            }
-            else if (VERBOSE) {
-                console.warn('[hmr][init] no component found in graph to mount initially for flavor', TARGET_FLAVOR);
-            }
-        }
-    }
-    catch { }
-}
-function applyDelta(payload) {
-    // If versions are out of sync, request a full graph resync, but still
-    // opportunistically queue the changed ids so the client can react once
-    // the resync arrives. This is especially important for simple TS flavors
-    // where we only need a signal that "something changed" to trigger a
-    // resetRootView-driven hot update.
-    const currentVersion = getGraphVersion();
-    const versionMatches = payload.baseVersion === currentVersion;
-    if (!versionMatches) {
-        if (VERBOSE)
-            console.warn('[hmr][graph] version mismatch requesting resync', payload.baseVersion, currentVersion);
-        try {
-            hmrSocket?.send(JSON.stringify({ type: 'ns:hmr-resync-request' }));
-        }
-        catch { }
-    }
-    if (versionMatches) {
-        setGraphVersion(payload.newVersion);
-    }
-    const changed = payload.changed || [];
-    switch (TARGET_FLAVOR) {
-        case 'vue':
-            recordVuePayloadChanges(changed, getGraphVersion());
-            break;
-    }
-    (payload.changed || []).forEach((m) => {
-        if (!m || !m.id)
-            return;
-        // Always update the local graph view with the announced module metadata
-        graph.set(m.id, { id: m.id, deps: m.deps || [], hash: m.hash || '' });
-    });
-    (payload.removed || []).forEach((r) => {
-        graph.delete(r);
-    });
-    if (VERBOSE)
-        console.log('[hmr][graph] delta applied newVersion', getGraphVersion(), 'changed=', (payload.changed || []).length, 'removed=', (payload.removed || []).length, 'baseVersion=', payload.baseVersion);
-    // Queue evaluation of changed modules (placeholder pipeline)
-    if (payload.changed?.length) {
-        // Gate: Before the first full-graph is received, delta messages are the server
-        // discovering modules during initial boot — NOT actual code changes. The entry-runtime
-        // already loaded all modules; re-importing them would cause duplicate Application.run(),
-        // router initialization, and modal conflicts. Only queue re-imports after the first
-        // full-graph confirms the graph is synced and subsequent deltas are real changes.
-        if (!hasReceivedFullGraph) {
-            if (VERBOSE)
-                console.log('[hmr][delta] skipping re-import queue (initial graph build, no full-graph yet)');
-            return;
-        }
-        // HARD SUPPRESS: the very first delta (baseVersion 0) commonly includes the app main entry which is already evaluated during bootstrap.
-        // Importing it again with a cache-bust often produces a spurious module-not-found (timestamp param treated as distinct file).
-        const isInitial = payload.baseVersion === 0;
-        // Filter out virtual helper ids (e.g. '\0plugin-vue:export-helper') which we do not evaluate directly
-        const realIds = payload.changed.map((c) => c.id).filter((id) => !/^\0|^\/\0|plugin-vue:export-helper/.test(id));
-        // Proactively prefetch core/src deps for any changed .vue SFCs (before registry update triggers reset)
-        try {
-            for (const entry of payload.changed || []) {
-                if (!entry || !/\.vue$/i.test(entry.id))
-                    continue;
-                const deps = Array.isArray(entry.deps) ? entry.deps : [];
-                const prefetchTargets = deps.filter((d) => /^\//.test(d) && !/node_modules/.test(d) && !/\.vue$/i.test(d));
-                if (prefetchTargets.length && VERBOSE)
-                    console.log('[hmr][prefetch] SFC deps', entry.id, '->', prefetchTargets);
-                for (const dep of prefetchTargets) {
-                    const norm = normalizeSpec(dep);
-                    // Skip if we already wrote it (basic heuristic: moduleFetchCache has it or path exists in Documents/_ns_hmr)
-                    if (moduleFetchCache.has(norm))
-                        continue;
-                    // Fire and forget; ensure rejection does not break HMR pipeline
-                    requestModuleFromServer(norm).catch(() => { });
-                }
-            }
-        }
-        catch (e) {
-            if (VERBOSE)
-                console.warn('[hmr][prefetch] failed', e);
-        }
-        const isAppMainEntryId = (value) => value.endsWith(APP_MAIN_ENTRY_SPEC);
-        for (const id of realIds) {
-            // We now rely on SFC registry update events to trigger root resets for .vue files directly
-            if (/\.vue$/i.test(id)) {
-                if (VERBOSE)
-                    console.log('[hmr][delta] skipping queue for .vue id; will handle on registry update', id);
-                continue;
-            }
-            if (isInitial && isAppMainEntryId(id)) {
-                if (VERBOSE)
-                    console.log(`[hmr][delta] suppressing initial ${APP_MAIN_ENTRY_SPEC} evaluation`);
-                continue;
-            }
-            if (isAppMainEntryId(id)) {
-                try {
-                    const exists = globalThis.require?.(id) || globalThis.__nsGetModuleExports?.(id);
-                    if (!exists && VERBOSE)
-                        console.log(`[hmr][delta] skipping unresolved ${APP_MAIN_ENTRY_SPEC} change`);
-                    if (!exists)
-                        continue;
-                }
-                catch {
-                    /* ignore */
-                }
-            }
-            changedQueue.push(id);
-        }
-        if (changedQueue.length)
-            processQueue();
-    }
-}
-// Deterministic navigation using the current Vue app instance rather than vendor-held rootApp
-function __nsNavigateUsingApp(comp, opts = {}) {
-    const g = globalThis;
-    switch (TARGET_FLAVOR) {
-        case 'vue':
-            ensureVueGlobals();
-            break;
-    }
-    const AppFactory = g.createApp;
-    const RootCtor = g.NSVRoot;
-    if (typeof AppFactory !== 'function' || typeof RootCtor !== 'function') {
-        throw new Error('Vue runtime not initialized');
-    }
+// Under a webpack (or non-HMR vite) build the app bundle evaluates BEFORE
+// `UIApplicationMain` finishes launching, so
+// `Application.ios.addNotificationObserver(UIApplicationDidFinishLaunchingNotification, cb)`
+// registers in time. Under the HTTP dev session UIKit is fully launched long
+// before the app graph evaluates — those observers register AFTER the
+// notification fired and are never called, so apps that gate SDK init (auth,
+// Firebase, Sentry) behind didFinishLaunching silently never initialize. The
+// bridge wraps `addNotificationObserver` so a post-launch registration for
+// Did/WillFinishLaunching still registers normally AND has its callback
+// invoked on the next macrotask with a synthesized NSNotification.
+//
+// The DETERMINISTIC install happens in the /__ns_dev__/client bootstrap
+// wrapper, which runs before the app entry. This module-eval attempt and the
+// global hook are belt-and-braces for exotic boot paths — this client
+// evaluates async and can lose the race against the entry graph, so it must
+// never be the only wrap.
+function tryInstallLaunchNotificationBridge(attempts, explicitApplication) {
+    let wrappedAny = false;
     try {
-        const top = (g.Frame && g.Frame.topmost && g.Frame.topmost()) || null;
-        const ctor = top && top.constructor && top.constructor.name;
-        if (VERBOSE)
-            console.log('[app-nav] begin', {
-                hmrRealm: g.__NS_HMR_REALM__ || 'unknown',
-                rtRealm: g.__NS_RT_REALM__ || 'unknown',
-                topCtor: ctor,
-                hasTop: !!top,
-            });
+        wrappedAny = installLaunchNotificationBridge(explicitApplication, [getCore('Application')]);
     }
     catch { }
-    // Build a fresh Page each time the factory is invoked to avoid reusing a Page instance
-    // across fragment recreations (Android) or multiple frame attachments.
-    const buildTarget = () => {
-        const existingApp = getCurrentApp();
-        const baseProvides = (existingApp && existingApp._context && existingApp._context.provides) || {};
-        const app = AppFactory(normalizeComponent(comp, comp && (comp.__name || comp.name)));
-        switch (TARGET_FLAVOR) {
-            case 'vue':
-                ensurePiniaOnApp(app);
-                break;
-        }
-        try {
-            const registry = g.__nsVendorRegistry;
-            const req = registry?.get ? g.__nsVendorRequire || g.__nsRequire || g.require : g.__nsRequire || g.require;
-            let rh = null;
-            if (registry && registry.has('nativescript-vue/dist/runtimeHelpers'))
-                rh = registry.get('nativescript-vue/dist/runtimeHelpers');
-            if (!rh && typeof req === 'function') {
-                try {
-                    rh = req('nativescript-vue/dist/runtimeHelpers');
-                }
-                catch { }
-            }
-            const setRootApp = rh && (rh.setRootApp || rh.default?.setRootApp);
-            if (typeof setRootApp === 'function')
-                setRootApp(app);
-        }
-        catch { }
-        try {
-            const ctx = app?._context;
-            if (ctx) {
-                const prov = (ctx.provides || (ctx.provides = {}));
-                Object.getOwnPropertyNames(baseProvides).forEach((k) => {
-                    if (!Object.prototype.hasOwnProperty.call(prov, k))
-                        prov[k] = baseProvides[k];
-                });
-                Object.getOwnPropertySymbols(baseProvides).forEach((s) => {
-                    if (!Object.prototype.hasOwnProperty.call(prov, s))
-                        prov[s] = baseProvides[s];
-                });
-            }
-        }
-        catch { }
-        const root = new RootCtor();
-        const vm = typeof app.runWithContext === 'function' ? app.runWithContext(() => app.mount(root)) : app.mount(root);
-        setCurrentApp(app);
-        const el = vm?.$el;
-        const nativeView = el?.nativeView;
-        if (!nativeView)
-            throw new Error('navigation mount did not yield a nativeView');
-        const P = getCore('Page');
-        const ctorName = String(nativeView?.constructor?.name || '').replace(/^_+/, '');
-        if (ctorName === 'Page' || /^Page(\$\d+)?$/.test(ctorName)) {
-            return nativeView;
-        }
-        if (typeof P === 'function') {
-            const pg = new P();
-            pg.content = nativeView;
-            // Hide default ActionBar for wrapped views to avoid double bars
-            try {
-                pg.actionBarHidden = true;
-            }
-            catch { }
-            return pg;
-        }
-        return nativeView; // fallback
-    };
-    let frame = opts && opts.frame ? opts.frame : getRootFrame();
-    if (!frame) {
-        const F = getCore('Frame');
-        frame = F && typeof F.topmost === 'function' ? F.topmost() : null;
+    if (!wrappedAny && attempts > 0) {
+        setTimeout(() => tryInstallLaunchNotificationBridge(attempts - 1, explicitApplication), 100);
     }
-    if (!frame) {
-        const GApp = getCore('Application') || g.Application;
-        const F = getCore('Frame');
-        if (typeof GApp?.resetRootView === 'function' && typeof F === 'function') {
-            GApp.resetRootView({
-                create: () => {
-                    const fr = new F();
-                    const navEntry = {
-                        create: () => buildTarget(),
-                        clearHistory: true,
-                        animated: false,
-                    };
-                    try {
-                        fr.navigate(navEntry);
-                    }
-                    catch { }
-                    setRootFrame(fr);
-                    return fr;
-                },
-            });
-            return undefined;
-        }
-        throw new Error('Application.resetRootView unavailable');
-    }
-    const navEntry = { create: () => buildTarget(), ...(opts || {}) };
-    frame.navigate(navEntry);
-    return undefined;
 }
-// Expose deterministic app navigation globally so /ns/rt can guarantee single-path navigation
+tryInstallLaunchNotificationBridge(100);
 try {
-    globalThis.__nsNavigateUsingApp = __nsNavigateUsingApp;
+    globalThis.__NS_DEV_INSTALL_LAUNCH_BRIDGE__ = (explicitApplication) => tryInstallLaunchNotificationBridge(100, explicitApplication);
 }
 catch { }
-async function processQueue() {
-    if (!globalThis.__NS_HMR_BOOT_COMPLETE__) {
-        if (VERBOSE)
-            console.log('[hmr][gate] deferring HMR eval until boot complete');
-        setTimeout(() => {
-            try {
-                processQueue();
-            }
-            catch { }
-        }, 150);
-        return Promise.resolve();
-    }
-    if (processingQueue)
-        return processingPromise || Promise.resolve();
-    processingQueue = true;
-    processingPromise = (async () => {
-        try {
-            // Simple deterministic drain of the queue. We currently focus on TS flavor
-            // by re-importing changed modules (to refresh their HTTP ESM copies) and
-            // then performing a root reset so the UI reflects the new code.
-            const seen = new Set();
-            const drained = [];
-            while (changedQueue.length) {
-                const id = changedQueue.shift();
-                if (!id || typeof id !== 'string')
-                    continue;
-                if (seen.has(id))
-                    continue;
-                seen.add(id);
-                drained.push(id);
-            }
-            if (!drained.length)
-                return;
-            if (VERBOSE)
-                console.log('[hmr][queue] processing changed ids', drained);
-            // Explicit eviction step.
-            //
-            // On modern runtimes the URL canonicalizer collapses any
-            // `__ns_hmr__/<tag>/` segment back to a stable cache key, so
-            // without explicit eviction the upcoming `import(url)` would
-            // resolve via V8's `g_moduleRegistry` and return the cached
-            // stale module — making the queue drain a silent no-op for
-            // every save after the first.
-            //
-            // We hand the canonical eviction URLs to the runtime first;
-            // `invalidateModulesByUrls` is a no-op on older runtimes and
-            // `requestModuleFromServer` automatically falls back to the
-            // legacy `/ns/m/__ns_hmr__/v<N>/` URL versioning path in that
-            // case. node_modules and virtual specs are filtered out by
-            // `buildEvictionUrls` so vendor modules stay hot.
-            const evictUrls = buildEvictionUrls(drained);
-            const evicted = invalidateModulesByUrls(evictUrls);
-            if (VERBOSE)
-                console.log(`[hmr][queue] eviction count=${evictUrls.length} ok=${evicted}`);
-            // Evaluate changed modules best-effort; failures shouldn't completely break HMR.
-            for (const id of drained) {
-                try {
-                    const spec = normalizeSpec(id);
-                    const url = await requestModuleFromServer(spec);
-                    if (!url)
-                        continue;
-                    if (VERBOSE)
-                        console.log('[hmr][queue] re-import', { id, spec, url });
-                    const mod = await import(/* @vite-ignore */ url);
-                }
-                catch (e) {
-                    if (VERBOSE)
-                        console.warn('[hmr][queue] re-import failed for', id, e);
-                }
-            }
-            // After evaluating the batch, perform flavor-specific UI refresh.
-            switch (TARGET_FLAVOR) {
-                case 'vue':
-                    // Vue SFCs are handled via the registry update path; nothing to do here.
-                    break;
-                case 'solid': {
-                    // Solid .tsx components are self-accepting via solid-refresh's inline
-                    // patchRegistry — re-importing them is sufficient. For non-component
-                    // .ts utility modules, we must propagate up the import graph to find
-                    // the .tsx/.jsx component boundaries and re-import those so their
-                    // solid-refresh proxies pick up the new dependency values.
-                    try {
-                        // Build reverse index: dep id → list of importer ids
-                        const reverseIndex = new Map();
-                        for (const [id, mod] of graph) {
-                            for (const dep of mod.deps) {
-                                let arr = reverseIndex.get(dep);
-                                if (!arr) {
-                                    arr = [];
-                                    reverseIndex.set(dep, arr);
-                                }
-                                arr.push(id);
-                            }
-                        }
-                        // BFS from each non-tsx changed module up to tsx/jsx boundaries
-                        const boundaries = new Set();
-                        for (const id of drained) {
-                            if (/\.(tsx|jsx)$/i.test(id))
-                                continue; // already self-accepting
-                            const visited = new Set();
-                            const queue = [id];
-                            while (queue.length) {
-                                const cur = queue.shift();
-                                if (visited.has(cur))
-                                    continue;
-                                visited.add(cur);
-                                const importers = reverseIndex.get(cur);
-                                if (!importers)
-                                    continue;
-                                for (const imp of importers) {
-                                    if (/\.(tsx|jsx)$/i.test(imp)) {
-                                        boundaries.add(imp);
-                                    }
-                                    else {
-                                        queue.push(imp);
-                                    }
-                                }
-                            }
-                        }
-                        // Re-import each boundary so solid-refresh patchRegistry fires.
-                        // For route files (TanStack Router), capture the new Route export
-                        // and patch the router's existing route with the fresh loader.
-                        let routesPatchCount = 0;
-                        let discoveredRouter = null;
-                        // Discover router: try __ns_router global (set by createNativeScriptRouter),
-                        // then scan globalThis for any router-shaped object with routesById.
-                        const findRouter = () => {
-                            if (discoveredRouter)
-                                return discoveredRouter;
-                            const g = globalThis;
-                            if (g.__ns_router?.routesById)
-                                return (discoveredRouter = g.__ns_router);
-                            // Fallback: scan common global keys for router
-                            for (const key of ['__ns_router', 'router', '__router']) {
-                                if (g[key]?.routesById && g[key]?.invalidate)
-                                    return (discoveredRouter = g[key]);
-                            }
-                            return null;
-                        };
-                        // Convert boundary file path to TanStack Router fullPath.
-                        // e.g. /src/routes/posts.$postId.tsx → /posts/$postId
-                        const boundaryToFullPath = (bid) => {
-                            const m = bid.match(/\/src\/routes\/(.+)\.(tsx|jsx|ts|js)$/i);
-                            if (!m)
-                                return null;
-                            let p = m[1];
-                            // Replace dots between segments with slashes (posts.$postId → posts/$postId)
-                            p = p.replace(/\./g, '/');
-                            // Handle index files
-                            if (p === 'index')
-                                return '/';
-                            if (p.endsWith('/index'))
-                                p = p.slice(0, -6);
-                            // Strip leading - (TanStack pathless layout convention)
-                            p = p.replace(/(^|\/)-([\w])/g, '$1$2');
-                            return '/' + p;
-                        };
-                        // Find existing route by fullPath (since new Route has no id yet)
-                        const findRouteByFullPath = (router, fp) => {
-                            if (!router?.routesById)
-                                return null;
-                            for (const rid of Object.keys(router.routesById)) {
-                                const r = router.routesById[rid];
-                                if (r?.fullPath === fp)
-                                    return r;
-                            }
-                            return null;
-                        };
-                        // Evict the boundary set so re-importing each .tsx
-                        // component actually picks up the new transitive
-                        // dependency code; without this V8 returns the
-                        // cached boundary module unchanged.
-                        const boundaryIds = Array.from(boundaries);
-                        const solidEvictUrls = buildEvictionUrls(boundaryIds);
-                        const solidEvicted = invalidateModulesByUrls(solidEvictUrls);
-                        if (VERBOSE)
-                            console.log(`[hmr][solid] eviction count=${solidEvictUrls.length} ok=${solidEvicted}`);
-                        for (const id of boundaries) {
-                            if (seen.has(id))
-                                continue;
-                            try {
-                                const spec = normalizeSpec(id);
-                                const url = await requestModuleFromServer(spec);
-                                if (!url)
-                                    continue;
-                                if (VERBOSE)
-                                    console.log('[hmr][solid] propagated to boundary', { id, url });
-                                const mod = await import(/* @vite-ignore */ url);
-                                // Patch TanStack Router route loaders
-                                try {
-                                    const newRoute = mod?.Route;
-                                    if (newRoute?.options?.loader) {
-                                        const router = findRouter();
-                                        const fullPath = boundaryToFullPath(id);
-                                        if (VERBOSE)
-                                            console.log('[hmr][solid][diag] route patch attempt', { id, fullPath, hasRouter: !!router, routesByIdKeys: router?.routesById ? Object.keys(router.routesById) : 'none' });
-                                        const existingRoute = fullPath && router ? findRouteByFullPath(router, fullPath) : null;
-                                        if (existingRoute?.options) {
-                                            existingRoute.options.loader = newRoute.options.loader;
-                                            if (newRoute.options.component)
-                                                existingRoute.options.component = newRoute.options.component;
-                                            routesPatchCount++;
-                                            if (VERBOSE)
-                                                console.log('[hmr][solid] patched route loader', existingRoute.id, 'fullPath=', fullPath);
-                                        }
-                                        else if (VERBOSE) {
-                                            console.log('[hmr][solid] no matching route for fullPath', fullPath);
-                                        }
-                                    }
-                                }
-                                catch (e) {
-                                    if (VERBOSE)
-                                        console.warn('[hmr][solid] route patch error', id, e);
-                                }
-                            }
-                            catch (e) {
-                                if (VERBOSE)
-                                    console.warn('[hmr][solid] boundary re-import failed', id, e);
-                            }
-                        }
-                        // Route loaders were patched with fresh closures. The data is
-                        // correct in router.state.matches[].loaderData (confirmed via
-                        // diagnostics), but the currently visible page doesn't re-render
-                        // because the NativeScriptRouterProvider's Solid store flush only
-                        // fires through history.subscribe. TODO: find the right mechanism
-                        // to trigger a Solid reactive update for the active match stores.
-                        if (routesPatchCount > 0 && VERBOSE) {
-                            console.log('[hmr][solid] patched', routesPatchCount, 'route loaders (data correct in match state, pending UI refresh mechanism)');
-                        }
-                        if (VERBOSE) {
-                            if (boundaries.size)
-                                console.log('[hmr][solid] propagated non-component change to', boundaries.size, 'boundaries', Array.from(boundaries));
-                            console.log('[hmr][queue] Solid: modules re-imported, solid-refresh handles reactive update', drained);
-                        }
-                    }
-                    catch (e) {
-                        if (VERBOSE)
-                            console.warn('[hmr][solid] propagation failed', e);
-                    }
-                    break;
-                }
-                case 'typescript': {
-                    // For TS apps, always reset back to the conventional app root.
-                    // This preserves the shell (Frame, ActionBar, etc.) that the app's
-                    // own bootstrapping wires up via `Application.run`.
-                    try {
-                        const g = globalThis;
-                        const App = getCore('Application') || g.Application;
-                        if (!App || typeof App.resetRootView !== 'function') {
-                            if (VERBOSE)
-                                console.warn('[hmr][queue] TS flavor: Application.resetRootView unavailable; skipping UI refresh');
-                            break;
-                        }
-                        // Re-fetch changed XML/CSS files and update the bundled module registry
-                        // so Builder.createViewFromEntry picks up fresh content.
-                        const rawAssetIds = drained.filter((id) => /\.(xml|css|scss|sass|less)$/i.test(id));
-                        if (rawAssetIds.length && typeof g.registerModule === 'function') {
-                            const origin = getHttpOriginForVite() || deriveHttpOrigin(getHMRWsUrl());
-                            if (origin) {
-                                for (const id of rawAssetIds) {
-                                    try {
-                                        const spec = normalizeSpec(id);
-                                        // Fetch the raw file content directly from Vite's dev server.
-                                        // Use the project-relative path which Vite serves as static files.
-                                        const fetchUrl = origin + (spec.startsWith('/') ? spec : '/' + spec);
-                                        if (VERBOSE)
-                                            console.log('[hmr][queue] fetching raw asset', { id, fetchUrl });
-                                        const resp = await fetch(fetchUrl);
-                                        if (resp.ok) {
-                                            const rawContent = await resp.text();
-                                            // Register under all nickname variants the module registry uses.
-                                            // The bundler context registers XML as e.g., './main-page.xml' and 'main-page.xml'
-                                            const appVirtual = APP_VIRTUAL_WITH_SLASH.replace(/^\//, '');
-                                            let relPath = spec.startsWith('/') ? spec.slice(1) : spec;
-                                            if (relPath.startsWith(appVirtual))
-                                                relPath = relPath.slice(appVirtual.length);
-                                            const nicknames = ['./' + relPath, relPath];
-                                            // Also add without extension for CSS
-                                            const extIdx = relPath.lastIndexOf('.');
-                                            if (extIdx > 0) {
-                                                const baseName = relPath.slice(0, extIdx);
-                                                if (!relPath.endsWith('.xml'))
-                                                    nicknames.push(baseName, './' + baseName);
-                                            }
-                                            for (const name of nicknames) {
-                                                if (VERBOSE)
-                                                    console.log('[hmr][queue] re-registering module', name);
-                                                g.registerModule(name, () => rawContent);
-                                            }
-                                        }
-                                        else if (VERBOSE) {
-                                            console.warn('[hmr][queue] raw asset fetch failed', id, resp.status);
-                                        }
-                                    }
-                                    catch (e) {
-                                        if (VERBOSE)
-                                            console.warn('[hmr][queue] raw asset refresh failed for', id, e);
-                                    }
-                                }
-                            }
-                        }
-                        // Determine if we can navigate in-place to a changed page
-                        // instead of resetting all the way back to app-root.
-                        // This keeps the user on the page they're editing for faster iteration.
-                        const changedXmlPages = drained
-                            .filter((id) => /\.xml$/i.test(id))
-                            .map((id) => {
-                            const spec = normalizeSpec(id);
-                            const appVirtual = APP_VIRTUAL_WITH_SLASH.replace(/^\//, '');
-                            let relPath = spec.startsWith('/') ? spec.slice(1) : spec;
-                            if (relPath.startsWith(appVirtual))
-                                relPath = relPath.slice(appVirtual.length);
-                            // Strip .xml extension to get the moduleName (e.g., 'pages/status-bar')
-                            return relPath.replace(/\.xml$/i, '');
-                        })
-                            .filter((m) => m && m !== 'app-root');
-                        // Resolve the topmost Frame from the bundled realm.
-                        // Frame.topmost() relies on an internal frameStack array, so we must
-                        // call it on the bundled-realm class. Multiple strategies to find it:
-                        const FrameClass = getCore('Frame') || g.Frame;
-                        let topFrame = null;
-                        // 1) Try the vendor-realm static topmost()
-                        try {
-                            topFrame = FrameClass?.topmost?.();
-                        }
-                        catch { }
-                        // 2) Try getting the root view from Application — if it's a Frame, use it
-                        if (!topFrame) {
-                            try {
-                                const rootView = App.getRootView?.() || App._rootView;
-                                if (rootView) {
-                                    // rootView could be a Frame itself, or contain a Frame
-                                    const isFrame = rootView.constructor?.name === 'Frame' || rootView.navigate;
-                                    if (isFrame) {
-                                        topFrame = rootView;
-                                    }
-                                    else if (rootView.getChildAt) {
-                                        // Walk direct children looking for a Frame
-                                        for (let i = 0; i < (rootView.getChildrenCount?.() || 0); i++) {
-                                            const child = rootView.getChildAt(i);
-                                            if (child?.constructor?.name === 'Frame' || child?.navigate) {
-                                                topFrame = child;
-                                                break;
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            catch { }
-                        }
-                        if (VERBOSE)
-                            console.log('[hmr][queue] TS: changedXmlPages=', changedXmlPages, 'topFrame=', !!topFrame);
-                        if (changedXmlPages.length > 0 && topFrame) {
-                            // Navigate the current frame to the changed page directly.
-                            // Use the last changed XML page (most specific).
-                            const moduleName = changedXmlPages[changedXmlPages.length - 1];
-                            if (VERBOSE)
-                                console.log('[hmr][queue] TS: navigating in-place to', moduleName);
-                            try {
-                                topFrame.navigate({ moduleName, clearHistory: false, animated: false });
-                            }
-                            catch (navErr) {
-                                console.warn('[hmr][queue] TS flavor: in-place navigate failed, falling back to resetRootView', navErr);
-                                App.resetRootView({ moduleName: 'app-root' });
-                            }
-                        }
-                        else {
-                            if (VERBOSE)
-                                console.log('[hmr][queue] TS flavor: resetRootView(app-root) after changes');
-                            App.resetRootView({ moduleName: 'app-root' });
-                        }
-                    }
-                    catch (e) {
-                        console.warn('[hmr][queue] TS flavor: resetRootView(app-root) failed', e);
-                    }
-                    break;
-                }
-            }
-        }
-        finally {
-            processingQueue = false;
-            processingPromise = null;
-        }
-    })();
-    return processingPromise;
-}
-let hmrSocket = null;
-// Track server-announced batches for each version so we can import in-order client-side
-const txnClientBatches = new Map();
-// Public hook for NativeScript runtime to call from ImportModuleDynamicallyCallback later.
-globalThis.__nsHmrRequestModule = async function (spec) {
-    let normalized = normalizeSpec(spec);
-    // Remove extension for transform lookup variants (server will try .ts/.js/.mjs)
-    normalized = normalized.replace(/\.(ts|js|tsx|jsx|mjs)$/i, '');
-    if (!normalized.startsWith('/'))
-        normalized = '/' + normalized;
-    if (normalized === '@') {
-        // Soft-handle instead of throwing to avoid breaking evaluation paths: return a safe empty module stub.
-        try {
-            const err = new Error('[hmr-fetch] anomalous @ spec');
-            const stack = err.stack || '';
-            hmrMetrics.invalidAtSpec = (hmrMetrics.invalidAtSpec || 0) + 1;
-            console.warn('[hmr-fetch] refusing to fetch bare @ spec; returning stub; original=', spec, 'stack=\n' + stack);
-        }
-        catch { }
-        return '/__invalid_at__.mjs';
-    }
-    const url = await requestModuleFromServer(normalized);
-    return url;
-};
-function connectHmr() {
-    if (hmrSocket?.readyState === WebSocket.OPEN)
-        return;
-    if (hmrSocket?.readyState === WebSocket.CONNECTING) {
-        if (__NS_ENV_VERBOSE__)
-            console.log('[hmr-client] Already connecting to HMR WebSocket, skipping');
+// Install the device CSS applier. CSS-bearing modules (a Vue SFC `<style>` via
+// `/ns/asm`, an imported `.css` via `/ns/m`) call `__NS_REGISTER_CSS__(tag, css)`,
+// or queue in `__NS_PENDING_CSS__` if they ran first; the drain below covers that.
+// Routes through the shared `applyCssText` (tagged remove+add + root restyle),
+// the same path app.css and live `.css` edits use.
+function installCssRegister() {
+    const g = getGlobalScope();
+    if (typeof g.__NS_REGISTER_CSS__ === 'function') {
         return;
     }
-    try {
-        globalThis.__NS_HMR_CLIENT_SOCKET_READY__ = false;
-    }
-    catch { }
-    const overlayStage = hasOpenedHmrSocket ? 'reconnecting' : 'connecting';
-    const baseUrl = getHMRWsUrl() || 'ws://localhost:5173/ns-hmr';
-    const buildCandidates = (url) => {
-        let candidates = [];
-        try {
-            const u = new URL(url);
-            const proto = u.protocol === 'wss:' ? ['wss'] : ['ws'];
-            const defaultPort = u.port || '5173';
-            // Build ordered host candidates with preference to the active HTTP origin
-            const orderedHosts = [];
-            try {
-                const g = globalThis;
-                const httpOrigin = g && typeof g.__NS_HTTP_ORIGIN__ === 'string' ? g.__NS_HTTP_ORIGIN__ : undefined;
-                if (httpOrigin) {
-                    try {
-                        const ho = new URL(httpOrigin);
-                        orderedHosts.push({
-                            host: ho.hostname,
-                            port: ho.port || defaultPort,
-                        });
-                    }
-                    catch { }
-                }
-            }
-            catch { }
-            // From provided URL
-            orderedHosts.push({ host: u.hostname, port: defaultPort });
-            // Explicit override
-            try {
-                const h = globalThis.__NS_HMR_HOST;
-                if (h)
-                    orderedHosts.push({ host: String(h), port: defaultPort });
-            }
-            catch { }
-            // Common fallbacks
-            orderedHosts.push({ host: '10.0.2.2', port: defaultPort });
-            orderedHosts.push({ host: 'localhost', port: defaultPort });
-            const seen = new Set();
-            for (const p of proto) {
-                for (const { host, port } of orderedHosts) {
-                    const key = `${host}:${port}`;
-                    if (seen.has(key))
-                        continue;
-                    seen.add(key);
-                    const cand = `${p}://${host}:${port}${u.pathname || '/ns-hmr'}${u.search || ''}`;
-                    candidates.push(cand);
-                }
-            }
-        }
-        catch {
-            candidates.push(url);
-        }
-        // Deduplicate while preserving order
-        const seen = new Set();
-        return candidates.filter((c) => (seen.has(c) ? false : (seen.add(c), true)));
-    };
-    const candidates = buildCandidates(baseUrl);
-    let idx = 0;
-    const tryNext = () => {
-        if (idx >= candidates.length) {
-            showConnectionOverlayNow('offline', 'Waiting for the Vite websocket to come back.');
-            console.warn('[hmr-client] All WS candidates failed:', candidates.join(', '));
-            setTimeout(connectHmr, 1500);
+    const apply = (tag, cssText) => {
+        if (typeof cssText !== 'string' || !cssText.length) {
             return;
         }
-        const url = candidates[idx++];
-        const connectionDetail = `${overlayStage === 'reconnecting' ? 'Retrying' : 'Opening'} ${url}`;
-        if (connectionOverlayVisible) {
-            updateConnectionOverlay(overlayStage, connectionDetail);
-        }
-        else {
-            scheduleConnectionOverlay(overlayStage, connectionDetail);
-        }
         try {
-            if (__NS_ENV_VERBOSE__)
-                console.log('[hmr-client] Connecting to HMR WebSocket:', url);
-            const sock = new WebSocket(url);
-            hmrSocket = sock;
-            setHttpOriginForVite(deriveHttpOrigin(url));
-            let opened = false;
-            const timeout = setTimeout(() => {
-                if (!opened && sock.readyState !== WebSocket.OPEN) {
-                    try {
-                        sock.close();
-                    }
-                    catch { }
-                    if (VERBOSE)
-                        console.warn('[hmr-client] WS connect timeout, trying next…');
-                    tryNext();
-                }
-            }, 3500);
-            sock.onopen = () => {
-                opened = true;
-                clearTimeout(timeout);
-                clearConnectionOverlayTimer();
-                hasOpenedHmrSocket = true;
-                awaitingHealthyHmrMessage = true;
-                try {
-                    globalThis.__NS_HMR_CLIENT_SOCKET_READY__ = true;
-                }
-                catch { }
-                if (connectionOverlayVisible) {
-                    showConnectionOverlayNow('synchronizing', 'Connected. Synchronizing the HMR graph.');
-                }
-                VERBOSE && console.log('[hmr-client] Connected to HMR WebSocket');
-                // Print the active module reload mode once on first
-                // successful connect so the user can correlate HMR latency
-                // with runtime capability without grepping for protocol
-                // details. The banner is verbose-gated.
-                try {
-                    emitHmrModeBannerOnce();
-                }
-                catch { }
-            };
-            sock.onmessage = handleHmrMessage;
-            sock.onerror = (error) => {
-                clearTimeout(timeout);
-                console.warn('[hmr-client] WebSocket error:', (error && (error.message || error)) || error);
-            };
-            sock.onclose = (ev) => {
-                clearTimeout(timeout);
-                try {
-                    globalThis.__NS_HMR_CLIENT_SOCKET_READY__ = false;
-                }
-                catch { }
-                if (!opened) {
-                    // immediate failure during connect → try another candidate
-                    if (VERBOSE)
-                        console.warn('[hmr-client] WS close before open (code', ev?.code, '), trying next…');
-                    tryNext();
-                }
-                else {
-                    if (VERBOSE)
-                        console.log('[hmr-client] WebSocket closed (code', ev?.code, '), will reconnect…');
-                    scheduleConnectionOverlay('reconnecting', 'The websocket closed. Waiting to reconnect.', 700);
-                    // try to reconnect with full candidate list again
-                    setTimeout(connectHmr, 1000);
-                }
-            };
+            applyCssText(cssText, tag);
         }
-        catch (e) {
-            console.warn('[hmr-client] Failed to connect WebSocket', e);
-            tryNext();
+        catch (cssErr) {
+            if (VERBOSE)
+                console.warn('[ns-hmr] CSS register/apply failed for', tag, cssErr?.message || cssErr);
         }
     };
-    tryNext();
-}
-async function handleHmrMessage(ev) {
-    let msg;
-    try {
-        msg = JSON.parse(ev.data);
-    }
-    catch {
-        return;
-    }
-    if (awaitingHealthyHmrMessage && msg) {
-        markHmrConnectionHealthy();
-    }
-    if (VERBOSE && msg?.type) {
-        console.log('[hmr-client] received message', msg.type);
-    }
-    // Notify optional app-level hook after an HMR batch is applied.
-    function notifyAppHmrUpdate(kind, changedIds) {
-        try {
-            const hook = globalThis.__NS_HMR_ON_UPDATE__;
-            if (typeof hook === 'function') {
-                hook({ type: kind, version: getGraphVersion(), changedIds: changedIds || [], raw: msg });
-            }
-        }
-        catch { }
-    }
-    if (msg) {
-        // `ns:hmr-pending` is a fire-and-forget UX hint emitted by the
-        // server at the START of handleHotUpdate. We drive the
-        // HMR-applying overlay's 'received' frame here (synchronously),
-        // well before the authoritative payload (`ns:angular-update` /
-        // `ns:css-updates`) lands. Skip running any other handlers —
-        // the pending message has no module payload and intentionally
-        // does not bump the graph version.
-        if (msg.type === 'ns:hmr-pending' && typeof msg.path === 'string') {
-            setHmrPendingOverlay(msg.path);
-            return;
-        }
-        if (msg.type === 'ns:hmr-full-graph') {
-            // Bump a monotonic nonce so HTTP ESM imports can always be cache-busted per update.
-            try {
-                const g = globalThis;
-                g.__NS_HMR_IMPORT_NONCE__ = (typeof g.__NS_HMR_IMPORT_NONCE__ === 'number' ? g.__NS_HMR_IMPORT_NONCE__ : 0) + 1;
-            }
-            catch { }
-            // Capture previous graph snapshot so we can infer which modules changed.
-            const prevGraph = new Map(graph);
-            setGraphVersion(Number(msg.version || getGraphVersion() || 0));
-            applyFullGraph(msg);
-            hasReceivedFullGraph = true;
-            // Gate: On first boot, the entry-runtime handles all initial module loading
-            // (with the import map already configured). Don't re-import here — the graph
-            // is stored above for future HMR delta comparisons, but modules are already
-            // loaded correctly via the entry-runtime boot sequence.
-            //
-            // Two cases to catch:
-            // 1. Boot still in progress (__NS_HMR_BOOT_COMPLETE__ is false)
-            // 2. Boot already finished but this is the FIRST full-graph (prevGraph was
-            //    empty). The WebSocket often connects after entry-runtime finishes, so
-            //    boot is "complete" but we still shouldn't re-import — all modules were
-            //    just loaded fresh. Only re-import on subsequent full-graphs (reconnect
-            //    scenarios) where prevGraph already has entries.
-            if (!globalThis.__NS_HMR_BOOT_COMPLETE__) {
-                if (VERBOSE)
-                    console.info('[hmr][full-graph] skipping initial re-import (boot in progress)');
-                const fullIds = Array.isArray(msg.modules) ? msg.modules.map((m) => m?.id).filter(Boolean) : [];
-                notifyAppHmrUpdate('full-graph', fullIds);
-                return;
-            }
-            if (prevGraph.size === 0) {
-                if (VERBOSE)
-                    console.info('[hmr][full-graph] skipping re-import on first graph after boot (modules already fresh)');
-                const fullIds = Array.isArray(msg.modules) ? msg.modules.map((m) => m?.id).filter(Boolean) : [];
-                notifyAppHmrUpdate('full-graph', fullIds);
-                return;
-            }
-            // Reconnect / resync case — re-import changed modules as normal.
-            // In some cases (e.g. server chooses full-graph resync / page reload), we won't
-            // receive a delta queue to re-import changed TS modules. Without re-import,
-            // HTTP ESM caching means module bodies (and side effects) won't re-run.
-            try {
-                const inferredChanged = [];
-                try {
-                    for (const [id, next] of graph.entries()) {
-                        const prev = prevGraph.get(id);
-                        if (!prev || prev.hash !== next.hash)
-                            inferredChanged.push(id);
-                    }
-                    // Removed modules are also "changed" but we don't import them.
-                }
-                catch { }
-                // Best-effort: only re-import real source modules (avoid .vue registry pipeline and virtual ids)
-                const toReimport = inferredChanged.filter((id) => {
-                    if (!id || typeof id !== 'string')
-                        return false;
-                    if (/^\0|^\/\0/.test(id))
-                        return false;
-                    if (/plugin-vue:export-helper/.test(id))
-                        return false;
-                    if (/\.vue$/i.test(id))
-                        return false;
-                    if (id.endsWith(APP_MAIN_ENTRY_SPEC))
-                        return false;
-                    return true;
-                });
-                if (toReimport.length && VERBOSE)
-                    console.log('[hmr][full-graph] inferred changed modules; re-importing', toReimport);
-                // Evict the inferred changed set before re-importing.
-                // See `processQueue` for the architectural rationale; the
-                // full-graph code path is the resync fallback (server chose
-                // not to send a delta) and shares the same V8 cache pitfall.
-                const fgEvictUrls = buildEvictionUrls(toReimport);
-                const fgEvicted = invalidateModulesByUrls(fgEvictUrls);
-                if (VERBOSE)
-                    console.log(`[hmr][full-graph] eviction count=${fgEvictUrls.length} ok=${fgEvicted}`);
-                for (const id of toReimport) {
-                    try {
-                        const spec = normalizeSpec(id);
-                        const url = await requestModuleFromServer(spec);
-                        if (!url)
-                            continue;
-                        if (VERBOSE)
-                            console.log('[hmr][full-graph] re-import', { id, spec, url });
-                        await import(/* @vite-ignore */ url);
-                    }
-                    catch (e) {
-                        if (VERBOSE)
-                            console.warn('[hmr][full-graph] re-import failed for', id, e);
-                    }
-                }
-            }
-            catch { }
-            const fullIds = Array.isArray(msg.modules) ? msg.modules.map((m) => m?.id).filter(Boolean) : [];
-            notifyAppHmrUpdate('full-graph', fullIds);
-            return;
-        }
-        if (msg.type === 'ns:ts-module-registry') {
-            try {
-                const mods = Array.isArray(msg.modules) ? msg.modules.filter((m) => typeof m === 'string') : [];
-                if (mods.length) {
-                    if (!tsModuleSet)
-                        tsModuleSet = new Set();
-                    mods.forEach((m) => tsModuleSet.add(m));
-                    // Prefer explicit app main entry if present, else first module
-                    if (mods.includes(APP_MAIN_ENTRY_SPEC)) {
-                        tsMainId = APP_MAIN_ENTRY_SPEC;
-                    }
-                    else if (!tsMainId) {
-                        tsMainId = mods[0];
-                    }
-                    if (VERBOSE)
-                        console.log('[hmr-client][ts-registry] registered TS modules', {
-                            count: tsModuleSet.size,
-                            mainId: tsMainId,
-                        });
-                }
-            }
-            catch (e) {
-                if (VERBOSE)
-                    console.warn('[hmr-client][ts-registry] failed to record', e);
-            }
-            return;
-        }
-        if (msg.type === 'ns:hmr-delta') {
-            // Bump a monotonic nonce so HTTP ESM imports can always be cache-busted per update.
-            try {
-                const g = globalThis;
-                g.__NS_HMR_IMPORT_NONCE__ = (typeof g.__NS_HMR_IMPORT_NONCE__ === 'number' ? g.__NS_HMR_IMPORT_NONCE__ : 0) + 1;
-            }
-            catch { }
-            try {
-                const ids = Array.isArray(msg.changed) ? msg.changed.map((c) => c?.id).filter(Boolean) : [];
-                if (ids.length)
-                    txnClientBatches.set(getGraphVersion(), ids);
-            }
-            catch { }
-            applyDelta(msg);
-            // Ensure queued module re-imports complete before notifying app hooks.
-            // Otherwise app-level handlers can run against stale module bodies due to HTTP ESM caching.
-            try {
-                await processQueue();
-            }
-            catch { }
-            const deltaIds = Array.isArray(msg.changed) ? msg.changed.map((c) => c?.id).filter(Boolean) : [];
-            notifyAppHmrUpdate('delta', deltaIds);
-            return;
-        }
-        else {
-            if (msg.type === 'ns:angular-update' && typeof msg.version === 'number') {
-                setGraphVersion(Number(msg.version || getGraphVersion() || 0));
-            }
-            if (await handleAngularHotUpdateMessage(msg, { getCore, verbose: VERBOSE })) {
-                return;
-            }
-        }
-    }
-    // On-demand module fetch response (Option A)
-    if (msg.type === 'ns:module-response' && typeof msg.requestId === 'number') {
-        const pending = pendingModuleFetches.get(msg.requestId);
-        if (pending) {
-            pendingModuleFetches.delete(msg.requestId);
-            if (msg.error) {
-                if (VERBOSE)
-                    console.warn('[hmr-fetch] error', msg.error, 'spec=', pending.spec, 'id=', msg.requestId);
-                pending.reject(new Error(`[hmr-fetch] ${msg.error} for ${pending.spec}`));
-            }
-            else {
-                try {
-                    const origin = getHttpOriginForVite() || deriveHttpOrigin(getHMRWsUrl());
-                    if (!origin)
-                        throw new Error('no-http-origin');
-                    const url = origin + '/ns/m' + (String(pending.spec).startsWith('/') ? pending.spec : '/' + pending.spec);
-                    moduleFetchCache.set(pending.spec, url);
-                    if (VERBOSE)
-                        console.log('[hmr-fetch] resolved via URL', pending.spec, '->', url, 'id=', msg.requestId);
-                    pending.resolve(url);
-                }
-                catch (e) {
-                    pending.reject(e);
-                }
-            }
-        }
-        return;
-    }
-    if (msg.type === 'ns:css-updates' && Array.isArray(msg.updates)) {
-        try {
-            const origin = msg.origin || getHttpOriginForVite() || deriveHttpOrigin(getHMRWsUrl());
-            await handleCssUpdates(msg.updates, origin);
-            return;
-        }
-        catch (e) {
-            console.warn('[hmr-client] CSS updates handling failed:', e);
-            return;
-        }
-    }
-    if (msg.type === 'ns:vue-sfc-registry') {
-        handleVueSfcRegistry(msg);
-        return;
-    }
-    if (msg.type === 'ns:vue-sfc-registry-update') {
-        if (typeof msg.version === 'number')
-            setGraphVersion(msg.version);
-        const comp = await handleVueSfcRegistryUpdate(msg, getGraphVersion());
-        if (comp) {
-            await performResetRoot(comp);
-        }
-        return;
-    }
-}
-function normalizeComponent(input, nameHint) {
+    g.__NS_REGISTER_CSS__ = apply;
     try {
-        if (!input)
-            return null;
-        // Unwrap module namespace with default
-        if (input && typeof input === 'object' && 'default' in input) {
-            const d = input.default;
-            if (d)
-                return normalizeComponent(d, nameHint);
-        }
-        // If already a component-like object with render/setup/template, return as-is
-        if (typeof input === 'object' && (input.render || input.setup || input.template || input.__isVue)) {
-            return input;
-        }
-        // If provided a render function, wrap with defineComponent
-        if (typeof input === 'function') {
-            ensureVueGlobals();
-            const comp = globalThis.defineComponent
-                ? globalThis.defineComponent({
-                    name: nameHint || input.name || 'AnonymousSFC',
-                    render: input,
-                })
-                : { name: nameHint || input.name || 'AnonymousSFC', render: input };
-            return comp;
-        }
-        // If object has a render function property
-        if (input?.render && typeof input.render === 'function') {
-            ensureVueGlobals();
-            const comp = globalThis.defineComponent
-                ? globalThis.defineComponent({
-                    name: nameHint || input.name || 'AnonymousSFC',
-                    render: input.render,
-                })
-                : {
-                    name: nameHint || input.name || 'AnonymousSFC',
-                    render: input.render,
-                };
-            return comp;
-        }
-    }
-    catch { }
-    return input;
-}
-async function performResetRoot(newComponent) {
-    const tStart = Date.now();
-    // Guard against re-entrant or rapid successive resets
-    try {
-        globalThis.__NS_DEV_RESET_IN_PROGRESS__ = true;
-    }
-    catch { }
-    try {
-        ensureCoreAliasesOnGlobalThis();
-    }
-    catch { }
-    if (VERBOSE) {
-        console.log('[hmr-client] Single-path: replace current root Page');
-        console.log('[hmr-client] Component details:', {
-            componentName: newComponent?.__name,
-            componentFile: newComponent?.__file,
-            hasRender: !!newComponent?.render,
-            hasSetup: !!newComponent?.setup,
-            componentKeys: Object.keys(newComponent || {}),
-        });
-    }
-    function createRootFactory() {
-        let rootKind = 'page';
-        let cachedRoot = undefined;
-        const state = {
-            getRootKind: () => rootKind,
-            setRootKind: (k) => {
-                rootKind = k;
-            },
-            getCachedRoot: () => cachedRoot,
-            setCachedRoot: (r) => {
-                cachedRoot = r;
-            },
-        };
-        const factory = {
-            get kind() {
-                return rootKind;
-            },
-            create: () => {
-                if (cachedRoot)
-                    return cachedRoot;
-                try {
-                    switch (TARGET_FLAVOR) {
-                        case 'vue':
-                            cachedRoot = getRootForVue(newComponent, state);
-                            break;
-                        case 'typescript': {
-                            // For TS flavor, treat the component as a factory or direct NS view.
-                            let root = null;
-                            try {
-                                if (typeof newComponent === 'function') {
-                                    root = newComponent();
-                                }
-                                else {
-                                    root = newComponent;
-                                }
-                            }
-                            catch (e) {
-                                console.warn('[hmr-client][ts] root factory invocation failed', e);
-                            }
-                            cachedRoot = root || {};
-                            // Heuristic: if the root "looks" like a Frame, prefer frame semantics
-                            try {
-                                const name = String(cachedRoot?.constructor?.name || '').replace(/^_+/, '');
-                                if (/^Frame(\$\d+)?$/.test(name)) {
-                                    rootKind = 'frame';
-                                }
-                            }
-                            catch { }
-                            break;
-                        }
-                    }
-                    return cachedRoot;
-                }
-                catch (e) {
-                    console.warn('[hmr-client] createRootFactory failed', e);
-                    if (VERBOSE)
-                        console.warn('[hmr-client] [createRoot] stack', e?.stack);
-                    const GPage = getCore('Page');
-                    rootKind = 'page';
-                    cachedRoot = GPage ? new GPage() : {};
-                    return cachedRoot;
-                }
-            },
-        };
-        return factory;
-    }
-    // Android readiness before any root changes
-    const App = getCore('Application') || globalThis.Application;
-    const isAndroid = !!(App && App.android !== undefined);
-    if (isAndroid) {
-        const isReady = () => {
-            try {
-                const a = App.android;
-                const act = a && (a.foregroundActivity || a.startActivity);
-                return !!act;
-            }
-            catch {
-                return false;
-            }
-        };
-        const waitFor = async (pred, ms = 6000, step = 60) => {
-            const start = Date.now();
-            while (Date.now() - start < ms) {
-                if (pred())
-                    return true;
-                await new Promise((r) => setTimeout(r, step));
+        const pending = g.__NS_PENDING_CSS__;
+        if (pending && typeof pending === 'object') {
+            for (const tag of Object.keys(pending)) {
+                apply(tag, pending[tag]);
             }
-            return pred();
-        };
-        const withEvents = async (ms = 6000) => {
-            try {
-                const a = App.android;
-                if (!a || typeof a.on !== 'function' || typeof a.off !== 'function') {
-                    if (VERBOSE)
-                        console.log('[hmr-client] [android] events API not available; polling');
-                    return await waitFor(isReady, ms, 60);
-                }
-                if (isReady()) {
-                    if (VERBOSE)
-                        console.log('[hmr-client] [android] activity already ready');
-                    return true;
-                }
-                return await new Promise((resolve) => {
-                    let done = false;
-                    const tWait = Date.now();
-                    const finish = (ok) => {
-                        if (done)
-                            return;
-                        done = true;
-                        try {
-                            a.off(a.activityStartedEvent || 'activityStarted', onAny);
-                            a.off(a.activityResumedEvent || 'activityResumed', onAny);
-                        }
-                        catch { }
-                        if (VERBOSE)
-                            console.log('[hmr-client] [android] readiness result', {
-                                ok,
-                                elapsedMs: Date.now() - tWait,
-                            });
-                        resolve(ok);
-                    };
-                    const onAny = (evt) => {
-                        if (VERBOSE)
-                            console.log('[hmr-client] [android] activity event', {
-                                type: evt?.eventName || 'unknown',
-                            });
-                        if (isReady())
-                            finish(true);
-                    };
-                    try {
-                        a.on(a.activityStartedEvent || 'activityStarted', onAny);
-                        a.on(a.activityResumedEvent || 'activityResumed', onAny);
-                        if (VERBOSE)
-                            console.log('[hmr-client] [android] waiting for activity events…');
-                    }
-                    catch {
-                        return resolve(waitFor(isReady, ms, 60));
-                    }
-                    setTimeout(() => finish(isReady()), ms);
-                });
-            }
-            catch {
-                return await waitFor(isReady, ms, 60);
-            }
-        };
-        const ok = await withEvents(6000);
-        if (!ok && VERBOSE)
-            console.warn('[hmr-client] [android] activity not ready; proceeding with best-effort');
-    }
-    // Create the new root first to determine whether it is a Page or a Frame
-    const rootFactory = createRootFactory();
-    const preparedRoot = rootFactory.create();
-    const isFrameRoot = (() => {
-        try {
-            const name = String(preparedRoot?.constructor?.name || '').replace(/^_+/, '');
-            return /^Frame(\$\d+)?$/.test(name);
+            g.__NS_PENDING_CSS__ = null;
         }
-        catch {
-            return false;
-        }
-    })();
-    // Prefer resetRootView on initial boot (placeholder present) or on iOS to avoid early createRootView races
-    let hadPlaceholder = false;
-    let isIOS = false;
-    try {
-        hadPlaceholder = !!globalThis.__NS_DEV_PLACEHOLDER_ROOT_EARLY__;
     }
     catch { }
-    try {
-        const AppAny = getCore('Application') || globalThis.Application;
-        isIOS = !!(AppAny && AppAny.ios !== undefined);
-    }
-    catch { }
-    // Preferred policy:
-    // - If this is the very first mount (placeholder present), or if the new root is a Frame,
-    //   perform a full root replacement via resetRootView so we never couple with the placeholder.
-    // - Otherwise (subsequent HMR updates with an authoritative Frame already in place), re-use the
-    //   current app Frame and navigate to the new Page. This avoids a brief flash that can occur
-    //   when swapping the entire root view on Android. The placeholder is never involved here.
-    const gAnyForPolicy = globalThis;
-    const placeholderFrame = (() => {
-        try {
-            return gAnyForPolicy.__NS_DEV_PLACEHOLDER_ROOT_VIEW__ || null;
-        }
-        catch {
-            return null;
-        }
-    })();
-    let existingAppFrame = null;
-    try {
-        existingAppFrame = getRootFrame() || getCore('Frame')?.topmost?.() || null;
-    }
-    catch { }
-    const isAuthoritativeFrame = !!existingAppFrame && existingAppFrame !== placeholderFrame;
-    if (!hadPlaceholder && !isFrameRoot && isAuthoritativeFrame && typeof existingAppFrame.navigate === 'function') {
-        try {
-            const navEntry = {
-                create: () => preparedRoot,
-                clearHistory: true,
-                animated: false,
-            };
-            existingAppFrame.navigate(navEntry);
-            setRootFrame(existingAppFrame);
-            return true;
-        }
-        catch (e) {
-            console.warn('[hmr-client] authoritative navigate fallback to resetRootView due to error', e);
-        }
-    }
-    if (VERBOSE)
-        console.log('[hmr-client] full root replacement via resetRootView (placeholder will be discarded)', { isFrameRoot, isIOS, hadPlaceholder });
-    // Fallback or preferred path: resetRootView with a creator that builds a fresh Frame and navigates to the new Page
-    try {
-        const App2 = getCore('Application') || globalThis.Application;
-        if (!App2 || typeof App2.resetRootView !== 'function') {
-            console.warn('[hmr-client] Application.resetRootView unavailable');
-            return false;
-        }
-        // iOS-specific: if the cached window was left in an invalid state (boolean false), clear it so
-        // setWindowContent can recreate a proper UIWindow. This can occur in rare early-boot races.
-        try {
-            const isIos = !!(App2 && App2.ios !== undefined);
-            if (isIos) {
-                let win = undefined;
-                try {
-                    win = App2.window;
-                }
-                catch { }
-                if (win === false) {
-                    if (VERBOSE)
-                        console.warn('[hmr-client] iOS Application.window is boolean false; attempting to clear cached window');
-                    try {
-                        const g = globalThis;
-                        const reg = g.__nsVendorRegistry;
-                        const req = reg?.get ? g.__nsVendorRequire || g.__nsRequire || g.require : g.__nsRequire || g.require;
-                        let helpers = null;
-                        // Try vendor registry first
-                        if (reg && reg.has('@nativescript/core/application/helpers-common')) {
-                            helpers = reg.get('@nativescript/core/application/helpers-common');
-                        }
-                        // Fallback to device require
-                        if (!helpers && typeof req === 'function') {
-                            try {
-                                helpers = req('@nativescript/core/application/helpers-common');
-                            }
-                            catch { }
-                        }
-                        const setter = helpers && (helpers.setiOSWindow || helpers.default?.setiOSWindow);
-                        if (typeof setter === 'function') {
-                            try {
-                                setter(undefined);
-                                if (VERBOSE)
-                                    console.log('[hmr-client] cleared cached iOS window via helpers-common');
-                            }
-                            catch { }
-                        }
-                    }
-                    catch { }
-                }
-            }
-        }
-        catch { }
-        // Use the previously created preparedRoot
-        const entry = {
-            create: () => {
-                if (!isFrameRoot) {
-                    const F = getCore('Frame');
-                    const fr = new F();
-                    if (VERBOSE)
-                        console.log('[hmr-client] resetRootView:create new Frame', {
-                            type: fr?.constructor?.name,
-                        });
-                    const navEntry = {
-                        create: () => preparedRoot,
-                        clearHistory: true,
-                        animated: false,
-                    };
-                    try {
-                        fr.navigate(navEntry);
-                    }
-                    catch (e) {
-                        console.warn('[hmr-client] resetRootView:create navigate failed', e);
-                    }
-                    setRootFrame(fr);
-                    return fr;
-                }
-                else {
-                    const fr = preparedRoot;
-                    setRootFrame(fr);
-                    return fr;
-                }
-            },
-        };
-        // Always use an entry with a create() function to avoid cross‑realm instanceof checks on Android.
-        App2.resetRootView(entry);
-        // After authoritative reset, it's safe to detach the early placeholder launch handler
-        try {
-            const restore = globalThis.__NS_DEV_RESTORE_PLACEHOLDER__;
-            if (typeof restore === 'function') {
-                restore();
-            }
-        }
-        catch { }
-        return true;
-    }
-    catch (e) {
-        console.warn('[hmr-client] resetRootView failed', e);
-        try {
-            if (VERBOSE)
-                console.warn('[hmr-client] resetRootView stack', e?.stack);
-        }
-        catch { }
-        return false;
-    }
-    finally {
-        try {
-            globalThis.__NS_DEV_RESET_IN_PROGRESS__ = false;
-        }
-        catch { }
-    }
 }
+installCssRegister();
+// Route incoming socket messages through the protocol dispatcher.
+setHmrMessageHandler(handleHmrMessage);
 export function initHmrClient(opts) {
     if (opts?.wsUrl) {
         setHMRWsUrl(opts.wsUrl);
@@ -2029,12 +132,9 @@ export function initHmrClient(opts) {
             console.log('[hmr-client] deferring WebSocket connection until boot completes');
         setTimeout(waitForBoot, 100);
     }
-    // Best-effort: install back wrapper even before first remount; original root may be captured later
-    switch (TARGET_FLAVOR) {
-        case 'vue':
-            ensureBackWrapperInstalled(performResetRoot, getCore);
-            break;
-    }
+    // Best-effort: install back wrapper even before first remount; original root may be captured later.
+    // Deferred until the dynamically-imported strategy resolves.
+    void CLIENT_STRATEGY_READY.then(() => getClientStrategy()?.installBackWrapper?.(performResetRoot, getCore));
 }
 export default function startViteHMR(opts) {
     if (VERBOSE)