@nativescript/vite 8.0.0-beta.0 → 8.0.0-rc.0

package/hmr/client/index.js

@@ -1,1445 +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 } from './utils.js';
-import { handleCssUpdates } from './css-handler.js';
-const VERBOSE = typeof __NS_ENV_VERBOSE__ !== 'undefined' && __NS_ENV_VERBOSE__;
-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)
-                g.Application = A;
-        }
-        catch { }
-        try {
-            if (P && !g.Page)
-                g.Page = P;
-        }
-        catch { }
-    }
-    catch { }
-}
-// Apply once on module evaluation
 ensureCoreAliasesOnGlobalThis();
-/**
- * Flavor hooks
- */
-import { installNsVueDevShims, ensureBackWrapperInstalled, getRootForVue, loadSfcComponent, ensureVueGlobals, ensurePiniaOnApp, addSfcMapping, recordVuePayloadChanges, handleVueSfcRegistry, handleVueSfcRegistryUpdate } from '../frameworks/vue/client/index.js';
-import { handleAngularHotUpdateMessage, installAngularHmrClientHooks } from '../frameworks/angular/client/index.js';
-switch (__NS_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__;
-// 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.
-    try {
-        const g = globalThis;
-        const bootDone = !!g.__NS_HMR_BOOT_COMPLETE__;
-        if (!bootDone && !initialMounted && !initialMounting && !g.__NS_HMR_RESCUE_SCHEDULED__) {
-            // 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 (__NS_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 (__NS_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;
-                                    }
-                                }
-                            }
-                            break;
-                        }
-                    }
-                    if (!candidate)
-                        return;
-                    initialMounting = true;
-                    try {
-                        g.__NS_HMR_INITIAL_MOUNT_IN_PROGRESS__ = true;
-                    }
-                    catch { }
-                    (async () => {
-                        try {
-                            let comp = null;
-                            switch (__NS_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.
+// Late-registration bridge for one-shot iOS launch notifications
+// (see shared/runtime/launch-bridge.ts).
+//
+// 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 {
-        // 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 (__NS_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;
-                            }
-                        }
-                    }
-                    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=', __NS_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 (__NS_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', __NS_TARGET_FLAVOR__);
-            }
-        }
+        wrappedAny = installLaunchNotificationBridge(explicitApplication, [getCore('Application')]);
     }
     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 (__NS_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) {
-        // 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();
+    if (!wrappedAny && attempts > 0) {
+        setTimeout(() => tryInstallLaunchNotificationBridge(attempts - 1, explicitApplication), 100);
     }
 }
-// Deterministic navigation using the current Vue app instance rather than vendor-held rootApp
-function __nsNavigateUsingApp(comp, opts = {}) {
-    const g = globalThis;
-    switch (__NS_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');
-    }
-    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,
-            });
-    }
-    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 (__NS_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 (!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);
-            // 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 (__NS_TARGET_FLAVOR__) {
-                case 'vue':
-                    // Vue SFCs are handled via the registry update path; nothing to do here.
-                    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;
-                        }
-                        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;
     }
-    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'}`;
-                    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) {
-            console.warn('[hmr-client] All WS candidates failed:', candidates.join(', '));
+    const apply = (tag, cssText) => {
+        if (typeof cssText !== 'string' || !cssText.length) {
             return;
         }
-        const url = candidates[idx++];
         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);
-                VERBOSE && console.log('[hmr-client] Connected to HMR WebSocket');
-            };
-            sock.onmessage = handleHmrMessage;
-            sock.onerror = (error) => {
-                clearTimeout(timeout);
-                console.warn('[hmr-client] WebSocket error:', (error && (error.message || error)) || error);
-            };
-            sock.onclose = (ev) => {
-                clearTimeout(timeout);
-                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…');
-                    // 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;
+    g.__NS_REGISTER_CSS__ = apply;
     try {
-        msg = JSON.parse(ev.data);
-    }
-    catch {
-        return;
-    }
-    // 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 });
+        const pending = g.__NS_PENDING_CSS__;
+        if (pending && typeof pending === 'object') {
+            for (const tag of Object.keys(pending)) {
+                apply(tag, pending[tag]);
             }
+            g.__NS_PENDING_CSS__ = null;
         }
-        catch { }
-    }
-    if (msg) {
-        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);
-            // 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);
-                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 (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) {
-    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 (__NS_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));
-            }
-            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);
-        }
-        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);
@@ -1455,13 +111,30 @@ export function initHmrClient(opts) {
     }
     g.__NS_HMR_CLIENT_ACTIVE__ = true;
     ensureCoreAliasesOnGlobalThis();
-    connectHmr();
-    // Best-effort: install back wrapper even before first remount; original root may be captured later
-    switch (__NS_TARGET_FLAVOR__) {
-        case 'vue':
-            ensureBackWrapperInstalled(performResetRoot, getCore);
-            break;
+    // Defer WebSocket connection until boot completes to avoid native V8 crashes
+    // caused by concurrent WebSocket message handling + HTTP fetch during early startup.
+    // The WebSocket is only needed for HMR updates, not the initial boot sequence.
+    if (g.__NS_HMR_BOOT_COMPLETE__) {
+        connectHmr();
+    }
+    else {
+        const waitForBoot = () => {
+            if (globalThis.__NS_HMR_BOOT_COMPLETE__) {
+                if (VERBOSE)
+                    console.log('[hmr-client] boot complete, connecting HMR WebSocket');
+                connectHmr();
+            }
+            else {
+                setTimeout(waitForBoot, 100);
+            }
+        };
+        if (VERBOSE)
+            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.
+    // Deferred until the dynamically-imported strategy resolves.
+    void CLIENT_STRATEGY_READY.then(() => getClientStrategy()?.installBackWrapper?.(performResetRoot, getCore));
 }
 export default function startViteHMR(opts) {
     if (VERBOSE)