@nativescript/vite 8.0.0-alpha.9 → 8.0.0-dev.0

package/hmr/shared/runtime/root-placeholder.js

@@ -1,4 +1,8 @@
 import { setHmrBootStage } from './dev-overlay.js';
+import { buildPlaceholderPage } from './root-placeholder-view.js';
+import { getGlobalScope } from './global-scope.js';
+import { getVendorRequire } from './vendor-resolve.js';
+import { markDevBootComplete } from './boot-complete.js';
 function isPlaceholderView(view, placeholderRoot) {
     if (!view) {
         return false;
@@ -15,17 +19,37 @@ function isPlaceholderView(view, placeholderRoot) {
     return false;
 }
 function getCommittedRootView(application, placeholderRoot) {
-    try {
-        const root = application?.getRootView?.() || null;
-        if (!root) {
-            return null;
-        }
-        if (!isPlaceholderView(root, placeholderRoot)) {
-            return root;
+    const probe = (app) => {
+        try {
+            const root = app?.getRootView?.() || null;
+            if (!root)
+                return null;
+            if (!isPlaceholderView(root, placeholderRoot))
+                return root;
+            const currentPage = root.currentPage || root._currentEntry?.resolvedPage || null;
+            if (currentPage && !isPlaceholderView(currentPage, placeholderRoot))
+                return root;
         }
-        const currentPage = root.currentPage || root._currentEntry?.resolvedPage || null;
-        if (currentPage && !isPlaceholderView(currentPage, placeholderRoot)) {
-            return root;
+        catch { }
+        return null;
+    };
+    const primary = probe(application);
+    if (primary)
+        return primary;
+    // Vite HMR realm split: Angular's `Application.resetRootView` may have
+    // committed the real root on a different Application instance than the
+    // one the placeholder/early hook patched. Scan every Application we
+    // know about so we can detect the commit regardless of which twin
+    // Angular actually wrote to.
+    try {
+        const g = getGlobalScope();
+        const known = g['__NS_DEV_KNOWN_APPLICATIONS__'] || [];
+        for (const app of known) {
+            if (!app || app === application)
+                continue;
+            const r = probe(app);
+            if (r)
+                return r;
         }
     }
     catch { }
@@ -85,6 +109,9 @@ function clearPlaceholderGlobals(g) {
     delete g['__NS_DEV_PLACEHOLDER_ROOT_VIEW__'];
     delete g['__NS_DEV_PLACEHOLDER_ROOT_EARLY__'];
     delete g['__NS_DEV_BOOT_STATUS_LABEL__'];
+    delete g['__NS_DEV_BOOT_DETAIL_LABEL__'];
+    delete g['__NS_DEV_BOOT_PROGRESS_FILL__'];
+    delete g['__NS_DEV_BOOT_PROGRESS_LAST_SCALE__'];
     delete g['__NS_DEV_BOOT_ACTIVITY_INDICATOR__'];
     delete g['__NS_DEV_PLACEHOLDER_LAUNCH_HANDLER__'];
     delete g['__NS_DEV_PLACEHOLDER_APPLICATION__'];
@@ -98,12 +125,48 @@ function clearPlaceholderGlobals(g) {
     delete g['__NS_DEV_PLACEHOLDER_RESTORE_TIMER__'];
 }
 export function tryFinalizeBootPlaceholder(reason, verbose) {
-    const g = globalThis;
+    const g = getGlobalScope();
     const placeholderRoot = g['__NS_DEV_PLACEHOLDER_ROOT_VIEW__'] || null;
     const hadPlaceholder = !!placeholderRoot || !!g['__NS_DEV_PLACEHOLDER_ROOT_EARLY__'] || !!g['__NS_DEV_BOOT_STATUS_LABEL__'] || !!g['__NS_DEV_BOOT_ACTIVITY_INDICATOR__'];
     const application = g['__NS_DEV_PLACEHOLDER_APPLICATION__'] || g.Application;
     const committedRoot = getCommittedRootView(application, placeholderRoot);
     if (!committedRoot) {
+        // Verbose-gated, throttled to 1 Hz to avoid spamming the log on long stalls.
+        try {
+            if (verbose) {
+                const now = Date.now();
+                const last = g.__NS_PLACEHOLDER_DIAG_LAST_FINALIZE__ || 0;
+                if (now - last > 1000) {
+                    g.__NS_PLACEHOLDER_DIAG_LAST_FINALIZE__ = now;
+                    const describe = (app) => {
+                        try {
+                            const r = app?.getRootView?.();
+                            const cp = r?.currentPage || r?._currentEntry?.resolvedPage;
+                            return {
+                                appType: app?.constructor?.name || typeof app,
+                                appIdentity: app === application ? 'primary' : 'alt',
+                                rootType: r?.constructor?.name || 'null',
+                                rootIsPlaceholder: !!r && (r === placeholderRoot || r.__ns_dev_placeholder === true),
+                                currentPageType: cp?.constructor?.name,
+                            };
+                        }
+                        catch {
+                            return { appType: 'error' };
+                        }
+                    };
+                    const known = (g['__NS_DEV_KNOWN_APPLICATIONS__'] || []);
+                    console.warn('[ns-placeholder][diag] tryFinalize: no committed root', {
+                        reason,
+                        hadPlaceholder,
+                        placeholderRootType: placeholderRoot?.constructor?.name,
+                        primary: describe(application),
+                        knownApplications: known.length,
+                        alts: known.filter((a) => a && a !== application).map(describe),
+                    });
+                }
+            }
+        }
+        catch { }
         return false;
     }
     let detachedPlaceholder = false;
@@ -119,10 +182,10 @@ export function tryFinalizeBootPlaceholder(reason, verbose) {
         clearPlaceholderGlobals(g);
         detachedPlaceholder = true;
     }
-    try {
-        g.__NS_HMR_BOOT_COMPLETE__ = true;
-    }
-    catch { }
+    // Flips the JS global AND the native cold-boot gate
+    // (ns:module `setDevBootComplete`): the real root is committed, so the
+    // runtime's boot-only runloop pump can disarm.
+    markDevBootComplete();
     if (detachedPlaceholder) {
         setHmrBootStage('app-root-committed', {
             detail: 'The real app root replaced the boot placeholder.',
@@ -138,7 +201,7 @@ export function tryFinalizeBootPlaceholder(reason, verbose) {
     return true;
 }
 function scheduleBootPlaceholderFinalize(reason, verbose) {
-    const g = globalThis;
+    const g = getGlobalScope();
     if (g['__NS_DEV_PLACEHOLDER_RESTORE_TIMER__']) {
         return;
     }
@@ -152,14 +215,33 @@ function scheduleBootPlaceholderFinalize(reason, verbose) {
         }
         attempts += 1;
         if (Date.now() - startedAt >= maxWaitMs) {
-            if (verbose) {
-                console.info('[ns-placeholder] waiting for real root commit timed out', {
-                    reason,
-                    attempts,
-                    waitMs: Date.now() - startedAt,
-                    state: getPlaceholderWaitDiagnosticSnapshot(g, g['__NS_DEV_PLACEHOLDER_APPLICATION__'] || g.Application, g['__NS_DEV_PLACEHOLDER_ROOT_VIEW__'] || null),
+            // Always-on: a dev session that never commits a real root used to be
+            // an INFINITE silent spinner — the most common cause (a swallowed
+            // XML/Builder error during Application.run) printed one console line
+            // and nothing else. Flip the boot overlay to its error stage with the
+            // last captured builder error so the failure is visible on-device.
+            // Core's SourceErrorFormat stashes that error on
+            // `globalThis.__NS_LAST_XML_ERROR__` for exactly this hand-off.
+            try {
+                const lastXmlError = g.__NS_LAST_XML_ERROR__;
+                const hint = lastXmlError && lastXmlError.message ? `Last UI build error — ${lastXmlError.uri}: ${lastXmlError.message}` : 'No error was captured; check the device console for the first failure after launch.';
+                setHmrBootStage('error', {
+                    detail: `Dev session is active but the app root never replaced the boot placeholder (waited ${Math.round((Date.now() - startedAt) / 1000)}s). ${hint}`,
                 });
             }
+            catch { }
+            // Verbose-gated: enable `verbose` in the HMR config to surface stall diagnostics.
+            try {
+                if (verbose) {
+                    console.warn('[ns-placeholder][diag] waiting for real root commit TIMED OUT', {
+                        reason,
+                        attempts,
+                        waitMs: Date.now() - startedAt,
+                        state: getPlaceholderWaitDiagnosticSnapshot(g, g['__NS_DEV_PLACEHOLDER_APPLICATION__'] || g.Application, g['__NS_DEV_PLACEHOLDER_ROOT_VIEW__'] || null),
+                    });
+                }
+            }
+            catch { }
             return;
         }
         g['__NS_DEV_PLACEHOLDER_RESTORE_TIMER__'] = setTimeout(tick, attempts === 1 ? 0 : 100);
@@ -178,7 +260,7 @@ function scheduleBootPlaceholderFinalize(reason, verbose) {
 // exactly as it would in production — the patch intercepts it and does a clean
 // root replacement instead of fighting the already-running lifecycle.
 export function installRootPlaceholder(verbose) {
-    const g = globalThis;
+    const g = getGlobalScope();
     if (g['__NS_DEV_PLACEHOLDER_ROOT_EARLY__'])
         return;
     g['__NS_DEV_PLACEHOLDER_ROOT_EARLY__'] = true;
@@ -208,8 +290,8 @@ export function installRootPlaceholder(verbose) {
                 }
                 catch { }
                 try {
-                    const req = g.__nsVendorRequire || g.__nsRequire || g.require;
-                    if (typeof req === 'function') {
+                    const req = getVendorRequire();
+                    if (req) {
                         const mod = req(moduleId);
                         if (mod)
                             return { value: (mod.default ?? mod) || mod, via: 'require', moduleId };
@@ -297,35 +379,159 @@ export function installRootPlaceholder(verbose) {
         }
         g['__NS_DEV_PLACEHOLDER_APPLICATION__'] = Application;
         const isAndroid = !!(g.__ANDROID__ || typeof g.android !== 'undefined');
-        if (!isAndroid && typeof Application.resetRootView === 'function' && !g['__NS_DEV_PATCHED_RESET_ROOT_VIEW__']) {
-            const __ns_dev_original_reset_root_view = Application.resetRootView.bind(Application);
-            const __ns_dev_patched_reset_root_view = function __ns_dev_patched_reset_root_view(entry) {
-                const result = __ns_dev_original_reset_root_view(entry);
+        // Patch `Application.resetRootView` on BOTH platforms so the placeholder
+        // finalize callback (`__NS_DEV_RESTORE_PLACEHOLDER__`) fires every time the
+        // framework swaps the root view. The early Android wrapper in
+        // `core-aliases-early.ts` is unreliable under HTTP HMR boot (it runs before
+        // `g.Application` exists), so we wrap here too and coordinate via
+        // `__NS_DEV_PATCHED_RESET_ROOT__` to avoid double-wrapping.
+        const earlyAndroidWrapped = !!g['__NS_DEV_PATCHED_RESET_ROOT__'];
+        // Verbose-gated: the diag stream (resetRootView wraps, launch-handler
+        // entries, placeholder install state) only matters when investigating a stall.
+        const diag = verbose
+            ? (...args) => {
                 try {
-                    const restore = g['__NS_DEV_RESTORE_PLACEHOLDER__'];
-                    if (typeof restore === 'function') {
-                        restore('Application.resetRootView');
-                    }
+                    console.warn('[ns-placeholder][diag]', ...args);
                 }
                 catch { }
-                return result;
-            };
-            Application.resetRootView = __ns_dev_patched_reset_root_view;
+            }
+            : () => { };
+        diag('install entry', {
+            platform: isAndroid ? 'android' : 'ios',
+            applicationSource: applicationResolved.source,
+            applicationType: Application?.constructor?.name,
+            hasReset: typeof Application.resetRootView === 'function',
+            alreadyPatchedEarly: earlyAndroidWrapped,
+            alreadyPatchedView: !!g['__NS_DEV_PATCHED_RESET_ROOT_VIEW__'],
+            globalApplicationSame: g.Application === Application,
+            vendorApplicationSame: (() => {
+                try {
+                    const v = g.__nsVendorRegistry?.get?.('@nativescript/core');
+                    return v?.Application === Application || v?.default?.Application === Application;
+                }
+                catch {
+                    return null;
+                }
+            })(),
+        });
+        // Always patch every Application instance we can find. The early
+        // Android hook in `core-aliases-early.ts` only patches `g.Application`
+        // (the bundled realm's Application) and its prototype — but on Vite
+        // HMR there can be a SECOND Application loaded by the HTTP realm
+        // (`vendor-registry @nativescript/core`) that Angular's `import { Application }`
+        // actually resolves to. If we don't patch that twin too, Angular's
+        // `Application.resetRootView({ create: () => doc })` lands on an
+        // unpatched object, the placeholder finalize callback is never
+        // invoked, and the boot stalls at "Waiting for the app root view".
+        const makePatched = (origReset, label) => function __ns_dev_patched_reset_root_view(entry) {
+            diag(`patched resetRootView called (${label})`, {
+                hasEntry: !!entry,
+                entryKind: entry?.create ? 'create-fn' : entry?.moduleName ? 'module-name' : typeof entry,
+            });
+            const result = origReset(entry);
             try {
-                if (g.Application && g.Application !== Application) {
-                    g.Application.resetRootView = __ns_dev_patched_reset_root_view;
+                const restore = g['__NS_DEV_RESTORE_PLACEHOLDER__'];
+                if (typeof restore === 'function') {
+                    restore(`Application.resetRootView (${label})`);
                 }
             }
-            catch { }
+            catch (e) {
+                diag('patched resetRootView restore threw', String(e && (e.message || e)));
+            }
+            return result;
+        };
+        const wrapOnce = (target, label) => {
+            try {
+                if (!target || typeof target.resetRootView !== 'function')
+                    return false;
+                if (target.resetRootView.__ns_dev_placeholder_wrap === true)
+                    return false;
+                const orig = target.resetRootView.bind(target);
+                const wrapped = makePatched(orig, label);
+                wrapped.__ns_dev_placeholder_wrap = true;
+                target.resetRootView = wrapped;
+                return true;
+            }
+            catch {
+                return false;
+            }
+        };
+        const wrappedLocal = wrapOnce(Application, 'local');
+        const wrappedGlobal = g.Application && g.Application !== Application ? wrapOnce(g.Application, 'global') : false;
+        const wrappedProto = (() => {
             try {
                 const proto = Object.getPrototypeOf(Application);
-                if (proto && typeof proto.resetRootView === 'function' && proto.resetRootView !== __ns_dev_patched_reset_root_view) {
-                    proto.resetRootView = __ns_dev_patched_reset_root_view;
+                return wrapOnce(proto, 'proto');
+            }
+            catch {
+                return false;
+            }
+        })();
+        // Vendor-realm Application coverage. Even when `earlyAndroidWrapped`
+        // is true, the early hook only touched `g.Application` + its proto;
+        // the vendor's Application is a separate object with its own
+        // `resetRootView` that the early hook never sees.
+        let wrappedVendor = false;
+        let wrappedVendorAppModule = false;
+        try {
+            const reg = g.__nsVendorRegistry;
+            if (reg && typeof reg.get === 'function') {
+                const vendorCore = reg.get('@nativescript/core');
+                const vendorApp = vendorCore?.Application || vendorCore?.default?.Application;
+                if (vendorApp && vendorApp !== Application) {
+                    wrappedVendor = wrapOnce(vendorApp, 'vendor-core');
+                    try {
+                        const vp = Object.getPrototypeOf(vendorApp);
+                        if (vp && vp !== Object.getPrototypeOf(Application)) {
+                            wrapOnce(vp, 'vendor-core-proto');
+                        }
+                    }
+                    catch { }
+                }
+                const vendorAppMod = reg.get('@nativescript/core/application');
+                const vendorAppOnly = vendorAppMod?.Application || vendorAppMod?.default?.Application;
+                if (vendorAppOnly && vendorAppOnly !== Application && vendorAppOnly !== vendorApp) {
+                    wrappedVendorAppModule = wrapOnce(vendorAppOnly, 'vendor-application');
+                }
+            }
+        }
+        catch { }
+        // Track every Application instance we know about so
+        // `tryFinalizeBootPlaceholder` can poll the real root view on the
+        // instance Angular actually committed to.
+        try {
+            const apps = (g['__NS_DEV_KNOWN_APPLICATIONS__'] || (g['__NS_DEV_KNOWN_APPLICATIONS__'] = []));
+            const push = (a) => {
+                if (a && apps.indexOf(a) === -1)
+                    apps.push(a);
+            };
+            push(Application);
+            push(g.Application);
+            try {
+                const reg = g.__nsVendorRegistry;
+                if (reg && typeof reg.get === 'function') {
+                    const vendorCore = reg.get('@nativescript/core');
+                    push(vendorCore?.Application);
+                    push(vendorCore?.default?.Application);
+                    const vendorAppMod = reg.get('@nativescript/core/application');
+                    push(vendorAppMod?.Application);
+                    push(vendorAppMod?.default?.Application);
                 }
             }
             catch { }
-            g['__NS_DEV_PATCHED_RESET_ROOT_VIEW__'] = true;
         }
+        catch { }
+        g['__NS_DEV_PATCHED_RESET_ROOT_VIEW__'] = true;
+        g['__NS_DEV_PATCHED_RESET_ROOT__'] = true;
+        diag('patched Application.resetRootView', {
+            platform: isAndroid ? 'android' : 'ios',
+            wrappedLocal,
+            wrappedGlobal,
+            wrappedProto,
+            wrappedVendor,
+            wrappedVendorAppModule,
+            knownApplications: (g['__NS_DEV_KNOWN_APPLICATIONS__'] || []).length,
+        });
         const canCreatePlaceholderRoot = !!Frame && !!Page && !!Label;
         if (!canCreatePlaceholderRoot && verbose) {
             console.warn('[ns-placeholder] visual placeholder unavailable; starting lifecycle without placeholder root', {
@@ -346,64 +552,21 @@ export function installRootPlaceholder(verbose) {
         let handlerFired = false;
         // launchEvent handler: provides a placeholder root, then patches Application.run
         const __ns_launch_handler = (args) => {
-            if (verbose) {
-                console.info('[ns-placeholder] launch handler fired', {
-                    hasArgs: !!args,
-                    hasExistingRoot: !!args?.root,
-                    hasLaunched: typeof Application.hasLaunched === 'function' ? !!Application.hasLaunched() : undefined,
-                    started: !!Application.started,
-                });
-            }
+            diag('launch handler fired', {
+                hasArgs: !!args,
+                hasExistingRoot: !!args?.root,
+                existingRootType: args?.root?.constructor?.name,
+                hasLaunched: typeof Application.hasLaunched === 'function' ? !!Application.hasLaunched() : undefined,
+                started: !!Application.started,
+            });
             try {
                 const prev = args?.root;
                 if (!prev && canCreatePlaceholderRoot && Frame && Page && Label) {
-                    const StackLayout = getCore('StackLayout').value;
-                    const page = new Page();
-                    page.actionBarHidden = true;
-                    const titleLabel = new Label();
-                    titleLabel.text = 'NativeScript Vite preparing dev session...';
-                    titleLabel.textAlignment = 'center';
-                    titleLabel.textWrap = true;
-                    titleLabel.fontSize = 20;
-                    const statusLabel = new Label();
-                    statusLabel.text = 'Preparing the HTTP HMR bootstrap (4%)';
-                    statusLabel.textAlignment = 'center';
-                    statusLabel.textWrap = true;
-                    statusLabel.fontSize = 14;
-                    statusLabel.marginTop = 12;
-                    const activityIndicator = ActivityIndicator
-                        ? (() => {
-                            const indicator = new ActivityIndicator();
-                            indicator.busy = true;
-                            indicator.marginTop = 16;
-                            indicator.width = 28;
-                            indicator.height = 28;
-                            indicator.horizontalAlignment = 'center';
-                            return indicator;
-                        })()
-                        : null;
-                    if (StackLayout) {
-                        const root = new StackLayout();
-                        root.padding = 24;
-                        root.verticalAlignment = 'middle';
-                        root.horizontalAlignment = 'center';
-                        root.addChild(titleLabel);
-                        root.addChild(statusLabel);
-                        if (activityIndicator) {
-                            root.addChild(activityIndicator);
-                        }
-                        page.content = root;
-                    }
-                    else {
-                        // Fallback: just show the title label centered
-                        titleLabel.verticalAlignment = 'middle';
-                        titleLabel.horizontalAlignment = 'center';
-                        titleLabel.width = 280;
-                        titleLabel.padding = 12;
-                        page.content = titleLabel;
-                    }
-                    // Store refs so the overlay API can update the status label
+                    const built = buildPlaceholderPage({ Page, Label, ActivityIndicator, StackLayout: getCore('StackLayout').value, GridLayout: getCore('GridLayout').value, ContentView: getCore('ContentView').value, Image: getCore('Image').value, Color: getCore('Color').value, verbose });
+                    const { page, statusLabel, detailLabel, progressFill, activityIndicator } = built;
                     g['__NS_DEV_BOOT_STATUS_LABEL__'] = statusLabel;
+                    g['__NS_DEV_BOOT_DETAIL_LABEL__'] = detailLabel;
+                    g['__NS_DEV_BOOT_PROGRESS_FILL__'] = progressFill;
                     g['__NS_DEV_BOOT_ACTIVITY_INDICATOR__'] = activityIndicator;
                     const frame = new Frame();
                     frame.navigate({ create: () => page, clearHistory: true, animated: false });
@@ -417,7 +580,7 @@ export function installRootPlaceholder(verbose) {
                         console.info('[ns-placeholder] assigned placeholder root', {
                             frameType: frame?.constructor?.name,
                             pageType: page?.constructor?.name,
-                            hasStackLayout: !!StackLayout,
+                            hasProgressFill: !!progressFill,
                             hasActivityIndicator: !!activityIndicator,
                         });
                     }
@@ -441,73 +604,116 @@ export function installRootPlaceholder(verbose) {
                     if (Application && typeof Application.run === 'function') {
                         const _originalRun = Application.run.bind(Application);
                         g['__NS_DEV_ORIGINAL_APP_RUN__'] = _originalRun;
+                        // HMR ordering invariant: the patched `Application.run` MUST yield
+                        // back to the synchronous caller before any iOS view-lifecycle event
+                        // fires on the new root view.
+                        //
+                        // Concrete bug this guards against: nativescript-vue's `app.start()` is
+                        //   const componentInstance = app.mount(createAppRoot(), false, false);
+                        //   startApp(componentInstance);   // → Application.run({ create: … })
+                        //   setRootApp(app);                // — sets the module-private `rootApp`
+                        // In a non-HMR build `Application.run` is `UIApplicationMain`, which
+                        // returns control to the iOS runloop and lets `setRootApp(app)` execute
+                        // before any `loaded`/`traitCollectionDidChange` callbacks fire. Under
+                        // HMR `Application.run` is replaced with synchronous `resetRootView`,
+                        // which attaches the root to the window *inside* this call — iOS then
+                        // synchronously fires `loaded` on the new view tree, a TabView handler
+                        // calls `nativescript-vue`'s `createNativeView`, that reads
+                        // `rootApp._context`, and crashes with
+                        //   TypeError: Cannot read properties of null (reading '_context')
+                        // because `setRootApp(app)` hasn't run yet.
+                        //
+                        // `setRootApp` is module-private inside the vendor bundle, so the bridge
+                        // cannot call it directly. Deferring the synchronous root attachment to a
+                        // microtask restores the production timing: every consumer that called
+                        // `Application.run(entry)` completes its tail (including private state
+                        // setters like `setRootApp`) before iOS triggers lifecycle on the new
+                        // root. The microtask runs before any I/O or DOM-tick boundary, so the UI
+                        // still appears in the same iOS runloop turn — no user-visible delay.
                         const __ns_dev_patched_run = function __ns_dev_patched_run(entry) {
+                            diag('patched Application.run called', {
+                                hasEntry: !!entry,
+                                entryKind: entry?.create ? 'create-fn' : entry?.moduleName ? 'module-name' : typeof entry,
+                            });
+                            // Detach the launch handler synchronously: by the time the caller
+                            // returned from `Application.run()`, the framework owns root-view
+                            // management, and we must not re-enter the placeholder path on a
+                            // subsequent launch tick.
                             try {
-                                // Detach the launch handler, but keep placeholder refs until the
-                                // real app root is actually committed.
-                                try {
-                                    if (Application && Application.off) {
-                                        Application.off(Application.launchEvent, __ns_launch_handler);
-                                    }
-                                }
-                                catch { }
-                                // When entry is undefined/null, the calling framework (e.g. Angular)
-                                // manages root views itself via launch events and resetRootView().
-                                // Don't attempt resetRootView(undefined) which throws "Main entry is missing".
-                                if (!entry) {
-                                    if (verbose)
-                                        console.info('[ns-placeholder] patched run() called with no entry; framework manages root view');
-                                    return;
+                                if (Application && Application.off) {
+                                    Application.off(Application.launchEvent, __ns_launch_handler);
                                 }
-                                const isModuleNameEntry = entry && entry.moduleName && !entry.create;
-                                if (isModuleNameEntry) {
-                                    if (typeof Application.resetRootView === 'function') {
-                                        Application.resetRootView(entry);
+                            }
+                            catch { }
+                            // Frameworks (notably Angular) call `Application.run()` with no
+                            // entry — they own the root via launch events and `resetRootView()`
+                            // directly. Bailing here keeps `resetRootView(undefined)` from
+                            // throwing "Main entry is missing".
+                            if (!entry) {
+                                diag('patched run() called with no entry; framework manages root view');
+                                return;
+                            }
+                            // Snapshot for the deferred body so a later mutation by the caller
+                            // can't observe a half-finished closure.
+                            const __ns_deferred_entry = entry;
+                            const __ns_deferred_reset = () => {
+                                try {
+                                    const isModuleNameEntry = __ns_deferred_entry && __ns_deferred_entry.moduleName && !__ns_deferred_entry.create;
+                                    if (isModuleNameEntry) {
+                                        if (typeof Application.resetRootView === 'function') {
+                                            Application.resetRootView(__ns_deferred_entry);
+                                        }
                                     }
-                                }
-                                else {
-                                    // Framework path: two-phase boot with dominative document
-                                    Application._rootView = null;
-                                    try {
-                                        const domModule = g.__nsVendorRegistry?.get?.('dominative') ||
-                                            (typeof require === 'function'
-                                                ? (() => {
-                                                    try {
-                                                        return require('dominative');
-                                                    }
-                                                    catch {
-                                                        return null;
-                                                    }
-                                                })()
-                                                : null);
-                                        const doc = domModule?.document;
-                                        if (doc && typeof Application.resetRootView === 'function') {
-                                            Application.resetRootView({ create: () => doc });
-                                            if (entry && typeof entry.create === 'function') {
-                                                entry.create();
+                                    else {
+                                        // Framework path: two-phase boot with dominative document
+                                        Application._rootView = null;
+                                        try {
+                                            const domModule = g.__nsVendorRegistry?.get?.('dominative') ||
+                                                (typeof require === 'function'
+                                                    ? (() => {
+                                                        try {
+                                                            return require('dominative');
+                                                        }
+                                                        catch {
+                                                            return null;
+                                                        }
+                                                    })()
+                                                    : null);
+                                            const doc = domModule?.document;
+                                            if (doc && typeof Application.resetRootView === 'function') {
+                                                Application.resetRootView({ create: () => doc });
+                                                if (__ns_deferred_entry && typeof __ns_deferred_entry.create === 'function') {
+                                                    __ns_deferred_entry.create();
+                                                }
                                             }
-                                        }
-                                        else {
-                                            if (typeof Application.resetRootView === 'function') {
-                                                Application.resetRootView(entry);
+                                            else {
+                                                if (typeof Application.resetRootView === 'function') {
+                                                    Application.resetRootView(__ns_deferred_entry);
+                                                }
                                             }
                                         }
-                                    }
-                                    catch (e2) {
-                                        if (verbose)
-                                            console.warn('[ns-placeholder] two-phase boot failed:', e2?.message || e2);
-                                        try {
-                                            if (typeof Application.resetRootView === 'function') {
-                                                Application.resetRootView(entry);
+                                        catch (e2) {
+                                            if (verbose)
+                                                console.warn('[ns-placeholder] two-phase boot failed:', e2?.message || e2);
+                                            try {
+                                                if (typeof Application.resetRootView === 'function') {
+                                                    Application.resetRootView(__ns_deferred_entry);
+                                                }
                                             }
+                                            catch { }
                                         }
-                                        catch { }
                                     }
                                 }
-                            }
-                            catch (e) {
-                                console.warn('[ns-placeholder] patched run() error:', e);
-                            }
+                                catch (e) {
+                                    console.warn('[ns-placeholder] deferred patched run() error:', e);
+                                }
+                            };
+                            // Microtask-defer. `Promise.resolve().then(...)` lands the callback
+                            // in the same iOS runloop turn — no perceptible delay — but only
+                            // after the synchronous call stack that invoked `Application.run`
+                            // has fully unwound, so `nativescript-vue`'s post-`startApp` code
+                            // (`setRootApp(app);`) has executed before any view lifecycle fires.
+                            Promise.resolve().then(__ns_deferred_reset);
                         };
                         Application.run = __ns_dev_patched_run;
                         if (verbose) {
@@ -565,6 +771,21 @@ export function installRootPlaceholder(verbose) {
             const nativeApp = appAny.nativeApp;
             const iosNativeApp = appAny.ios?.nativeApp;
             const canRunAsMainApp = typeof appAny.runAsMainApp === 'function';
+            // iOS family only: when NativeScript runs EMBEDDED inside a host
+            // UIApplication (a visionOS SwiftUI `App`, or iOS built with
+            // `NS_SWIFTUI_BOOT=1`), the UIApplication singleton ALREADY exists by
+            // the time this placeholder runs — the SwiftUI `@main` created it
+            // before `[NativeScriptStart boot]` ran our entry. Calling
+            // `UIApplicationMain` again (via `runAsMainApp`/`run`) asserts in
+            // `UIApplicationInstantiateSingleton` and crashes at boot.
+            //
+            // `runAsMainApp` is an iOS-only method, so gating on `canRunAsMainApp`
+            // scopes this to Apple platforms (it leaves Android's `appAny.run()`
+            // branch untouched, where `nativeApp` is legitimately present early).
+            // On STANDALONE iOS the UIApplication is not created until
+            // `runAsMainApp()` itself calls `UIApplicationMain`, so `nativeApp` is
+            // still null here and the normal boot path below is preserved.
+            const hostUIApplicationExists = canRunAsMainApp && !!(nativeApp || iosNativeApp);
             if (verbose) {
                 console.info('[ns-placeholder] boot state', {
                     hasLaunched,
@@ -573,14 +794,18 @@ export function installRootPlaceholder(verbose) {
                     nativeApp: !!nativeApp,
                     iosNativeApp: !!iosNativeApp,
                     canRunAsMainApp,
+                    hostUIApplicationExists,
                     hasResetRootView: typeof appAny.resetRootView === 'function',
                 });
             }
-            if (hasLaunched || hasRootView) {
-                // App lifecycle is already active. Skip starting it again and only install
-                // the placeholder root/patching behavior for the existing instance.
+            if (hasLaunched || hasRootView || hostUIApplicationExists) {
+                // App lifecycle is already active — either a standalone app that has
+                // already launched, or NativeScript embedded inside a host
+                // UIApplication (visionOS SwiftUI). Skip starting it again
+                // (a second `UIApplicationMain` would assert) and only install the
+                // placeholder root/patching behavior for the existing instance.
                 if (verbose) {
-                    console.info('[ns-placeholder] boot branch: existing lifecycle');
+                    console.info('[ns-placeholder] boot branch: existing lifecycle', { hostUIApplicationExists });
                 }
                 try {
                     __ns_launch_handler();