@nativescript/vite 8.0.0-alpha.4 → 8.0.0-alpha.41

package/hmr/shared/runtime/dev-overlay.js

@@ -1,18 +1,42 @@
-const BOOT_TITLE = 'NativeScript Vite preparing dev session...';
-const DEFAULT_SNAPSHOT = {
-    visible: false,
-    mode: 'hidden',
-    badge: 'HMR',
-    title: BOOT_TITLE,
-    phase: '',
-    detail: '',
-    progress: null,
-    busy: false,
-    blocking: false,
-    tone: 'info',
-};
+import { BOOT_PLACEHOLDER_MOTION, computeBootProgressFillScale, formatBootDetailLine, formatBootPrimaryLine } from './boot-placeholder-ui.js';
+import { BOOT_TITLE, DEFAULT_SNAPSHOT, createBootOverlaySnapshot, createConnectionOverlaySnapshot, createUpdateOverlaySnapshot } from './dev-overlay-snapshots.js';
+import { getGlobalScope } from './global-scope.js';
+// Re-export the snapshot model so existing `./dev-overlay.js` importers keep working.
+export { createBootOverlaySnapshot, createConnectionOverlaySnapshot, createUpdateOverlaySnapshot } from './dev-overlay-snapshots.js';
+const DEFAULT_OVERLAY_POSITION = 'top';
 function getOverlayGlobal() {
-    return globalThis;
+    return getGlobalScope();
+}
+/**
+ * Resolve the configured live-overlay position.
+ *
+ * Reads `globalThis.__NS_HMR_OVERLAY_POSITION__` so a project can
+ * override the default at boot time (e.g. inside `app.ts` before the
+ * Vite session bootstraps). Falls back to 'top' which gives the
+ * toast-style chip with a slide-in animation and safe-area padding.
+ */
+export function getHmrDevOverlayPosition() {
+    const g = getOverlayGlobal();
+    const stored = g.__NS_HMR_OVERLAY_POSITION__;
+    if (stored === 'top' || stored === 'bottom' || stored === 'center') {
+        return stored;
+    }
+    return DEFAULT_OVERLAY_POSITION;
+}
+/**
+ * Imperative setter for the live-overlay position. Re-applies the
+ * current snapshot so the change is visible without waiting for the
+ * next HMR cycle. Useful during dev to A/B between top/bottom/center
+ * without restarting the app.
+ */
+export function setHmrDevOverlayPosition(position) {
+    if (position !== 'top' && position !== 'bottom' && position !== 'center') {
+        return;
+    }
+    const g = getOverlayGlobal();
+    g.__NS_HMR_OVERLAY_POSITION__ = position;
+    const state = getRuntimeState();
+    applyRuntimeSnapshot(state.snapshot);
 }
 function getRuntimeState() {
     const g = getOverlayGlobal();
@@ -21,240 +45,25 @@ function getRuntimeState() {
             snapshot: { ...DEFAULT_SNAPSHOT },
             bootRefs: null,
             liveRefs: null,
+            iosRefs: null,
+            iosBuildFailed: false,
             verbose: false,
+            updateAutoHideTimer: null,
+            updateCycleStartedAt: 0,
         };
     }
-    return g.__NS_HMR_DEV_OVERLAY_STATE__;
-}
-function describeAttempt(info) {
-    const attempt = Number(info?.attempt || 0);
-    const attempts = Number(info?.attempts || 0);
-    if (!attempt || !attempts) {
-        return '';
-    }
-    return `Attempt ${attempt}/${attempts}`;
-}
-export function createBootOverlaySnapshot(stage, info) {
-    const attemptText = describeAttempt(info);
-    const phaseInfo = {
-        placeholder: {
-            visible: true,
-            mode: 'boot',
-            badge: 'BOOT',
-            title: BOOT_TITLE,
-            phase: 'Preparing the HTTP HMR bootstrap',
-            progress: 4,
-            busy: true,
-            blocking: true,
-            tone: 'info',
-        },
-        'probing-origin': {
-            visible: true,
-            mode: 'boot',
-            badge: 'BOOT',
-            title: BOOT_TITLE,
-            phase: 'Contacting the Vite dev server',
-            progress: 8,
-            busy: true,
-            blocking: true,
-            tone: 'info',
-        },
-        'loading-entry-runtime': {
-            visible: true,
-            mode: 'boot',
-            badge: 'BOOT',
-            title: BOOT_TITLE,
-            phase: 'Loading the entry runtime bridge',
-            progress: 16,
-            busy: true,
-            blocking: true,
-            tone: 'info',
-        },
-        'configuring-import-map': {
-            visible: true,
-            mode: 'boot',
-            badge: 'BOOT',
-            title: BOOT_TITLE,
-            phase: 'Configuring the import map',
-            progress: 26,
-            busy: true,
-            blocking: true,
-            tone: 'info',
-        },
-        'loading-runtime-bridge': {
-            visible: true,
-            mode: 'boot',
-            badge: 'BOOT',
-            title: BOOT_TITLE,
-            phase: 'Loading the NativeScript runtime bridge',
-            progress: 40,
-            busy: true,
-            blocking: true,
-            tone: 'info',
-        },
-        'loading-core-bridge': {
-            visible: true,
-            mode: 'boot',
-            badge: 'BOOT',
-            title: BOOT_TITLE,
-            phase: 'Loading the unified core bridge',
-            progress: 54,
-            busy: true,
-            blocking: true,
-            tone: 'info',
-        },
-        'preloading-style-scope': {
-            visible: true,
-            mode: 'boot',
-            badge: 'BOOT',
-            title: BOOT_TITLE,
-            phase: 'Preparing the shared style scope',
-            progress: 62,
-            busy: true,
-            blocking: true,
-            tone: 'info',
-        },
-        'installing-css': {
-            visible: true,
-            mode: 'boot',
-            badge: 'BOOT',
-            title: BOOT_TITLE,
-            phase: 'Applying the app stylesheet',
-            progress: 70,
-            busy: true,
-            blocking: true,
-            tone: 'info',
-        },
-        'importing-main': {
-            visible: true,
-            mode: 'boot',
-            badge: 'BOOT',
-            title: BOOT_TITLE,
-            phase: 'Importing the app entry',
-            progress: 82,
-            busy: true,
-            blocking: true,
-            tone: 'info',
-        },
-        'waiting-for-app': {
-            visible: true,
-            mode: 'boot',
-            badge: 'BOOT',
-            title: BOOT_TITLE,
-            phase: 'Waiting for the app root view',
-            progress: 94,
-            busy: true,
-            blocking: true,
-            tone: 'info',
-        },
-        'app-root-committed': {
-            visible: true,
-            mode: 'boot',
-            badge: 'READY',
-            title: BOOT_TITLE,
-            phase: 'Real app root committed',
-            progress: 100,
-            busy: false,
-            blocking: true,
-            tone: 'info',
-        },
-        ready: {
-            visible: true,
-            mode: 'boot',
-            badge: 'READY',
-            title: BOOT_TITLE,
-            phase: 'Boot complete',
-            progress: 100,
-            busy: false,
-            blocking: true,
-            tone: 'info',
-        },
-        error: {
-            visible: true,
-            mode: 'boot',
-            badge: 'RETRY',
-            title: BOOT_TITLE,
-            phase: 'Retrying after a boot failure',
-            progress: null,
-            busy: true,
-            blocking: true,
-            tone: 'error',
-        },
-    };
-    const base = phaseInfo[stage];
-    let detail = info?.detail || '';
-    if (!detail && stage === 'probing-origin' && info?.origin) {
-        detail = `Trying ${info.origin}`;
-    }
-    if (attemptText) {
-        detail = detail ? `${detail}  ${attemptText}` : attemptText;
-    }
-    return {
-        ...base,
-        detail,
-        progress: typeof info?.progress === 'number' || info?.progress === null ? info.progress : base.progress,
-    };
-}
-export function createConnectionOverlaySnapshot(stage, info) {
-    if (stage === 'healthy') {
-        return { ...DEFAULT_SNAPSHOT };
-    }
-    const phaseInfo = {
-        connecting: {
-            visible: true,
-            mode: 'connection',
-            badge: 'SOCKET',
-            title: 'Waiting for Vite dev server',
-            phase: 'Opening websocket connection',
-            detail: 'Live updates are paused until the connection is healthy.',
-            progress: null,
-            busy: true,
-            blocking: false,
-            tone: 'warn',
-        },
-        reconnecting: {
-            visible: true,
-            mode: 'connection',
-            badge: 'SOCKET',
-            title: 'HMR connection lost',
-            phase: 'Reconnecting Vite websocket',
-            detail: 'The app may be stale until the dev server reconnects.',
-            progress: null,
-            busy: true,
-            blocking: false,
-            tone: 'warn',
-        },
-        synchronizing: {
-            visible: true,
-            mode: 'connection',
-            badge: 'SYNC',
-            title: 'HMR connection restored',
-            phase: 'Synchronizing live-update state',
-            detail: 'Finalizing the module graph before dismissing the overlay.',
-            progress: 95,
-            busy: true,
-            blocking: false,
-            tone: 'info',
-        },
-        offline: {
-            visible: true,
-            mode: 'connection',
-            badge: 'OFFLINE',
-            title: 'Vite dev server offline',
-            phase: 'Idle...',
-            detail: 'The websocket and HTTP HMR path are both unavailable right now.',
-            progress: null,
-            busy: true,
-            blocking: false,
-            tone: 'error',
-        },
-    };
-    const base = phaseInfo[stage];
-    return {
-        ...base,
-        detail: info?.detail || base.detail,
-        progress: typeof info?.progress === 'number' || info?.progress === null ? info.progress : base.progress,
-    };
+    const state = g.__NS_HMR_DEV_OVERLAY_STATE__;
+    // Backfill newer fields for legacy state objects (e.g. after hot reload)
+    // so we never observe an undefined iosRefs/iosBuildFailed at runtime.
+    if (typeof state.iosRefs === 'undefined')
+        state.iosRefs = null;
+    if (typeof state.iosBuildFailed === 'undefined')
+        state.iosBuildFailed = false;
+    if (typeof state.updateAutoHideTimer === 'undefined')
+        state.updateAutoHideTimer = null;
+    if (typeof state.updateCycleStartedAt !== 'number')
+        state.updateCycleStartedAt = 0;
+    return state;
 }
 function resolveCoreExport(name) {
     const g = getOverlayGlobal();
@@ -435,10 +244,28 @@ function findBootStatusLabel() {
     catch { }
     return null;
 }
+function findBootDetailLabel() {
+    const g = getOverlayGlobal();
+    return g.__NS_DEV_BOOT_DETAIL_LABEL__ || null;
+}
+function findBootProgressFill() {
+    const g = getOverlayGlobal();
+    return g.__NS_DEV_BOOT_PROGRESS_FILL__ || null;
+}
 function updateBootStatusLabel(snapshot) {
-    const newText = formatStatusText(snapshot) || 'Preparing the HTTP HMR bootstrap (4%)';
     const statusLabel = findBootStatusLabel();
+    const detailLabel = findBootDetailLabel();
+    const progressFill = findBootProgressFill();
     const activityIndicator = findBootActivityIndicator();
+    // New (card) layout: phase line + detail line live in separate
+    // labels so the typography can differ. Legacy (single-label)
+    // layout: keep the original combined "phase (X%)\ndetail" text so
+    // nothing visually regresses for runtimes still attached to the
+    // older placeholder shape.
+    const hasSplitLabels = !!detailLabel;
+    const phaseLine = formatBootPrimaryLine(snapshot);
+    const detailLine = formatBootDetailLine(snapshot);
+    const combinedText = formatStatusText(snapshot) || 'Preparing the HTTP HMR bootstrap (4%)';
     if (!statusLabel) {
         if (activityIndicator) {
             try {
@@ -447,11 +274,16 @@ function updateBootStatusLabel(snapshot) {
             }
             catch { }
         }
+        applyBootProgressFill(progressFill, snapshot);
         return;
     }
     try {
-        statusLabel.text = newText;
-        statusLabel.color = asColor(snapshot.tone === 'error' ? '#b41810e6' : '#563e3fb1');
+        statusLabel.text = hasSplitLabels ? phaseLine || 'Preparing the HTTP HMR bootstrap' : combinedText;
+        // Card layout uses the calibrated phase-text colour from the
+        // palette; legacy single-label layout keeps the original muted
+        // brown so we don't visually regress mid-session.
+        const phaseColorHex = snapshot.tone === 'error' ? '#B91C1C' : hasSplitLabels ? '#475569' : '#563e3fb1';
+        statusLabel.color = asColor(phaseColorHex);
         if (typeof statusLabel.requestLayout === 'function') {
             statusLabel.requestLayout();
         }
@@ -461,6 +293,15 @@ function updateBootStatusLabel(snapshot) {
         }
     }
     catch { }
+    if (detailLabel) {
+        try {
+            detailLabel.text = detailLine;
+            detailLabel.color = asColor(snapshot.tone === 'error' ? '#DC2626' : '#94A3B8');
+            detailLabel.visibility = detailLine ? 'visible' : 'collapse';
+        }
+        catch { }
+    }
+    applyBootProgressFill(progressFill, snapshot);
     if (activityIndicator) {
         try {
             activityIndicator.busy = !!snapshot.busy;
@@ -469,6 +310,50 @@ function updateBootStatusLabel(snapshot) {
         catch { }
     }
 }
+// Drive the progress fill scaleX from the snapshot. Uses NS's view
+// animate API for a smooth 220 ms easeOut between heartbeat ticks; a
+// monotonic ratchet on `globalThis.__NS_DEV_BOOT_PROGRESS_LAST_SCALE__`
+// guards against the fill snapping backwards if a less-progressed
+// snapshot ever lands between ticks (mirrors the JS-side
+// `applyMonotonicBootProgress` contract).
+function applyBootProgressFill(progressFill, snapshot) {
+    if (!progressFill)
+        return;
+    const g = getOverlayGlobal();
+    const isError = snapshot.tone === 'error';
+    progressFill.backgroundColor = asColor(isError ? '#B41810' : '#3B6FE5');
+    const targetScale = computeBootProgressFillScale(snapshot.progress ?? null);
+    const previousRaw = Number(g.__NS_DEV_BOOT_PROGRESS_LAST_SCALE__);
+    const previous = Number.isFinite(previousRaw) ? previousRaw : 0;
+    const next = Math.max(previous, targetScale);
+    g.__NS_DEV_BOOT_PROGRESS_LAST_SCALE__ = next;
+    try {
+        // NS view.animate scales around `originX`/`originY`; the
+        // placeholder builder pins `originX = 0` so the fill grows
+        // rightward. animate() may be unavailable in some headless
+        // test environments — fall through to a direct property set.
+        if (typeof progressFill.animate === 'function') {
+            progressFill
+                .animate({
+                scale: { x: next, y: 1 },
+                duration: BOOT_PLACEHOLDER_MOTION.progressDurationMs,
+                curve: 'easeOut',
+            })
+                .catch(() => {
+                try {
+                    progressFill.scaleX = next;
+                }
+                catch { }
+            });
+        }
+        else {
+            progressFill.scaleX = next;
+        }
+    }
+    catch {
+        progressFill.scaleX = next;
+    }
+}
 function resolveActivePage() {
     try {
         const Frame = resolveCoreExport('Frame');
@@ -492,6 +377,87 @@ function resolveActivePage() {
     catch { }
     return null;
 }
+function readCachedAndroidSafeAreaInsets() {
+    const g = getOverlayGlobal();
+    const cached = g.__NS_HMR_ANDROID_SAFE_INSETS__;
+    if (cached && typeof cached.top === 'number') {
+        return cached;
+    }
+    return null;
+}
+/**
+ * Read the Android system-bar safe-area insets (status bar / navigation
+ * bar / display cutout) in device-independent pixels.
+ *
+ * NativeScript runs every Android activity edge-to-edge, so the overlay
+ * wrapper fills the whole window — we need these insets to keep the toast
+ * chip out from under the system bars (see `computeAndroidToastMargin`).
+ *
+ * Returns null on non-Android runtimes (iOS / web / vitest) so callers
+ * fall back to base margins. The last good reading is cached on the
+ * global so a transient null (e.g. insets queried before the decor view
+ * is attached) reuses the previous value instead of snapping the chip
+ * back under the status bar.
+ */
+function readAndroidSafeAreaInsets() {
+    const g = getOverlayGlobal();
+    // `android.*` is exposed as a global only on the NativeScript Android
+    // runtime; its absence means iOS, web, or a test environment.
+    const androidNs = g.android || (typeof globalThis.android !== 'undefined' ? globalThis.android : undefined);
+    if (!androidNs) {
+        return null;
+    }
+    try {
+        const Application = resolveCoreExport('Application');
+        const activity = Application?.android?.foregroundActivity || Application?.android?.startActivity;
+        const decorView = activity?.getWindow?.()?.getDecorView?.();
+        const rootInsets = decorView?.getRootWindowInsets?.();
+        if (!rootInsets) {
+            return readCachedAndroidSafeAreaInsets();
+        }
+        let density = 1;
+        try {
+            const metricsDensity = Number(activity?.getResources?.()?.getDisplayMetrics?.()?.density);
+            if (Number.isFinite(metricsDensity) && metricsDensity > 0) {
+                density = metricsDensity;
+            }
+        }
+        catch { }
+        let px = { top: 0, bottom: 0, left: 0, right: 0 };
+        const WindowInsets = androidNs.view?.WindowInsets;
+        const Type = WindowInsets?.Type;
+        if (typeof rootInsets.getInsets === 'function' && Type && typeof Type.systemBars === 'function') {
+            // API 30+: query the system bars + display cutout so notches /
+            // camera holes are respected in landscape.
+            let mask = Type.systemBars();
+            if (typeof Type.displayCutout === 'function') {
+                mask = mask | Type.displayCutout();
+            }
+            const i = rootInsets.getInsets(mask);
+            px = { top: Number(i?.top) || 0, bottom: Number(i?.bottom) || 0, left: Number(i?.left) || 0, right: Number(i?.right) || 0 };
+        }
+        else {
+            // API < 30 fallback.
+            px = {
+                top: Number(rootInsets.getSystemWindowInsetTop?.()) || 0,
+                bottom: Number(rootInsets.getSystemWindowInsetBottom?.()) || 0,
+                left: Number(rootInsets.getSystemWindowInsetLeft?.()) || 0,
+                right: Number(rootInsets.getSystemWindowInsetRight?.()) || 0,
+            };
+        }
+        const insets = {
+            top: px.top / density,
+            bottom: px.bottom / density,
+            left: px.left / density,
+            right: px.right / density,
+        };
+        g.__NS_HMR_ANDROID_SAFE_INSETS__ = insets;
+        return insets;
+    }
+    catch {
+        return readCachedAndroidSafeAreaInsets();
+    }
+}
 function buildLiveOverlayView(snapshot) {
     const GridLayout = resolveCoreExport('GridLayout');
     const StackLayout = resolveCoreExport('StackLayout');
@@ -505,8 +471,18 @@ function buildLiveOverlayView(snapshot) {
     overlay.height = '100%';
     overlay.horizontalAlignment = 'stretch';
     overlay.verticalAlignment = 'stretch';
+    // Toast mode lets touches reach the underlying app. We flip
+    // isUserInteractionEnabled in applySnapshotToLiveRefs based on
+    // the resolved position, but keep it false here as a safe default
+    // (the panel itself is purely informational).
+    try {
+        overlay.isUserInteractionEnabled = false;
+    }
+    catch { }
     const panel = new StackLayout();
     panel.horizontalAlignment = 'center';
+    // Vertical alignment is overridden in applySnapshotToLiveRefs
+    // based on getHmrDevOverlayPosition(); 'middle' is the default
     panel.verticalAlignment = 'middle';
     panel.width = 320;
     panel.margin = 24;
@@ -528,6 +504,8 @@ function buildLiveOverlayView(snapshot) {
         overlay,
         titleLabel,
         statusLabel,
+        wasVisible: false,
+        currentPosition: getHmrDevOverlayPosition(),
     };
     applySnapshotToLiveRefs(refs, snapshot);
     return refs;
@@ -584,26 +562,777 @@ function applySnapshotToLiveRefs(refs, snapshot) {
     if (!refs) {
         return;
     }
-    const visible = snapshot.visible && snapshot.mode === 'connection';
-    refs.overlay.visibility = visible ? 'visible' : 'collapse';
-    refs.overlay.backgroundColor = asColor(snapshot.tone === 'error' ? '#b4181068' : '#a1771683');
+    // 'update' mode shares the live (in-tree) overlay chrome with
+    // 'connection'. Both render a small panel inside the page; only
+    // the colours, text, and (now) panel position change with the
+    // snapshot's tone and the configured overlay position.
+    const visible = snapshot.visible && (snapshot.mode === 'connection' || snapshot.mode === 'update');
+    const wasVisible = !!refs.wasVisible;
+    const position = getHmrDevOverlayPosition();
+    const previousPosition = refs.currentPosition || position;
+    const isToast = position !== 'center';
     refs.titleLabel.text = snapshot.title;
-    refs.titleLabel.color = asColor(snapshot.tone === 'error' ? '#b41810e6' : '#563e3fb1');
     refs.statusLabel.text = formatStatusText(snapshot);
-    refs.statusLabel.color = asColor(snapshot.tone === 'error' ? '#b41810e6' : '#563e3fb1');
+    const textColor = snapshot.tone === 'error' ? '#b41810e6' : snapshot.tone === 'success' ? '#0e6e2fff' : '#563e3fb1';
+    refs.titleLabel.color = asColor(textColor);
+    refs.statusLabel.color = asColor(textColor);
+    // Backdrop tints (centered modal only). Toast modes use a fully
+    // transparent backdrop so the rest of the app stays visible AND
+    // reachable; the panel itself carries enough colour to stand out.
+    if (isToast) {
+        refs.overlay.backgroundColor = asColor('transparent');
+    }
+    else {
+        // Original wash-by-tone for centered:
+        //   error   → red wash (matches existing UX)
+        //   success → richer green wash so the apply event is visible
+        //             on bright app backgrounds
+        //   default → warm orange (existing connection-overlay look)
+        const overlayBg = snapshot.tone === 'error' ? '#b4181068' : snapshot.tone === 'success' ? '#1f883d80' : '#a1771683';
+        refs.overlay.backgroundColor = asColor(overlayBg);
+    }
+    // Panel chrome — toast and centered share the same chip look,
+    // just position differs. We keep the slightly richer green tint
+    // for the HMR success state so it pops without needing the
+    // backdrop wash.
+    let panel = null;
     try {
-        const panel = refs.titleLabel.parent;
+        panel = refs.titleLabel.parent;
         if (panel) {
-            panel.backgroundColor = asColor('#FFFFFFFF');
+            const panelBg = snapshot.tone === 'success' ? '#E6F8E9FF' : '#FFFFFFFF';
+            panel.backgroundColor = asColor(panelBg);
             panel.opacity = 1;
             panel.padding = 16;
             try {
                 panel.borderRadius = 12;
             }
             catch { }
+            // Position-aware alignment. The wrapper GridLayout fills the
+            // page content area. NativeScript runs every Android activity
+            // edge-to-edge, so that area extends under the status bar and
+            // navigation bar — we fold the system-bar safe-area insets into
+            // the chip's margin (via computeAndroidToastMargin) so a top
+            // chip clears the status bar and a bottom chip clears the nav
+            // bar instead of being clipped behind them. readAndroidSafeAreaInsets
+            // returns null off-Android, so the margins collapse to their base
+            // values (no behavioural change on iOS's in-tree fallback / tests).
+            try {
+                if (position === 'top' || position === 'bottom') {
+                    const m = computeAndroidToastMargin({ position, safeInsets: readAndroidSafeAreaInsets() });
+                    panel.verticalAlignment = position;
+                    panel.margin = `${m.top} ${m.right} ${m.bottom} ${m.left}`;
+                }
+                else {
+                    panel.verticalAlignment = 'middle';
+                    panel.margin = 24;
+                }
+            }
+            catch { }
+            // Force a tight re-measure so the StackLayout panel hugs the
+            // CURRENT title+status text. Connection stages can swap between
+            // frames whose text wraps to a different number of lines (e.g. a
+            // long 'reconnecting' "Retrying ws://…" detail vs. the short
+            // 'offline' message). Without an explicit relayout the panel can
+            // retain the tallest height it ever measured, leaving an oversized
+            // gap between title and message. Mirrors updateBootStatusLabel.
+            try {
+                refs.titleLabel.requestLayout?.();
+                refs.statusLabel.requestLayout?.();
+                panel.requestLayout?.();
+            }
+            catch { }
         }
     }
     catch { }
+    // Touch passthrough for toast; centered mode keeps the
+    // blocking modal so the dim backdrop is meaningful.
+    try {
+        refs.overlay.isUserInteractionEnabled = !isToast;
+    }
+    catch { }
+    const positionChanged = previousPosition !== position;
+    const justAppeared = visible && (!wasVisible || positionChanged);
+    const justDismissed = !visible && wasVisible;
+    if (justAppeared) {
+        refs.overlay.visibility = 'visible';
+        if (isToast && panel && typeof panel.animate === 'function') {
+            animateLivePanelIn(panel, position);
+        }
+        else if (panel) {
+            try {
+                panel.translateY = 0;
+                panel.opacity = 1;
+            }
+            catch { }
+        }
+    }
+    else if (justDismissed) {
+        if (isToast && panel && typeof panel.animate === 'function') {
+            animateLivePanelOut(panel, previousPosition, () => {
+                try {
+                    refs.overlay.visibility = 'collapse';
+                }
+                catch { }
+            });
+        }
+        else {
+            refs.overlay.visibility = 'collapse';
+        }
+    }
+    else {
+        // Steady-state refresh (e.g. offline → reconnecting → offline while
+        // already visible): no slide animation fires here, so clear any
+        // transform residue a previously-interrupted slide-in/out may have
+        // left on the panel. Otherwise the chip can appear shifted or
+        // faded across rapid connection-stage swaps.
+        if (visible && panel) {
+            try {
+                panel.translateY = 0;
+                panel.opacity = 1;
+            }
+            catch { }
+        }
+        refs.overlay.visibility = visible ? 'visible' : 'collapse';
+    }
+    if (typeof refs.wasVisible !== 'undefined')
+        refs.wasVisible = visible;
+    if (typeof refs.currentPosition !== 'undefined')
+        refs.currentPosition = position;
+}
+/**
+ * Slide-in animation for the in-tree toast panel.
+ *
+ * NativeScript's `View.animate({ translate, opacity, duration, curve })`
+ * is widely available across Core versions, so we don't depend on any
+ * specific curve enum being importable here. We use a moderate-to-snappy
+ * 320ms ease-out which feels close to a UIView spring without needing
+ * platform-specific APIs.
+ */
+function animateLivePanelIn(panel, position) {
+    if (!panel || typeof panel.animate !== 'function')
+        return;
+    try {
+        const startY = position === 'bottom' ? 80 : -80;
+        panel.translateY = startY;
+        panel.opacity = 0;
+        const result = panel.animate({
+            translate: { x: 0, y: 0 },
+            opacity: 1,
+            duration: 320,
+            curve: 'easeOut',
+        });
+        if (result && typeof result.catch === 'function') {
+            result.catch(() => {
+                try {
+                    panel.translateY = 0;
+                    panel.opacity = 1;
+                }
+                catch { }
+            });
+        }
+    }
+    catch {
+        try {
+            panel.translateY = 0;
+            panel.opacity = 1;
+        }
+        catch { }
+    }
+}
+function animateLivePanelOut(panel, position, onComplete) {
+    if (!panel || typeof panel.animate !== 'function') {
+        onComplete();
+        return;
+    }
+    try {
+        const targetY = position === 'bottom' ? 80 : -80;
+        const result = panel.animate({
+            translate: { x: 0, y: targetY },
+            opacity: 0,
+            duration: 220,
+            curve: 'easeIn',
+        });
+        const finish = () => {
+            try {
+                panel.translateY = 0;
+                panel.opacity = 1;
+            }
+            catch { }
+            onComplete();
+        };
+        if (result && typeof result.then === 'function') {
+            result.then(finish, finish);
+        }
+        else {
+            finish();
+        }
+    }
+    catch {
+        onComplete();
+    }
+}
+// pure helpers for iOS window promotion. Factored out so the layout
+// math and window-level selection stay unit-testable without booting a
+// simulator. See `dev-overlay.spec.ts`.
+/**
+ * Returns the UIWindow level we use for the live/connection overlay. We lift
+ * above `UIWindowLevelAlert` so system alerts (and any app-presented modal)
+ * stack underneath. When the platform does not expose `UIWindowLevelAlert`
+ * we fall back to the documented constant value (2000).
+ */
+export function computeIosOverlayWindowLevel(baseAlert) {
+    if (typeof baseAlert === 'number' && Number.isFinite(baseAlert)) {
+        return baseAlert + 1;
+    }
+    return 2000 + 1;
+}
+/**
+ * Layout math for the live overlay when it runs inside its own UIWindow.
+ * Pure, deterministic and independent of UIKit so we can verify the rules
+ * (max panel width, position-aware placement, safe-area clamping, sane
+ * defaults) from tests.
+ *
+ * `position` controls where the panel sits vertically:
+ *   - 'top':    hugs `safeInsets.top + toastVerticalInset` so the chip
+ *               sits just below the notch / Dynamic Island.
+ *   - 'bottom': hugs `viewHeight - safeInsets.bottom - panelHeight -
+ *               toastVerticalInset` so the chip sits just above the
+ *               home indicator / nav bar.
+ *   - 'center': original modal placement (vertically centered, clamped
+ *               so it never crosses the top safe-area inset).
+ */
+export function computeIosOverlayLayout(input) {
+    const viewWidth = Math.max(0, Number(input.viewWidth) || 0);
+    const viewHeight = Math.max(0, Number(input.viewHeight) || 0);
+    const safeInsets = {
+        top: Math.max(0, Number(input.safeInsets?.top ?? 0) || 0),
+        bottom: Math.max(0, Number(input.safeInsets?.bottom ?? 0) || 0),
+        left: Math.max(0, Number(input.safeInsets?.left ?? 0) || 0),
+        right: Math.max(0, Number(input.safeInsets?.right ?? 0) || 0),
+    };
+    const titleHeight = Math.max(0, Number(input.titleHeight) || 0);
+    const statusHeight = Math.max(0, Number(input.statusHeight) || 0);
+    const horizontalMargin = Math.max(0, Number(input.horizontalMargin ?? 24));
+    const maxPanelWidth = Math.max(0, Number(input.maxPanelWidth ?? 340));
+    const panelPadding = Math.max(0, Number(input.panelPadding ?? 16));
+    const interLabelSpacing = Math.max(0, Number(input.interLabelSpacing ?? 10));
+    const minTopInset = Math.max(0, Number(input.minTopInset ?? 20));
+    // Default to 'center' on the pure function so the existing
+    // snapshot/layout tests remain stable; the runtime call site
+    // (layoutIosOverlayRefs) reads the configured position from
+    // `getHmrDevOverlayPosition()` and forwards it explicitly.
+    const position = input.position ?? 'center';
+    // Distance between the panel and the safe-area edge in toast
+    // modes. 8pt mirrors the typical iOS notification chip inset and
+    // keeps the chip from hugging the notch / home indicator.
+    const toastVerticalInset = Math.max(0, Number(input.toastVerticalInset ?? 8));
+    const available = Math.max(0, viewWidth - 2 * horizontalMargin - safeInsets.left - safeInsets.right);
+    const panelWidth = Math.min(maxPanelWidth, available);
+    const innerWidth = Math.max(0, panelWidth - 2 * panelPadding);
+    const spacing = titleHeight > 0 && statusHeight > 0 ? interLabelSpacing : 0;
+    const panelHeight = panelPadding * 2 + titleHeight + spacing + statusHeight;
+    const panelX = Math.max(0, (viewWidth - panelWidth) / 2);
+    let panelY;
+    if (position === 'top') {
+        // Pin to the top safe-area inset (just below notch / Dynamic
+        // Island). Clamp non-negative for fully-NaN input.
+        panelY = Math.max(0, safeInsets.top + toastVerticalInset);
+    }
+    else if (position === 'bottom') {
+        // Pin to the bottom safe-area inset (just above home indicator
+        // / nav bar). If the panel can't fit between the safe-area
+        // insets we fall back to the top safe-area edge so the chip is
+        // always visible (rather than getting clipped off-screen).
+        const desired = viewHeight - safeInsets.bottom - panelHeight - toastVerticalInset;
+        panelY = Math.max(safeInsets.top + minTopInset, desired);
+    }
+    else {
+        // Center vertically, but never cross the top safe-area inset
+        // (notch/Dynamic Island). Original modal placement.
+        const centered = (viewHeight - panelHeight) / 2;
+        panelY = Math.max(safeInsets.top + minTopInset, centered);
+    }
+    return {
+        backdrop: { x: 0, y: 0, width: viewWidth, height: viewHeight },
+        panel: { x: panelX, y: panelY, width: panelWidth, height: panelHeight },
+        title: { x: panelPadding, y: panelPadding, width: innerWidth, height: titleHeight },
+        status: {
+            x: panelPadding,
+            y: panelPadding + titleHeight + spacing,
+            width: innerWidth,
+            height: statusHeight,
+        },
+    };
+}
+/**
+ * Margin math for the in-tree (Android) live/update toast chip.
+ *
+ * NativeScript enables edge-to-edge on every Android activity
+ * (`@nativescript/core` → `application.android.ts` → `enableEdgeToEdge`),
+ * so the page content — and therefore the overlay wrapper we inject into
+ * it — extends underneath the status bar and navigation bar. A fixed
+ * top/bottom margin leaves the chip tucked behind the system bars, where
+ * it gets clipped (Android 15 / API 35 enforces edge-to-edge, so this is
+ * now the norm rather than the exception).
+ *
+ * This pure helper folds the system-bar safe-area insets into the chip's
+ * margin so the toast always clears the status bar (top position) /
+ * navigation bar (bottom position). It is deterministic and free of
+ * native deps so the rules stay unit-testable — the runtime reads the
+ * live insets via `readAndroidSafeAreaInsets()` and forwards them here.
+ *
+ *   - 'top':    margin.top    = baseVerticalInset + safeInsets.top
+ *   - 'bottom': margin.bottom = baseVerticalInset + safeInsets.bottom
+ *   - 'center': fixed `centerMargin` all around (vertically centered, so
+ *               it never approaches the system bars on normal viewports).
+ *
+ * Horizontal margins always include the relevant safe-area inset so a
+ * landscape display cutout / gesture pill doesn't clip the chip edge.
+ */
+export function computeAndroidToastMargin(input) {
+    // Clamp to a finite, non-negative number; fall back to `fallback`
+    // for missing/NaN input so a glitched measurement can't produce a
+    // negative or NaN margin (which NativeScript would silently drop).
+    const clamp = (value, fallback) => {
+        const n = Number(value);
+        return Number.isFinite(n) && n >= 0 ? n : fallback;
+    };
+    const safe = {
+        top: clamp(input.safeInsets?.top, 0),
+        bottom: clamp(input.safeInsets?.bottom, 0),
+        left: clamp(input.safeInsets?.left, 0),
+        right: clamp(input.safeInsets?.right, 0),
+    };
+    const baseVerticalInset = clamp(input.baseVerticalInset, 8);
+    const baseHorizontalInset = clamp(input.baseHorizontalInset, 16);
+    const centerMargin = clamp(input.centerMargin, 24);
+    if (input.position === 'center') {
+        return { top: centerMargin, right: centerMargin, bottom: centerMargin, left: centerMargin };
+    }
+    const left = Math.round(baseHorizontalInset + safe.left);
+    const right = Math.round(baseHorizontalInset + safe.right);
+    if (input.position === 'bottom') {
+        return { top: 0, right, bottom: Math.round(baseVerticalInset + safe.bottom), left };
+    }
+    // 'top' (and any unexpected value) hugs the status-bar safe area.
+    return { top: Math.round(baseVerticalInset + safe.top), right, bottom: 0, left };
+}
+/**
+ * Returns the iOS UIKit symbols we rely on if we're running on an iOS runtime
+ * with the metadata bridge available. Returns null on Android, web, or in
+ * tests so callers can gracefully fall back to the in-tree overlay.
+ */
+function getIosOverlayHost() {
+    const g = getOverlayGlobal();
+    if (typeof g.UIWindow === 'undefined' || typeof g.UIApplication === 'undefined' || typeof g.UIViewController === 'undefined' || typeof g.UIView === 'undefined' || typeof g.UILabel === 'undefined' || typeof g.UIColor === 'undefined' || typeof g.UIFont === 'undefined' || typeof g.UIScreen === 'undefined') {
+        return null;
+    }
+    return {
+        UIWindow: g.UIWindow,
+        UIViewController: g.UIViewController,
+        UIView: g.UIView,
+        UILabel: g.UILabel,
+        UIColor: g.UIColor,
+        UIFont: g.UIFont,
+        UIApplication: g.UIApplication,
+        UIScreen: g.UIScreen,
+        UIWindowLevelAlert: typeof g.UIWindowLevelAlert === 'number' ? g.UIWindowLevelAlert : undefined,
+    };
+}
+/**
+ * Walks UIApplication.sharedApplication windows and returns the first active
+ * UIWindowScene we can locate. On iOS 13+ every UIWindow is attached to a
+ * scene, and we must initialise our overlay window the same way or the OS
+ * will silently refuse to render it. Returns null when no scene is found
+ * (older iOS versions or non-UI environments).
+ */
+function findActiveWindowScene(host) {
+    try {
+        const app = host.UIApplication.sharedApplication;
+        const windows = app?.windows;
+        if (!windows || typeof windows.count !== 'number')
+            return null;
+        for (let i = 0; i < windows.count; i++) {
+            const w = windows.objectAtIndex(i);
+            const scene = w && w.windowScene;
+            if (scene)
+                return scene;
+        }
+    }
+    catch { }
+    return null;
+}
+function buildIosOverlayRefs(state) {
+    const host = getIosOverlayHost();
+    if (!host)
+        return null;
+    // Without a scene we can't build a modern UIWindow that actually renders.
+    // Fall back to the in-tree overlay rather than show nothing.
+    const scene = findActiveWindowScene(host);
+    if (!scene) {
+        if (state.verbose) {
+            console.info('[ns-hmr-overlay] no active UIWindowScene; skipping iOS overlay promotion');
+        }
+        return null;
+    }
+    try {
+        const { UIWindow, UIViewController, UIView, UILabel, UIColor, UIFont } = host;
+        const window = UIWindow.alloc().initWithWindowScene(scene);
+        window.windowLevel = computeIosOverlayWindowLevel(host.UIWindowLevelAlert ?? null);
+        window.backgroundColor = UIColor.clearColor;
+        window.hidden = true;
+        const controller = UIViewController.new();
+        controller.view.backgroundColor = UIColor.clearColor;
+        window.rootViewController = controller;
+        // UIViewAutoresizing bit masks. We mirror the UIKit constants here to
+        // avoid depending on symbols the metadata bridge does not always
+        // expose as top-level globals.
+        const FLEXIBLE_LEFT_MARGIN = 1 << 0;
+        const FLEXIBLE_WIDTH = 1 << 1;
+        const FLEXIBLE_RIGHT_MARGIN = 1 << 2;
+        const FLEXIBLE_TOP_MARGIN = 1 << 3;
+        const FLEXIBLE_HEIGHT = 1 << 4;
+        const FLEXIBLE_BOTTOM_MARGIN = 1 << 5;
+        const backdrop = UIView.new();
+        backdrop.backgroundColor = UIColor.colorWithRedGreenBlueAlpha(0, 0, 0, 0.35);
+        backdrop.autoresizingMask = FLEXIBLE_WIDTH | FLEXIBLE_HEIGHT;
+        controller.view.addSubview(backdrop);
+        const panel = UIView.new();
+        panel.backgroundColor = UIColor.whiteColor;
+        panel.autoresizingMask = FLEXIBLE_LEFT_MARGIN | FLEXIBLE_RIGHT_MARGIN | FLEXIBLE_TOP_MARGIN | FLEXIBLE_BOTTOM_MARGIN;
+        try {
+            panel.layer.cornerRadius = 14;
+            panel.layer.masksToBounds = true;
+        }
+        catch { }
+        controller.view.addSubview(panel);
+        const titleLabel = UILabel.new();
+        titleLabel.numberOfLines = 0;
+        titleLabel.textAlignment = 1; // NSTextAlignmentCenter
+        titleLabel.font = UIFont.boldSystemFontOfSize(16);
+        titleLabel.textColor = UIColor.blackColor;
+        panel.addSubview(titleLabel);
+        const statusLabel = UILabel.new();
+        statusLabel.numberOfLines = 0;
+        statusLabel.textAlignment = 1;
+        statusLabel.font = UIFont.systemFontOfSize(13);
+        statusLabel.textColor = UIColor.darkGrayColor;
+        panel.addSubview(statusLabel);
+        // Subtle drop-shadow so the toast chip reads against light app
+        // content (white-on-white is invisible). The error / centered
+        // branches still get the dim backdrop, so the shadow is mostly
+        // a no-op for them — but it's a one-time setup.
+        try {
+            panel.layer.shadowColor = UIColor.blackColor.CGColor;
+            panel.layer.shadowOpacity = 0.18;
+            panel.layer.shadowRadius = 8;
+            panel.layer.shadowOffset = { width: 0, height: 2 };
+            panel.layer.masksToBounds = false;
+        }
+        catch { }
+        // `wasVisible` / `currentPosition` are mutated by
+        // applySnapshotToIosRefs when the snapshot triggers a slide-in
+        // or slide-out. They start in the "hidden" state so the very
+        // first visible snapshot animates in cleanly.
+        return {
+            window,
+            controller,
+            backdrop,
+            panel,
+            titleLabel,
+            statusLabel,
+            wasVisible: false,
+            currentPosition: getHmrDevOverlayPosition(),
+        };
+    }
+    catch (err) {
+        console.warn('[ns-hmr-overlay] iOS overlay construction failed:', err?.message || err);
+        return null;
+    }
+}
+function ensureIosOverlayRefs(state) {
+    if (state.iosRefs)
+        return state.iosRefs;
+    if (state.iosBuildFailed)
+        return null;
+    const built = buildIosOverlayRefs(state);
+    if (built) {
+        state.iosRefs = built;
+    }
+    else {
+        // Remember failure so we don't hammer construction on every snapshot
+        // update — the in-tree path will take over for this session.
+        state.iosBuildFailed = true;
+    }
+    return state.iosRefs;
+}
+function layoutIosOverlayRefs(refs, position) {
+    try {
+        const bounds = refs.controller.view.bounds;
+        const viewWidth = Number(bounds?.size?.width) || 0;
+        const viewHeight = Number(bounds?.size?.height) || 0;
+        const raw = refs.controller.view.safeAreaInsets;
+        const safeInsets = raw
+            ? {
+                top: Number(raw.top) || 0,
+                bottom: Number(raw.bottom) || 0,
+                left: Number(raw.left) || 0,
+                right: Number(raw.right) || 0,
+            }
+            : { top: 0, bottom: 0, left: 0, right: 0 };
+        // Ask UIKit what the labels want given the panel inner width. We use a
+        // generous height bound so nothing clips on long reconnect strings.
+        const panelPadding = 16;
+        const horizontalMargin = 24;
+        const maxPanelWidth = 340;
+        const innerWidth = Math.max(0, Math.min(maxPanelWidth, viewWidth - 2 * horizontalMargin - safeInsets.left - safeInsets.right) - 2 * panelPadding);
+        const titleFit = refs.titleLabel.sizeThatFits({ width: innerWidth, height: 10000 }) || { height: 0 };
+        const statusFit = refs.statusLabel.sizeThatFits({ width: innerWidth, height: 10000 }) || { height: 0 };
+        const layout = computeIosOverlayLayout({
+            viewWidth,
+            viewHeight,
+            safeInsets,
+            titleHeight: Number(titleFit.height) || 0,
+            statusHeight: Number(statusFit.height) || 0,
+            maxPanelWidth,
+            horizontalMargin,
+            panelPadding,
+            position,
+        });
+        const toCgRect = (rect) => ({
+            origin: { x: rect.x, y: rect.y },
+            size: { width: rect.width, height: rect.height },
+        });
+        refs.backdrop.frame = toCgRect(layout.backdrop);
+        refs.panel.frame = toCgRect(layout.panel);
+        refs.titleLabel.frame = toCgRect(layout.title);
+        refs.statusLabel.frame = toCgRect(layout.status);
+        return layout;
+    }
+    catch (err) {
+        console.warn('[ns-hmr-overlay] iOS overlay layout failed:', err?.message || err);
+        return null;
+    }
+}
+/**
+ * Slide-in animation for the iOS toast panel. Off-screen start frame
+ * lives just above (top) or below (bottom) the visible area; the panel
+ * snaps to its target frame with a spring so the motion feels physical
+ * without the heavy "settle" overshoot of a hard spring (damping 0.85
+ * lands quickly with a small overshoot).
+ */
+function animateIosPanelIn(refs, position, layout) {
+    const g = getOverlayGlobal();
+    const UIView = g?.UIView;
+    if (!UIView)
+        return;
+    try {
+        const targetFrame = {
+            origin: { x: layout.panel.x, y: layout.panel.y },
+            size: { width: layout.panel.width, height: layout.panel.height },
+        };
+        // Off-screen start: distance includes a small fudge so the
+        // shadow blur tail isn't visible at t=0.
+        const startY = position === 'bottom' ? layout.backdrop.height + 24 : -(layout.panel.height + 24);
+        refs.panel.frame = {
+            origin: { x: layout.panel.x, y: startY },
+            size: { width: layout.panel.width, height: layout.panel.height },
+        };
+        refs.panel.alpha = 0;
+        try {
+            if (typeof UIView.animateWithDurationDelayUsingSpringWithDampingInitialSpringVelocityOptionsAnimationsCompletion === 'function') {
+                UIView.animateWithDurationDelayUsingSpringWithDampingInitialSpringVelocityOptionsAnimationsCompletion(0.42, 0, 0.85, 0.7, 0, () => {
+                    refs.panel.frame = targetFrame;
+                    refs.panel.alpha = 1;
+                }, null);
+            }
+            else if (typeof UIView.animateWithDurationAnimations === 'function') {
+                UIView.animateWithDurationAnimations(0.32, () => {
+                    refs.panel.frame = targetFrame;
+                    refs.panel.alpha = 1;
+                });
+            }
+            else {
+                refs.panel.frame = targetFrame;
+                refs.panel.alpha = 1;
+            }
+        }
+        catch {
+            refs.panel.frame = targetFrame;
+            refs.panel.alpha = 1;
+        }
+    }
+    catch { }
+}
+/**
+ * Slide-out animation for the iOS toast panel. Mirrors animateIosPanelIn:
+ * the panel travels to the nearest off-screen edge while fading out so
+ * the dismissal still feels intentional even on fast HMR cycles.
+ */
+function animateIosPanelOut(refs, position, onComplete) {
+    const g = getOverlayGlobal();
+    const UIView = g?.UIView;
+    const currentFrame = refs.panel?.frame;
+    if (!UIView || !currentFrame) {
+        onComplete();
+        return;
+    }
+    try {
+        const bounds = refs.controller?.view?.bounds;
+        const viewHeight = Number(bounds?.size?.height) || 0;
+        const targetY = position === 'bottom' ? viewHeight + 24 : -(Number(currentFrame.size?.height) + 24);
+        const startFrame = currentFrame;
+        const targetFrame = {
+            origin: { x: Number(startFrame.origin?.x) || 0, y: targetY },
+            size: startFrame.size,
+        };
+        try {
+            if (typeof UIView.animateWithDurationDelayOptionsAnimationsCompletion === 'function') {
+                // UIViewAnimationOptionCurveEaseIn = 1 << 16 — accelerate
+                // out so the dismissal doesn't drag on screen.
+                UIView.animateWithDurationDelayOptionsAnimationsCompletion(0.22, 0, 1 << 16, () => {
+                    refs.panel.frame = targetFrame;
+                    refs.panel.alpha = 0;
+                }, () => onComplete());
+            }
+            else if (typeof UIView.animateWithDurationAnimationsCompletion === 'function') {
+                UIView.animateWithDurationAnimationsCompletion(0.22, () => {
+                    refs.panel.frame = targetFrame;
+                    refs.panel.alpha = 0;
+                }, () => onComplete());
+            }
+            else {
+                refs.panel.alpha = 0;
+                onComplete();
+            }
+        }
+        catch {
+            refs.panel.alpha = 0;
+            onComplete();
+        }
+    }
+    catch {
+        onComplete();
+    }
+}
+function applySnapshotToIosRefs(refs, snapshot) {
+    if (!refs)
+        return false;
+    try {
+        // 'update' mode rides the same dedicated UIWindow as
+        // 'connection' so the HMR apply overlay always stacks above
+        // modals/sheets/system alerts. The window is constructed
+        // lazily (ensureIosOverlayRefs) and reused for the lifetime of
+        // the dev session.
+        const visible = snapshot.visible && (snapshot.mode === 'connection' || snapshot.mode === 'update');
+        const wasVisible = !!refs.wasVisible;
+        const position = getHmrDevOverlayPosition();
+        const previousPosition = refs.currentPosition;
+        const isToast = position !== 'center';
+        // Touches pass through the overlay window in toast mode so
+        // the user can keep tapping the app while the HMR chip is
+        // shown. In centered mode we keep the blocking
+        // behaviour (the dim backdrop is itself a hint to wait).
+        try {
+            refs.window.userInteractionEnabled = !isToast;
+        }
+        catch { }
+        if (!visible) {
+            // Animate out before hiding the window so the dismissal
+            // has a discoverable motion. Only animate when previously
+            // visible and in toast mode — centered modal hides instantly.
+            if (wasVisible && isToast) {
+                animateIosPanelOut(refs, previousPosition, () => {
+                    try {
+                        refs.window.hidden = true;
+                    }
+                    catch { }
+                });
+            }
+            else {
+                refs.window.hidden = true;
+            }
+            refs.wasVisible = false;
+            refs.currentPosition = position;
+            return true;
+        }
+        refs.window.hidden = false;
+        refs.titleLabel.text = snapshot.title || '';
+        refs.statusLabel.text = formatStatusText(snapshot);
+        const host = getIosOverlayHost();
+        if (host) {
+            const { UIColor } = host;
+            const isError = snapshot.tone === 'error';
+            const isSuccess = snapshot.tone === 'success';
+            try {
+                if (isError) {
+                    // Red panel + dark red text (existing UX).
+                    refs.panel.backgroundColor = UIColor.colorWithRedGreenBlueAlpha(1, 0.96, 0.96, 1);
+                    refs.titleLabel.textColor = UIColor.colorWithRedGreenBlueAlpha(0.7, 0.1, 0.06, 1);
+                    refs.statusLabel.textColor = UIColor.colorWithRedGreenBlueAlpha(0.7, 0.1, 0.06, 0.9);
+                }
+                else if (isSuccess) {
+                    // Slightly more saturated green panel + dark-green
+                    // text. The previous 0.94/0.99/0.95 background was
+                    // nearly indistinguishable from white on most
+                    // devices; this bump keeps long detail strings
+                    // readable while making the apply event obviously
+                    // "happening right now".
+                    refs.panel.backgroundColor = UIColor.colorWithRedGreenBlueAlpha(0.9, 0.97, 0.91, 1);
+                    refs.titleLabel.textColor = UIColor.colorWithRedGreenBlueAlpha(0.05, 0.43, 0.18, 1);
+                    refs.statusLabel.textColor = UIColor.colorWithRedGreenBlueAlpha(0.05, 0.43, 0.18, 1);
+                }
+                else {
+                    // Default (info / warn) — existing connection look.
+                    refs.panel.backgroundColor = UIColor.whiteColor;
+                    refs.titleLabel.textColor = UIColor.blackColor;
+                    refs.statusLabel.textColor = UIColor.darkGrayColor;
+                }
+                // Backdrop dims only in centered mode; toast mode keeps
+                // the rest of the app fully visible/usable. Errors get
+                // a slightly stronger dim in centered mode because the
+                // user MUST notice them.
+                if (isToast) {
+                    refs.backdrop.backgroundColor = UIColor.clearColor;
+                }
+                else if (isError) {
+                    refs.backdrop.backgroundColor = UIColor.colorWithRedGreenBlueAlpha(0, 0, 0, 0.35);
+                }
+                else if (isSuccess) {
+                    refs.backdrop.backgroundColor = UIColor.colorWithRedGreenBlueAlpha(0, 0.15, 0.05, 0.28);
+                }
+                else {
+                    refs.backdrop.backgroundColor = UIColor.colorWithRedGreenBlueAlpha(0, 0, 0, 0.35);
+                }
+            }
+            catch { }
+        }
+        const layout = layoutIosOverlayRefs(refs, position);
+        // Slide-in animation only fires on the actual hidden→visible
+        // transition (or on a position swap — e.g. dev toggling top
+        // to bottom mid-cycle). Subsequent updates within the same
+        // visible cycle just refresh text/colours without re-animating.
+        const positionChanged = previousPosition !== position;
+        const justAppeared = !wasVisible || positionChanged;
+        if (justAppeared && isToast && layout) {
+            animateIosPanelIn(refs, position, layout);
+        }
+        else if (justAppeared && !isToast) {
+            // Centered modal: ensure alpha is reset to 1 in case a
+            // previous toast-mode dismissal left it at 0.
+            try {
+                refs.panel.alpha = 1;
+            }
+            catch { }
+        }
+        refs.wasVisible = true;
+        refs.currentPosition = position;
+        return true;
+    }
+    catch (err) {
+        console.warn('[ns-hmr-overlay] iOS overlay apply failed:', err?.message || err);
+        return false;
+    }
 }
 function applyRuntimeSnapshot(snapshot) {
     const state = getRuntimeState();
@@ -613,15 +1342,108 @@ function applyRuntimeSnapshot(snapshot) {
         updateBootStatusLabel(snapshot);
     }
     applySnapshotToBootRefs(state.bootRefs, snapshot);
-    if (snapshot.visible && snapshot.mode === 'connection') {
-        const liveRefs = ensureLiveOverlayRefs(snapshot);
-        applySnapshotToLiveRefs(liveRefs, snapshot);
+    // prefer the dedicated UIWindow
+    // path so the live/update overlays always stack on top of modals,
+    // sheets, and other windows. Fall back to the in-tree overlay when
+    // iOS APIs aren't available (Android, tests, or when scene
+    // construction fails).
+    let handledByIos = false;
+    // Both 'connection' and 'update' use the small-panel surface
+    // (UIWindow on iOS, in-tree overlay everywhere else). 'boot' uses
+    // the placeholder root via applySnapshotToBootRefs above; 'hidden'
+    // hides everything.
+    const wantsOverlay = snapshot.visible && (snapshot.mode === 'connection' || snapshot.mode === 'update');
+    if (getIosOverlayHost()) {
+        if (wantsOverlay) {
+            const iosRefs = ensureIosOverlayRefs(state);
+            handledByIos = applySnapshotToIosRefs(iosRefs, snapshot);
+        }
+        else if (state.iosRefs) {
+            handledByIos = applySnapshotToIosRefs(state.iosRefs, snapshot);
+        }
     }
-    else {
-        applySnapshotToLiveRefs(state.liveRefs, snapshot);
+    if (!handledByIos) {
+        if (wantsOverlay) {
+            const liveRefs = ensureLiveOverlayRefs(snapshot);
+            applySnapshotToLiveRefs(liveRefs, snapshot);
+        }
+        else {
+            applySnapshotToLiveRefs(state.liveRefs, snapshot);
+        }
     }
     return state.snapshot;
 }
+// How long the 'complete' frame stays on screen before we auto-hide.
+// The original 350ms was too tight: many HMR cycles complete in
+// 50–250ms, so the *total* overlay lifetime (received → complete +
+// 350ms) was often under 500ms, which is faster than the human eye
+// can comfortably register. 600ms gives the user time to read the
+// "Total Xms" line and confirm visually that something happened.
+const UPDATE_AUTO_HIDE_MS = 600;
+// Minimum perceptible duration for an entire update overlay cycle
+// (from 'received' to hide). If the cycle finished in 50ms (e.g., a
+// tiny HTML edit on a warm cache), we still hold for ~MIN_VISIBLE_MS
+// total before hiding so the overlay is actually seen. Combined with
+// UPDATE_AUTO_HIDE_MS, the *effective* hold-after-complete =
+// max(UPDATE_AUTO_HIDE_MS, MIN_VISIBLE_MS - elapsed-since-received).
+const UPDATE_MIN_VISIBLE_MS = 800;
+function clearUpdateAutoHideTimer(state) {
+    if (state.updateAutoHideTimer) {
+        try {
+            clearTimeout(state.updateAutoHideTimer);
+        }
+        catch { }
+        state.updateAutoHideTimer = null;
+    }
+}
+function scheduleUpdateAutoHide(state) {
+    clearUpdateAutoHideTimer(state);
+    // Compute how much longer we need to hold the overlay so that the
+    // total cycle visibility is at least UPDATE_MIN_VISIBLE_MS. For
+    // fast cycles (50ms reboot) this stretches the hide; for slow
+    // cycles (>UPDATE_MIN_VISIBLE_MS) it falls back to the standard
+    // UPDATE_AUTO_HIDE_MS so we don't truncate the celebratory hold.
+    const startedAt = state.updateCycleStartedAt || 0;
+    const elapsed = startedAt > 0 ? Math.max(0, Date.now() - startedAt) : 0;
+    const minRemainder = elapsed > 0 ? Math.max(0, UPDATE_MIN_VISIBLE_MS - elapsed) : UPDATE_MIN_VISIBLE_MS;
+    const holdMs = Math.max(UPDATE_AUTO_HIDE_MS, minRemainder);
+    try {
+        state.updateAutoHideTimer = setTimeout(() => {
+            state.updateAutoHideTimer = null;
+            // Critical: only auto-hide if we're still on the 'complete'
+            // frame. If a new HMR cycle has rotated the snapshot back
+            // to 'update' / 'received' (e.g., user saved twice in
+            // quick succession), the new cycle owns the overlay and
+            // our timer must not steal it.
+            const current = state.snapshot;
+            if (current.mode === 'update' && current.tone === 'success' && current.progress === 100) {
+                state.updateCycleStartedAt = 0;
+                applyRuntimeSnapshot({ ...DEFAULT_SNAPSHOT });
+            }
+        }, holdMs);
+    }
+    catch {
+        // setTimeout missing (extremely rare; some test envs). Fall
+        // back to immediate hide so we never leave the overlay visible
+        // forever after a 'complete'.
+        state.updateCycleStartedAt = 0;
+        applyRuntimeSnapshot({ ...DEFAULT_SNAPSHOT });
+    }
+}
+function logUpdateStageTransition(state, stage, info) {
+    if (!state.verbose)
+        return;
+    try {
+        const detail = info?.detail || '';
+        const progress = typeof info?.progress === 'number' ? info.progress : null;
+        const progressTag = progress !== null ? ` (${Math.round(progress)}%)` : '';
+        // Single-line breadcrumb so a developer can correlate
+        // overlay frames with the [ns-hmr][angular] timing log when
+        // debugging "I don't see the overlay" reports.
+        console.info(`[ns-hmr-overlay] update stage=${stage}${progressTag}${detail ? ` detail=${detail}` : ''}`);
+    }
+    catch { }
+}
 function createOverlayApi() {
     return {
         ensureBootPage(verbose) {
@@ -637,12 +1459,74 @@ function createOverlayApi() {
             return state.bootRefs?.page || null;
         },
         setBootStage(stage, info) {
-            return applyRuntimeSnapshot(createBootOverlaySnapshot(stage, info));
+            // A boot transition cancels any pending HMR auto-hide so
+            // the boot phase always wins.
+            const state = getRuntimeState();
+            clearUpdateAutoHideTimer(state);
+            state.updateCycleStartedAt = 0;
+            const next = createBootOverlaySnapshot(stage, info);
+            // Monotonic boot-progress ratchet: boot stages can fire out of
+            // order across boot paths (native `__nsStartDevSession` vs the
+            // http-bootloader fallback) and individual bases were tuned
+            // independently, so clamp boot→boot transitions to never go
+            // backwards. Non-boot snapshots (error/ready) bypass — they
+            // genuinely want to reset the visual.
+            if (next.mode === 'boot' && state.snapshot.mode === 'boot' && typeof next.progress === 'number' && typeof state.snapshot.progress === 'number' && next.progress < state.snapshot.progress) {
+                next.progress = state.snapshot.progress;
+            }
+            return applyRuntimeSnapshot(next);
         },
         setConnectionStage(stage, info) {
+            const state = getRuntimeState();
+            clearUpdateAutoHideTimer(state);
+            state.updateCycleStartedAt = 0;
             return applyRuntimeSnapshot(createConnectionOverlaySnapshot(stage, info));
         },
+        setUpdateStage(stage, info) {
+            const state = getRuntimeState();
+            // Each new in-progress stage cancels any pending auto-hide
+            // from a previous cycle. Without this, two saves in quick
+            // succession could see cycle-2's progress overlay yanked
+            // off by cycle-1's already-scheduled hide.
+            clearUpdateAutoHideTimer(state);
+            // Stamp the cycle start on 'received', but distinguish
+            // between two cases:
+            //
+            //   (a) Re-assertion of the SAME cycle (e.g., the server
+            //       emits both `ns:hmr-pending` AND `ns:angular-update`,
+            //       both of which call `setUpdateStage('received')`).
+            //       We must PRESERVE the original timestamp so the
+            //       minimum-visible-window math measures the FIRST
+            //       'received' the user actually saw.
+            //
+            //   (b) Genuinely-new cycle starting either from a hidden
+            //       overlay OR while the previous cycle is still on
+            //       its 'complete' frame (pre auto-hide). In both
+            //       sub-cases we MUST stamp a fresh start so the
+            //       new cycle's auto-hide math is sane.
+            //
+            // We treat the previous snapshot as "in-progress for the
+            // same cycle" iff mode==='update' AND progress!==100.
+            // 'complete' frames are a sign that the cycle finished;
+            // any subsequent 'received' is a NEW cycle.
+            if (stage === 'received') {
+                const prev = state.snapshot;
+                const isMidCycleReassertion = prev.mode === 'update' && prev.progress !== 100;
+                if (!isMidCycleReassertion) {
+                    state.updateCycleStartedAt = Date.now();
+                }
+            }
+            logUpdateStageTransition(state, stage, info);
+            const snapshot = applyRuntimeSnapshot(createUpdateOverlaySnapshot(stage, info));
+            if (stage === 'complete') {
+                scheduleUpdateAutoHide(state);
+            }
+            return snapshot;
+        },
         hide() {
+            const state = getRuntimeState();
+            clearUpdateAutoHideTimer(state);
+            state.updateCycleStartedAt = 0;
             applyRuntimeSnapshot({ ...DEFAULT_SNAPSHOT });
         },
         getSnapshot() {
@@ -668,6 +1552,14 @@ export function setHmrBootStage(stage, info) {
 export function setHmrConnectionStage(stage, info) {
     return ensureHmrDevOverlayRuntimeInstalled().setConnectionStage(stage, info);
 }
+// Public entry point for driving the HMR-applying overlay. Callers
+// walk through stages (received → evicting → reimporting → rebooting
+// → complete); 'complete' auto-hides after a short interval.
+// Soft-fails (no-op) if the runtime overlay was never installed
+// (e.g., production builds, test environments).
+export function setHmrUpdateStage(stage, info) {
+    return ensureHmrDevOverlayRuntimeInstalled().setUpdateStage(stage, info);
+}
 export function hideHmrDevOverlay(reason) {
     void reason;
     ensureHmrDevOverlayRuntimeInstalled().hide(reason);