@nativescript/vite 8.0.0-alpha.2 → 8.0.0-alpha.21

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

@@ -1,3 +1,553 @@
+import { BOOT_PLACEHOLDER_MOTION, computeBootProgressFillScale, formatBootDetailLine, formatBootPrimaryLine, getBootPlaceholderPalette } from './boot-placeholder-ui.js';
+import { setHmrBootStage } from './dev-overlay.js';
+function isPlaceholderView(view, placeholderRoot) {
+    if (!view) {
+        return false;
+    }
+    if (placeholderRoot && view === placeholderRoot) {
+        return true;
+    }
+    try {
+        if (view.__ns_dev_placeholder) {
+            return true;
+        }
+    }
+    catch { }
+    return false;
+}
+function getCommittedRootView(application, placeholderRoot) {
+    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;
+        }
+        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 = globalThis;
+        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 { }
+    return null;
+}
+function getPlaceholderWaitDiagnosticSnapshot(g, application, placeholderRoot) {
+    const snapshot = {
+        bootComplete: !!g.__NS_HMR_BOOT_COMPLETE__,
+        hasPlaceholderRoot: !!placeholderRoot,
+        hasPlaceholderFlag: !!g.__NS_DEV_PLACEHOLDER_ROOT_EARLY__,
+        hasAngularAppRef: !!g.__NS_ANGULAR_APP_REF__,
+        hasAngularReboot: typeof g.__reboot_ng_modules__ === 'function',
+    };
+    try {
+        snapshot.applicationType = application?.constructor?.name;
+        snapshot.hasLaunched = typeof application?.hasLaunched === 'function' ? !!application.hasLaunched() : undefined;
+        snapshot.rootViewType = application?.getRootView?.()?.constructor?.name;
+    }
+    catch { }
+    try {
+        const Frame = g.Frame;
+        const topmost = Frame?.topmost?.() || null;
+        snapshot.topmostFrameType = topmost?.constructor?.name;
+        snapshot.topmostPageType = topmost?.currentPage?.constructor?.name || topmost?._currentEntry?.resolvedPage?.constructor?.name;
+    }
+    catch { }
+    return snapshot;
+}
+function restoreOriginalApplicationRun(g) {
+    const originalRun = g['__NS_DEV_ORIGINAL_APP_RUN__'];
+    if (typeof originalRun !== 'function') {
+        return;
+    }
+    const application = g['__NS_DEV_PLACEHOLDER_APPLICATION__'] || g.Application;
+    try {
+        if (application) {
+            application.run = originalRun;
+        }
+    }
+    catch { }
+    try {
+        if (g.Application && g.Application !== application) {
+            g.Application.run = originalRun;
+        }
+    }
+    catch { }
+    try {
+        const proto = application ? Object.getPrototypeOf(application) : null;
+        if (proto && typeof proto.run === 'function' && proto.run !== originalRun) {
+            proto.run = originalRun;
+        }
+    }
+    catch { }
+    delete g['__NS_DEV_ORIGINAL_APP_RUN__'];
+}
+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__'];
+    const timer = g['__NS_DEV_PLACEHOLDER_RESTORE_TIMER__'];
+    if (timer) {
+        try {
+            clearTimeout(timer);
+        }
+        catch { }
+    }
+    delete g['__NS_DEV_PLACEHOLDER_RESTORE_TIMER__'];
+}
+// Official NativeScript wordmark, dark slate on transparent. Hosted
+// remotely so we don't have to ship the asset with @nativescript/vite;
+// fetched once per cold boot, NS's Image element handles caching.
+const NATIVESCRIPT_LOGO_URL = 'https://raw.githubusercontent.com/NativeScript/artwork/main/logo/export/NativeScript_Logo_Dark_Transparent.png';
+const BRAND_MARK_SIZE = 44;
+function makeColor(Color, value) {
+    if (!Color)
+        return value;
+    try {
+        return new Color(value);
+    }
+    catch {
+        return value;
+    }
+}
+// iOS layer-level shadow. Soft + offset down so the card reads as
+// "slightly lifted off the page" without a heavy, dated drop.
+function applyIosCardShadow(card, shadowHex, ColorCtor) {
+    const ios = card.ios;
+    const layer = ios?.layer;
+    if (!layer)
+        return;
+    if (ColorCtor) {
+        const shadowColor = new ColorCtor(shadowHex);
+        const uiColor = shadowColor.ios;
+        if (uiColor && typeof uiColor.CGColor !== 'undefined') {
+            layer.shadowColor = uiColor.CGColor;
+        }
+    }
+    layer.shadowOpacity = 0.18;
+    layer.shadowRadius = 16;
+    layer.shadowOffset = { width: 0, height: 6 };
+    layer.masksToBounds = false;
+}
+// Pre-load setup: keep the card invisible + slightly down-scaled so
+// it doesn't flash at full opacity before the loaded handler can
+// kick off the entrance animation. Called once at construction.
+function primeCardForEntrance(card) {
+    if (!card)
+        return;
+    try {
+        card.opacity = 0;
+        card.scaleX = BOOT_PLACEHOLDER_MOTION.entranceFromScale;
+        card.scaleY = BOOT_PLACEHOLDER_MOTION.entranceFromScale;
+    }
+    catch { }
+}
+// One-shot fade + scale on attach. Triggered from `loaded` so we run
+// after the view has been measured and committed to the visual tree.
+// Primed via `primeCardForEntrance` to avoid a pre-animation flash.
+function animateCardIn(card) {
+    if (!card || typeof card.animate !== 'function')
+        return;
+    try {
+        card
+            .animate({
+            opacity: 1,
+            scale: { x: 1, y: 1 },
+            duration: BOOT_PLACEHOLDER_MOTION.entranceDurationMs,
+            curve: 'easeOut',
+        })
+            .catch(() => {
+            try {
+                card.opacity = 1;
+                card.scaleX = 1;
+                card.scaleY = 1;
+            }
+            catch { }
+        });
+    }
+    catch { }
+}
+// Slow opacity pulse on the brand mark to give the otherwise-static
+// card a heartbeat. Loops until boot completes (the `__NS_HMR_BOOT_COMPLETE__`
+// gate) or the view is detached (animate rejects and the .catch swallows it).
+function pulseBrandMark(badge) {
+    if (!badge || typeof badge.animate !== 'function')
+        return;
+    const g = globalThis;
+    if (g.__NS_HMR_BOOT_COMPLETE__)
+        return;
+    try {
+        badge
+            .animate({
+            opacity: BOOT_PLACEHOLDER_MOTION.brandPulseMinOpacity,
+            duration: BOOT_PLACEHOLDER_MOTION.brandPulseDurationMs,
+            curve: 'easeInOut',
+        })
+            .then(() => badge.animate({
+            opacity: 1,
+            duration: BOOT_PLACEHOLDER_MOTION.brandPulseDurationMs,
+            curve: 'easeInOut',
+        }))
+            .then(() => pulseBrandMark(badge))
+            .catch(() => { });
+    }
+    catch { }
+}
+function buildPlaceholderPage(ctors) {
+    const { Page, Label, ActivityIndicator, StackLayout, GridLayout, ContentView, Image, Color } = ctors;
+    const palette = getBootPlaceholderPalette('info');
+    const page = new Page();
+    page.actionBarHidden = true;
+    try {
+        page.backgroundColor = makeColor(Color, palette.pageBackground);
+    }
+    catch { }
+    const titleLabel = new Label();
+    titleLabel.text = 'NativeScript Vite preparing dev session...';
+    titleLabel.textAlignment = 'center';
+    titleLabel.textWrap = true;
+    titleLabel.fontSize = 18;
+    titleLabel.fontWeight = '700';
+    try {
+        titleLabel.color = makeColor(Color, palette.titleText);
+    }
+    catch { }
+    titleLabel.marginTop = 18;
+    const statusLabel = new Label();
+    statusLabel.text = 'Preparing the HTTP HMR bootstrap (4%)';
+    statusLabel.textAlignment = 'center';
+    statusLabel.textWrap = true;
+    statusLabel.fontSize = 13;
+    try {
+        statusLabel.color = makeColor(Color, palette.phaseText);
+    }
+    catch { }
+    statusLabel.marginTop = 10;
+    const detailLabel = new Label();
+    detailLabel.text = '';
+    detailLabel.textAlignment = 'center';
+    detailLabel.textWrap = true;
+    detailLabel.fontSize = 11;
+    try {
+        detailLabel.color = makeColor(Color, palette.detailText);
+    }
+    catch { }
+    detailLabel.marginTop = 12;
+    const activityIndicator = ActivityIndicator
+        ? (() => {
+            const indicator = new ActivityIndicator();
+            indicator.busy = true;
+            indicator.marginTop = 14;
+            indicator.width = 22;
+            indicator.height = 22;
+            indicator.horizontalAlignment = 'center';
+            try {
+                indicator.color = makeColor(Color, palette.activityIndicator);
+            }
+            catch { }
+            return indicator;
+        })()
+        : null;
+    let progressFill = null;
+    let progressTrack = null;
+    if (GridLayout && ContentView) {
+        try {
+            progressTrack = new GridLayout();
+            progressTrack.height = 6;
+            progressTrack.marginTop = 16;
+            progressTrack.marginLeft = 4;
+            progressTrack.marginRight = 4;
+            try {
+                progressTrack.backgroundColor = makeColor(Color, palette.progressTrack);
+            }
+            catch { }
+            try {
+                progressTrack.borderRadius = 3;
+            }
+            catch { }
+            progressTrack.horizontalAlignment = 'stretch';
+            progressFill = new ContentView();
+            progressFill.height = 6;
+            progressFill.horizontalAlignment = 'stretch';
+            progressFill.verticalAlignment = 'middle';
+            try {
+                progressFill.backgroundColor = makeColor(Color, palette.progressFill);
+            }
+            catch { }
+            try {
+                progressFill.borderRadius = 3;
+            }
+            catch { }
+            // Anchor the scale transform at the left edge so the fill
+            // grows rightward like a real progress bar. Starting scale
+            // matches `computeBootProgressFillScale(0)` = 0.01 — visible
+            // sliver of accent that telegraphs "we're starting".
+            try {
+                progressFill.originX = 0;
+            }
+            catch { }
+            progressFill.scaleX = computeBootProgressFillScale(0);
+            progressTrack.addChild(progressFill);
+        }
+        catch {
+            progressTrack = null;
+            progressFill = null;
+        }
+    }
+    const brandMark = new Image();
+    brandMark.src = NATIVESCRIPT_LOGO_URL;
+    brandMark.stretch = 'aspectFit';
+    brandMark.width = BRAND_MARK_SIZE;
+    brandMark.height = BRAND_MARK_SIZE;
+    brandMark.horizontalAlignment = 'center';
+    brandMark.on?.('loaded', () => pulseBrandMark(brandMark));
+    let card = null;
+    if (StackLayout) {
+        try {
+            card = new StackLayout();
+            card.padding = '24 28 22 28';
+            try {
+                card.backgroundColor = makeColor(Color, palette.cardBackground);
+            }
+            catch { }
+            try {
+                card.borderRadius = 18;
+            }
+            catch { }
+            card.width = 320;
+            card.horizontalAlignment = 'center';
+            if (brandMark)
+                card.addChild(brandMark);
+            card.addChild(titleLabel);
+            card.addChild(statusLabel);
+            if (progressTrack)
+                card.addChild(progressTrack);
+            card.addChild(detailLabel);
+            if (activityIndicator)
+                card.addChild(activityIndicator);
+            primeCardForEntrance(card);
+            card.on?.('loaded', () => {
+                try {
+                    const ios = card.ios;
+                    if (ios && ios.layer) {
+                        ios.layer.cornerRadius = 18;
+                        ios.layer.masksToBounds = false;
+                    }
+                }
+                catch { }
+                applyIosCardShadow(card, palette.cardShadow, Color);
+                animateCardIn(card);
+            });
+        }
+        catch {
+            card = null;
+        }
+    }
+    if (card && GridLayout) {
+        try {
+            const root = new GridLayout();
+            root.horizontalAlignment = 'stretch';
+            root.verticalAlignment = 'stretch';
+            try {
+                root.backgroundColor = makeColor(Color, palette.pageBackground);
+            }
+            catch { }
+            card.verticalAlignment = 'middle';
+            card.horizontalAlignment = 'center';
+            root.addChild(card);
+            page.content = root;
+        }
+        catch {
+            page.content = card;
+        }
+    }
+    else if (card) {
+        card.verticalAlignment = 'middle';
+        page.content = card;
+    }
+    else if (StackLayout) {
+        // StackLayout exists but card creation failed — fall back to the
+        // minimal three-child layout the older placeholder used so the
+        // dev-overlay's fallback `findBootStatusLabel` walk still works.
+        try {
+            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;
+        }
+        catch {
+            titleLabel.verticalAlignment = 'middle';
+            titleLabel.horizontalAlignment = 'center';
+            titleLabel.width = 280;
+            titleLabel.padding = 12;
+            page.content = titleLabel;
+        }
+    }
+    else {
+        titleLabel.verticalAlignment = 'middle';
+        titleLabel.horizontalAlignment = 'center';
+        titleLabel.width = 280;
+        titleLabel.padding = 12;
+        page.content = titleLabel;
+    }
+    return {
+        page,
+        statusLabel,
+        detailLabel: card ? detailLabel : null,
+        progressFill,
+        activityIndicator,
+    };
+}
+export function tryFinalizeBootPlaceholder(reason, verbose) {
+    const g = globalThis;
+    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) {
+        // Throttled verbose-gated diagnostic. Used to be unconditional
+        // (with a `__NS_PLACEHOLDER_DIAG_SILENT__` opt-out) while we
+        // were debugging the Android "Waiting for the app root view"
+        // stall — now that Layer 1-9 fixes have landed, surface this
+        // only when the user opted into `verbose` in their HMR config.
+        // Still throttled to 1 Hz to avoid spamming the verbose 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;
+    if (hadPlaceholder) {
+        try {
+            const launchHandler = g['__NS_DEV_PLACEHOLDER_LAUNCH_HANDLER__'];
+            if (application && typeof application.off === 'function' && launchHandler) {
+                application.off(application.launchEvent, launchHandler);
+            }
+        }
+        catch { }
+        restoreOriginalApplicationRun(g);
+        clearPlaceholderGlobals(g);
+        detachedPlaceholder = true;
+    }
+    try {
+        g.__NS_HMR_BOOT_COMPLETE__ = true;
+    }
+    catch { }
+    if (detachedPlaceholder) {
+        setHmrBootStage('app-root-committed', {
+            detail: 'The real app root replaced the boot placeholder.',
+        });
+    }
+    if (verbose) {
+        console.info('[ns-placeholder] real app root committed', {
+            reason,
+            rootType: committedRoot?.constructor?.name || typeof committedRoot,
+            detachedPlaceholder,
+        });
+    }
+    return true;
+}
+function scheduleBootPlaceholderFinalize(reason, verbose) {
+    const g = globalThis;
+    if (g['__NS_DEV_PLACEHOLDER_RESTORE_TIMER__']) {
+        return;
+    }
+    const startedAt = Date.now();
+    const maxWaitMs = 20000;
+    let attempts = 0;
+    const tick = () => {
+        delete g['__NS_DEV_PLACEHOLDER_RESTORE_TIMER__'];
+        if (tryFinalizeBootPlaceholder(reason, verbose)) {
+            return;
+        }
+        attempts += 1;
+        if (Date.now() - startedAt >= maxWaitMs) {
+            // Verbose-gated — used to be unconditional with a
+            // `__NS_PLACEHOLDER_DIAG_SILENT__` opt-out while we were
+            // debugging the Android stall. Now that the stall is
+            // resolved, users investigating a new stall should enable
+            // `verbose` in their HMR config to see this warning.
+            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);
+    };
+    tick();
+}
 // Root placeholder installer used during dev HMR until HTTP ESM loads.
 //
 // Architecture:
@@ -14,107 +564,323 @@ export function installRootPlaceholder(verbose) {
     if (g['__NS_DEV_PLACEHOLDER_ROOT_EARLY__'])
         return;
     g['__NS_DEV_PLACEHOLDER_ROOT_EARLY__'] = true;
+    g['__NS_DEV_RESTORE_PLACEHOLDER__'] = (reason) => {
+        if (!tryFinalizeBootPlaceholder(reason, verbose)) {
+            scheduleBootPlaceholderFinalize(reason, verbose);
+        }
+    };
     try {
+        const resolveModule = (moduleIds) => {
+            for (const moduleId of moduleIds) {
+                try {
+                    if (typeof g.moduleExists === 'function' && g.moduleExists(moduleId) && typeof g.loadModule === 'function') {
+                        const mod = g.loadModule(moduleId);
+                        if (mod)
+                            return { value: (mod.default ?? mod) || mod, via: 'loadModule', moduleId };
+                    }
+                }
+                catch { }
+                try {
+                    const reg = g.__nsVendorRegistry;
+                    if (reg?.has?.(moduleId)) {
+                        const mod = reg.get(moduleId);
+                        if (mod)
+                            return { value: (mod.default ?? mod) || mod, via: '__nsVendorRegistry', moduleId };
+                    }
+                }
+                catch { }
+                try {
+                    const req = g.__nsVendorRequire || g.__nsRequire || g.require;
+                    if (typeof req === 'function') {
+                        const mod = req(moduleId);
+                        if (mod)
+                            return { value: (mod.default ?? mod) || mod, via: 'require', moduleId };
+                    }
+                }
+                catch { }
+                try {
+                    const nr = g.__nativeRequire;
+                    if (typeof nr === 'function') {
+                        const mod = nr(moduleId, '/');
+                        if (mod)
+                            return { value: (mod.default ?? mod) || mod, via: '__nativeRequire', moduleId };
+                    }
+                }
+                catch { }
+            }
+            return undefined;
+        };
         const getCore = (name) => {
-            try {
-                const reg = g.__nsVendorRegistry;
-                const req = reg?.get ? g.__nsVendorRequire || g.__nsRequire || g.require : g.__nsRequire || g.require;
-                let mod = null;
-                if (reg && reg.has('@nativescript/core'))
-                    mod = reg.get('@nativescript/core');
-                else if (typeof req === 'function') {
-                    try {
-                        mod = req('@nativescript/core');
+            if (name === 'Application' && g.Application && (typeof g.Application.run === 'function' || typeof g.Application.on === 'function' || typeof g.Application.resetRootView === 'function')) {
+                return { value: g.Application, source: 'globalThis.Application' };
+            }
+            const pickApplicationApi = (candidate, source) => {
+                if (!candidate)
+                    return null;
+                const candidates = [
+                    { value: candidate, source },
+                    { value: candidate.Application, source: `${source}#Application` },
+                    { value: candidate.app, source: `${source}#app` },
+                    { value: candidate.application, source: `${source}#application` },
+                ];
+                for (const entry of candidates) {
+                    if (entry.value && (typeof entry.value.run === 'function' || typeof entry.value.on === 'function' || typeof entry.value.resetRootView === 'function')) {
+                        return entry;
                     }
-                    catch { }
                 }
-                const ns = (mod && (mod.default ?? mod)) || mod;
-                if (name === 'Application' && ns && (ns.Application || ns))
-                    return ns.Application || ns;
-                if (ns && ns[name])
-                    return ns[name];
+                return null;
+            };
+            if (name === 'Application') {
+                const applicationModule = resolveModule(['@nativescript/core/application']);
+                const pickedFromAppModule = pickApplicationApi(applicationModule?.value, applicationModule ? `${applicationModule.via}:${applicationModule.moduleId}` : '@nativescript/core/application');
+                if (pickedFromAppModule)
+                    return pickedFromAppModule;
             }
-            catch { }
+            const primary = resolveModule(['@nativescript/core']);
+            if (name === 'Application' && primary?.value) {
+                const pickedFromPrimary = pickApplicationApi(primary.value, `${primary.via}:${primary.moduleId}`);
+                if (pickedFromPrimary)
+                    return pickedFromPrimary;
+            }
+            if (primary?.value && primary.value[name])
+                return { value: primary.value[name], source: `${primary.via}:${primary.moduleId}` };
+            const ui = resolveModule(['@nativescript/core/ui']);
+            if (ui?.value && ui.value[name])
+                return { value: ui.value[name], source: `${ui.via}:${ui.moduleId}` };
+            return { value: undefined, source: 'unresolved' };
+        };
+        const applicationResolved = getCore('Application');
+        const frameResolved = getCore('Frame');
+        const pageResolved = getCore('Page');
+        const labelResolved = getCore('Label');
+        const activityResolved = getCore('ActivityIndicator');
+        const Application = applicationResolved.value;
+        const Frame = frameResolved.value;
+        const Page = pageResolved.value;
+        const Label = labelResolved.value;
+        const ActivityIndicator = activityResolved.value;
+        if (!Application) {
+            if (verbose) {
+                console.warn('[ns-placeholder] Application unavailable', {
+                    resolution: {
+                        Application: applicationResolved.source,
+                        Frame: frameResolved.source,
+                        Page: pageResolved.source,
+                        Label: labelResolved.source,
+                    },
+                    moduleApis: {
+                        moduleExists: typeof g.moduleExists === 'function',
+                        loadModule: typeof g.loadModule === 'function',
+                        uiModuleRegistered: typeof g.moduleExists === 'function' ? !!g.moduleExists('@nativescript/core/ui') : false,
+                    },
+                });
+            }
+            return;
+        }
+        g['__NS_DEV_PLACEHOLDER_APPLICATION__'] = Application;
+        const isAndroid = !!(g.__ANDROID__ || typeof g.android !== 'undefined');
+        // Patch `Application.resetRootView` on BOTH platforms so the placeholder
+        // finalize callback (`__NS_DEV_RESTORE_PLACEHOLDER__`) fires every time
+        // the framework swaps the root view.
+        //
+        // History: this used to be gated behind `!isAndroid` on the assumption
+        // that `core-aliases-early.ts` already installs an Android-specific
+        // `resetRootView` wrapper. That early hook is unreliable in HTTP HMR
+        // boot — it runs before `@nativescript/core/bundle-entry-points`, so
+        // `g.Application` is undefined when it runs and the wrapper is silently
+        // skipped. By the time `installRootPlaceholder` reaches this point,
+        // `getCore('Application')` has resolved a real Application (the
+        // placeholder UI is already showing, which proves it), so wrapping here
+        // works on Android too. We also coordinate with the early hook's flag
+        // (`__NS_DEV_PATCHED_RESET_ROOT__`) so we never double-wrap if it did
+        // install successfully.
+        const earlyAndroidWrapped = !!g['__NS_DEV_PATCHED_RESET_ROOT__'];
+        // Verbose-gated. Previously this was unconditional with a
+        // `__NS_PLACEHOLDER_DIAG_SILENT__` opt-out — needed while we
+        // were debugging the Android "Waiting for the app root view"
+        // stall. Now that Layer 1-9 fixes have landed, the diag stream
+        // (resetRootView wraps, launch-handler entries, placeholder
+        // install state) is only useful when investigating a new
+        // stall, so it follows the user's `verbose` opt-in.
+        const diag = verbose
+            ? (...args) => {
+                try {
+                    console.warn('[ns-placeholder][diag]', ...args);
+                }
+                catch { }
+            }
+            : () => { };
+        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 {
+                const restore = g['__NS_DEV_RESTORE_PLACEHOLDER__'];
+                if (typeof restore === 'function') {
+                    restore(`Application.resetRootView (${label})`);
+                }
+            }
+            catch (e) {
+                diag('patched resetRootView restore threw', String(e && (e.message || e)));
+            }
+            return result;
+        };
+        const wrapOnce = (target, label) => {
             try {
-                const nr = g.__nativeRequire;
-                if (typeof nr === 'function') {
+                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);
+                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 mod = nr('@nativescript/core', '/');
-                        const ns = (mod && (mod.default ?? mod)) || mod;
-                        if (name === 'Application' && ns && (ns.Application || ns))
-                            return ns.Application || ns;
-                        if (ns && ns[name])
-                            return ns[name];
+                        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 { }
-            return undefined;
-        };
-        const Application = getCore('Application');
-        const Frame = getCore('Frame');
-        const Page = getCore('Page');
-        const Label = getCore('Label');
-        const ActivityIndicator = getCore('ActivityIndicator');
-        if (!Application || !Frame || !Page || !Label) {
-            if (verbose)
-                console.warn('[ns-placeholder] core classes unavailable');
-            return;
+        }
+        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', {
+                resolution: {
+                    Application: applicationResolved.source,
+                    Frame: frameResolved.source,
+                    Page: pageResolved.source,
+                    Label: labelResolved.source,
+                    ActivityIndicator: activityResolved.source,
+                },
+                moduleApis: {
+                    moduleExists: typeof g.moduleExists === 'function',
+                    loadModule: typeof g.loadModule === 'function',
+                    uiModuleRegistered: typeof g.moduleExists === 'function' ? !!g.moduleExists('@nativescript/core/ui') : false,
+                },
+            });
         }
         let handlerFired = false;
         // launchEvent handler: provides a placeholder root, then patches Application.run
         const __ns_launch_handler = (args) => {
+            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 && Frame && Page && Label) {
-                    const StackLayout = getCore('StackLayout');
-                    const page = new Page();
-                    page.actionBarHidden = true;
-                    const titleLabel = new Label();
-                    titleLabel.text = 'Starting NativeScript + Vite dev server…';
-                    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
+                if (!prev && canCreatePlaceholderRoot && Frame && Page && 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 });
@@ -124,6 +890,14 @@ export function installRootPlaceholder(verbose) {
                         g['__NS_DEV_PLACEHOLDER_ROOT_VIEW__'] = frame;
                     }
                     catch { }
+                    if (verbose) {
+                        console.info('[ns-placeholder] assigned placeholder root', {
+                            frameType: frame?.constructor?.name,
+                            pageType: page?.constructor?.name,
+                            hasProgressFill: !!progressFill,
+                            hasActivityIndicator: !!activityIndicator,
+                        });
+                    }
                     if (args)
                         args.root = frame;
                 }
@@ -144,76 +918,121 @@ 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 {
-                                // Clean up: remove launchEvent handler and placeholder references
-                                try {
-                                    if (Application && Application.off) {
-                                        Application.off(Application.launchEvent, __ns_launch_handler);
-                                    }
+                                if (Application && Application.off) {
+                                    Application.off(Application.launchEvent, __ns_launch_handler);
                                 }
-                                catch { }
-                                delete g['__NS_DEV_PLACEHOLDER_ROOT_VIEW__'];
-                                delete g['__NS_DEV_PLACEHOLDER_ROOT_EARLY__'];
-                                // 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;
-                                }
-                                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) {
+                            console.info('[ns-placeholder] patched Application.run');
+                        }
                         if (g.Application && g.Application !== Application) {
                             g.Application.run = __ns_dev_patched_run;
                         }
@@ -229,6 +1048,7 @@ export function installRootPlaceholder(verbose) {
                 catch { }
             }
         };
+        g['__NS_DEV_PLACEHOLDER_LAUNCH_HANDLER__'] = __ns_launch_handler;
         try {
             if (Application && Application.on) {
                 Application.on(Application.launchEvent, __ns_launch_handler);
@@ -237,20 +1057,68 @@ export function installRootPlaceholder(verbose) {
         catch { }
         // Determine boot path
         try {
-            if (Application && typeof Application.run === 'function') {
-                const nativeApp = Application.nativeApp;
-                const iosNativeApp = Application.ios?.nativeApp;
-                if (nativeApp || iosNativeApp) {
-                    // App already running (v9 runtime) — skip Application.run() to avoid
-                    // runAsEmbeddedApp's modal presentViewController.
-                    try {
-                        __ns_launch_handler();
-                    }
-                    catch { }
+            const appAny = Application;
+            const methodState = {
+                hasRun: typeof appAny?.run === 'function',
+                hasOn: typeof appAny?.on === 'function',
+                hasOff: typeof appAny?.off === 'function',
+                hasHasLaunched: typeof appAny?.hasLaunched === 'function',
+                hasGetRootView: typeof appAny?.getRootView === 'function',
+                hasResetRootView: typeof appAny?.resetRootView === 'function',
+                hasRunAsMainApp: typeof appAny?.runAsMainApp === 'function',
+                type: appAny?.constructor?.name,
+            };
+            if (verbose) {
+                console.info('[ns-placeholder] application methods', methodState);
+                console.info('[ns-placeholder] application source', applicationResolved.source);
+            }
+            if (!appAny || typeof appAny.run !== 'function') {
+                console.warn('[ns-placeholder] Application.run unavailable', {
+                    ...methodState,
+                    source: applicationResolved.source,
+                });
+                return;
+            }
+            const hasLaunched = typeof appAny.hasLaunched === 'function' ? !!appAny.hasLaunched() : false;
+            const hasRootView = typeof appAny.getRootView === 'function' ? !!appAny.getRootView() : false;
+            const started = !!appAny.started;
+            const nativeApp = appAny.nativeApp;
+            const iosNativeApp = appAny.ios?.nativeApp;
+            const canRunAsMainApp = typeof appAny.runAsMainApp === 'function';
+            if (verbose) {
+                console.info('[ns-placeholder] boot state', {
+                    hasLaunched,
+                    hasRootView,
+                    started,
+                    nativeApp: !!nativeApp,
+                    iosNativeApp: !!iosNativeApp,
+                    canRunAsMainApp,
+                    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 (verbose) {
+                    console.info('[ns-placeholder] boot branch: existing lifecycle');
+                }
+                try {
+                    __ns_launch_handler();
                 }
-                else {
-                    Application.run();
+                catch { }
+            }
+            else if (canRunAsMainApp) {
+                if (verbose) {
+                    console.info('[ns-placeholder] boot branch: runAsMainApp');
+                }
+                appAny.started = true;
+                appAny.runAsMainApp();
+            }
+            else {
+                if (verbose) {
+                    console.info('[ns-placeholder] boot branch: Application.run');
                 }
+                appAny.run();
             }
         }
         catch (e) {