@nativescript/vite 0.0.1-alpha.7 → 0.0.2

package/dist/hmr/runtime-vue.js

@@ -1,2306 +0,0 @@
-// Vue HMR Runtime Integration for NativeScript
-// Clean implementation replacing corrupted content
-import componentTracker from './component-tracker';
-const VERBOSE = true;
-// Track deferred update attempts per instance to avoid infinite loops
-const __pendingUpdateAttempts = new WeakMap();
-const MAX_DEFER_ATTEMPTS = 8;
-const BASE_DEFER_MS = 16; // ~1 frame
-// Microtask and frame schedulers for consistent timing across runtimes
-function scheduleMicrotask(fn) {
-    try {
-        if (typeof globalThis.queueMicrotask === 'function')
-            return void globalThis.queueMicrotask(fn);
-    }
-    catch { }
-    try {
-        Promise.resolve().then(fn);
-    }
-    catch {
-        setTimeout(fn, 0);
-    }
-}
-function scheduleNextFrame(fn) {
-    try {
-        const raf = globalThis.requestAnimationFrame;
-        if (typeof raf === 'function')
-            return void raf(() => fn());
-    }
-    catch { }
-    setTimeout(fn, 16);
-}
-function resolveNSView(el) {
-    let view = null;
-    let nativeView = null;
-    try {
-        if (el && typeof el === 'object') {
-            // Method 1: Direct NativeScript view
-            if (el.nativeViewProtected) {
-                view = el;
-                nativeView = el.nativeViewProtected;
-            }
-            else if (el.nativeView) {
-                nativeView = el.nativeView;
-                view = el.view || el; // Use el as view if no separate view property
-            }
-            // Method 2: NSVElement wrapper
-            else if (el.view && el.view.nativeViewProtected) {
-                view = el.view;
-                nativeView = el.view.nativeViewProtected;
-            }
-            else if (el.view) {
-                view = el.view;
-                nativeView = view.nativeViewProtected || view.nativeView || null;
-            }
-            // Method 3: Check if el itself is a native view that we need to wrap
-            else if (el._nativeView || el.__native) {
-                nativeView = el._nativeView || el.__native;
-                view = el; // el is the wrapper
-            }
-            // Method 4: Check parent node navigation
-            else if (el.parentNode) {
-                try {
-                    const p = el.parentNode;
-                    if (p) {
-                        if (p.nativeViewProtected) {
-                            view = p;
-                            nativeView = p.nativeViewProtected;
-                        }
-                        else if (p.view && p.view.nativeViewProtected) {
-                            view = p.view;
-                            nativeView = p.view.nativeViewProtected;
-                        }
-                        else if (p.nativeView) {
-                            nativeView = p.nativeView;
-                            view = p.view || p;
-                        }
-                    }
-                }
-                catch { }
-            }
-            // Method 5: Try to find NativeScript view from iOS/Android native objects
-            else if (typeof el.ios !== 'undefined' || typeof el.android !== 'undefined') {
-                // el might be a native view directly, try to find the wrapper
-                nativeView = el;
-                // Look for ViewBase wrapper in parent hierarchy or references
-                try {
-                    if (el._owner) {
-                        view = el._owner;
-                    }
-                    else if (el.__owner) {
-                        view = el.__owner;
-                    }
-                }
-                catch { }
-            }
-        }
-    }
-    catch { }
-    const hasNativeView = !!nativeView;
-    let suspendCount;
-    let isLoaded;
-    try {
-        const v = view || el;
-        if (v && typeof v === 'object') {
-            suspendCount = v._suspendNativeUpdatesCount;
-            const field = v._isLoaded;
-            const getter = v.isLoaded;
-            isLoaded = typeof field === 'boolean' ? field : (typeof getter === 'boolean' ? getter : undefined);
-        }
-    }
-    catch { }
-    const isRootView = !!(view && view.mIsRootView);
-    return { el, view, nativeView, hasNativeView, isRootView, suspendCount, isLoaded };
-}
-// Probe multiple likely locations on a component instance to find an NS view quickly after updates
-function findNSViewFromInternal(internal) {
-    const candidates = [];
-    try {
-        const ins = internal || {};
-        const vnode = ins.vnode;
-        const proxy = ins.proxy;
-        const subTree = ins.subTree;
-        // Add candidates in order of preference - prioritize NativeScript elements
-        if (proxy && proxy.$el) {
-            const el = proxy.$el;
-            if (el && el.constructor && el.constructor.name === 'NSVElement') {
-                candidates.unshift(el); // Prioritize NSVElement
-            }
-            else {
-                candidates.push(el);
-            }
-        }
-        if (vnode && vnode.el) {
-            const el = vnode.el;
-            if (el && el.constructor && el.constructor.name === 'NSVElement') {
-                candidates.unshift(el); // Prioritize NSVElement
-            }
-            else {
-                candidates.push(el);
-            }
-        }
-        if (subTree && subTree.el) {
-            const el = subTree.el;
-            if (el && el.constructor && el.constructor.name === 'NSVElement') {
-                candidates.unshift(el); // Prioritize NSVElement
-            }
-            else {
-                candidates.push(el);
-            }
-        }
-        // Check subTree component hierarchy
-        if (subTree && subTree.component && subTree.component.vnode) {
-            const c = subTree.component;
-            if (c.vnode && c.vnode.el) {
-                const el = c.vnode.el;
-                if (el && el.constructor && el.constructor.name === 'NSVElement') {
-                    candidates.unshift(el); // Prioritize NSVElement
-                }
-                else {
-                    candidates.push(el);
-                }
-            }
-            if (c.subTree && c.subTree.el) {
-                const el = c.subTree.el;
-                if (el && el.constructor && el.constructor.name === 'NSVElement') {
-                    candidates.unshift(el); // Prioritize NSVElement
-                }
-                else {
-                    candidates.push(el);
-                }
-            }
-        }
-        // Also peek one level deeper through children arrays if present
-        try {
-            const st = subTree;
-            const ch = st && (st.children || st.child);
-            if (Array.isArray(ch)) {
-                for (const it of ch) {
-                    if (!it || typeof it !== 'object')
-                        continue;
-                    try {
-                        if (it.el) {
-                            const el = it.el;
-                            if (el && el.constructor && el.constructor.name === 'NSVElement') {
-                                candidates.unshift(el); // Prioritize NSVElement
-                            }
-                            else {
-                                candidates.push(el);
-                            }
-                        }
-                    }
-                    catch { }
-                    try {
-                        if (it.component && it.component.vnode && it.component.vnode.el)
-                            candidates.push(it.component.vnode.el);
-                    }
-                    catch { }
-                    try {
-                        if (it.component && it.component.subTree && it.component.subTree.el)
-                            candidates.push(it.component.subTree.el);
-                    }
-                    catch { }
-                }
-            }
-        }
-        catch { }
-        // Add the internal instance itself as a candidate only if it might be useful
-        if (ins && typeof ins === 'object' && !candidates.length) {
-            candidates.push(ins);
-        }
-    }
-    catch { }
-    if (VERBOSE && candidates.length > 0) {
-        console.info('[ns-hmr][vue-runtime] findNSViewFromInternal candidates:', {
-            count: candidates.length,
-            types: candidates.map(c => c?.constructor?.name || typeof c).slice(0, 5)
-        });
-    }
-    // Evaluate in order; return first with a nativeView
-    for (const el of candidates) {
-        try {
-            const info = resolveNSView(el);
-            if (VERBOSE) {
-                console.info('[ns-hmr][vue-runtime] candidate evaluation:', {
-                    elType: el?.constructor?.name || typeof el,
-                    hasNativeView: info.hasNativeView,
-                    hasView: !!info.view,
-                    viewType: info.view?.constructor?.name
-                });
-            }
-            if (info && info.hasNativeView) {
-                if (VERBOSE)
-                    console.info('[ns-hmr][vue-runtime] Found valid candidate with native view');
-                return { el, info };
-            }
-        }
-        catch { }
-    }
-    // Fallback to first candidate if any
-    const first = candidates.length ? candidates[0] : null;
-    const info = resolveNSView(first);
-    if (VERBOSE) {
-        console.info('[ns-hmr][vue-runtime] Using fallback candidate:', {
-            hasFirst: !!first,
-            firstType: first?.constructor?.name || typeof first,
-            hasNativeView: info.hasNativeView,
-            hasView: !!info.view
-        });
-    }
-    return { el: first, info };
-}
-function registerExistingComponents(runtime) {
-    try {
-        if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime] Registering existing components with HMR runtime');
-        let registeredCount = 0;
-        // Method 1: Use component tracker
-        const allInstances = componentTracker.getAllInstances();
-        for (const [id, instances] of allInstances) {
-            try {
-                // Create record for this component type if not already recorded
-                if (typeof runtime.createRecord === 'function' && typeof runtime.isRecorded === 'function') {
-                    if (!runtime.isRecorded(id)) {
-                        // Get component definition from first instance
-                        const firstInstance = Array.from(instances)[0];
-                        const componentDef = firstInstance?.$?.type || firstInstance?.type || {};
-                        runtime.createRecord(id, componentDef);
-                        if (VERBOSE)
-                            console.info('[ns-hmr][vue-runtime] Created record for component:', id);
-                    }
-                }
-                // Register all instances of this component
-                if (typeof runtime.registerInstance === 'function') {
-                    for (const instance of instances) {
-                        runtime.registerInstance(id, instance);
-                        registeredCount++;
-                    }
-                }
-            }
-            catch (e) {
-                if (VERBOSE)
-                    console.warn('[ns-hmr][vue-runtime] Failed to register component:', id, e?.message);
-            }
-        }
-        // Method 2: Bridge with fallback runtime records (handle the disconnect)
-        try {
-            const fallbackRuntime = runtime;
-            if (fallbackRuntime && fallbackRuntime.map) {
-                let fallbackCount = 0;
-                const records = fallbackRuntime.map;
-                if (records && typeof records.forEach === 'function') {
-                    // Map object with forEach
-                    records.forEach((instances, id) => {
-                        fallbackCount++;
-                        if (VERBOSE)
-                            console.info('[ns-hmr][vue-runtime] Found fallback record:', id, 'instances:', instances ? instances.length : 0);
-                    });
-                }
-                else if (records && typeof records === 'object') {
-                    // Plain object
-                    for (const [id, instances] of Object.entries(records)) {
-                        fallbackCount++;
-                        if (VERBOSE)
-                            console.info('[ns-hmr][vue-runtime] Found fallback record:', id, 'instances:', instances?.length || 0);
-                    }
-                }
-                if (VERBOSE)
-                    console.info('[ns-hmr][vue-runtime] Fallback runtime has', fallbackCount, 'records');
-            }
-        }
-        catch (e) {
-            if (VERBOSE)
-                console.warn('[ns-hmr][vue-runtime] Failed to analyze fallback runtime records:', e?.message);
-        }
-        if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime] Registered existing components:', {
-                componentTypes: allInstances.size,
-                instanceCount: registeredCount
-            });
-    }
-    catch (e) {
-        if (VERBOSE)
-            console.warn('[ns-hmr][vue-runtime] Failed to register existing components:', e?.message);
-    }
-}
-function getComponentIdFromInternal(internal) {
-    try {
-        // Try to get component ID from various locations
-        const type = internal?.type || internal?.vnode?.type;
-        if (type) {
-            // Check for __hmrId (Vue 3 HMR component ID)
-            if (type.__hmrId)
-                return type.__hmrId;
-            // Check for __file (component file path)
-            if (type.__file)
-                return type.__file;
-            // Check for name
-            if (type.name)
-                return type.name;
-            // Check for _name (internal Vue name)
-            if (type._name)
-                return type._name;
-        }
-        // Check component instance for name
-        if (internal?.proxy?.$options?.name)
-            return internal.proxy.$options.name;
-        if (internal?.proxy?.$options?.__file)
-            return internal.proxy.$options.__file;
-        // Fallback to component constructor name
-        if (internal?.constructor?.name && internal.constructor.name !== 'Object') {
-            return internal.constructor.name;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-function instanceHasFrameOrPage(internal) {
-    try {
-        const q = [];
-        const push = (n) => { if (n && typeof n === 'object')
-            q.push(n); };
-        push(internal?.subTree || internal?.vnode);
-        let seen = 0;
-        while (q.length && seen < 50) {
-            const n = q.shift();
-            seen++;
-            try {
-                const t = (n && (n.type || n.component?.type)) || null;
-                const name = t && ((t.__name || t.name || '').toString().toLowerCase());
-                if (name === 'frame' || name === 'page')
-                    return true;
-            }
-            catch { }
-            try {
-                if (n.component)
-                    push(n.component.subTree);
-            }
-            catch { }
-            try {
-                const ch = (n.children || n.child);
-                if (Array.isArray(ch))
-                    for (const c of ch)
-                        push(c);
-                else
-                    push(ch);
-            }
-            catch { }
-        }
-    }
-    catch { }
-    return false;
-}
-// Cache resolved views per instance to avoid inconsistent lookups
-const instanceViewCache = new WeakMap();
-// Cache the working instance per component ID to ensure consistency
-const workingInstanceCache = new Map();
-// Global registry to track the current working instance being processed
-let currentWorkingInstance = null;
-let currentComponentId = null;
-function setCurrentWorkingInstance(instance, componentId) {
-    currentWorkingInstance = instance;
-    currentComponentId = componentId || null;
-    if (VERBOSE && componentId) {
-        console.info('[ns-hmr][vue-runtime] Set current working instance for:', componentId);
-    }
-}
-function getCurrentWorkingInstance() {
-    return currentWorkingInstance;
-}
-function isNSViewReady(instance, componentId) {
-    try {
-        if (VERBOSE) {
-            console.info('[ns-hmr][vue-runtime] isNSViewReady called with:', {
-                hasInstance: !!instance,
-                instanceType: instance?.constructor?.name,
-                componentId: componentId || 'none',
-                hasCachedWorking: componentId ? workingInstanceCache.has(componentId) : false,
-                hasCurrentWorking: !!currentWorkingInstance
-            });
-        }
-        // Priority 1: If we have a cached working instance for this component, use it
-        if (componentId && workingInstanceCache.has(componentId)) {
-            const workingInstance = workingInstanceCache.get(componentId);
-            if (workingInstance && workingInstance !== instance) {
-                if (VERBOSE) {
-                    console.info('[ns-hmr][vue-runtime] Using cached working instance for component:', componentId);
-                }
-                instance = workingInstance;
-            }
-        }
-        // Priority 2: If no cached instance but we have a current working instance, try it
-        else if (currentWorkingInstance && currentWorkingInstance !== instance) {
-            if (VERBOSE) {
-                console.info('[ns-hmr][vue-runtime] Trying current working instance as fallback');
-            }
-            // Test the current working instance first
-            const testFound = findNSViewFromInternal(currentWorkingInstance);
-            if (testFound.info?.hasNativeView) {
-                if (VERBOSE) {
-                    console.info('[ns-hmr][vue-runtime] Current working instance is valid, using it');
-                }
-                instance = currentWorkingInstance;
-                // Cache it for this component if we have a component ID
-                if (componentId) {
-                    workingInstanceCache.set(componentId, currentWorkingInstance);
-                }
-            }
-        }
-        let cached = instanceViewCache.get(instance);
-        if (!cached) {
-            const found = findNSViewFromInternal(instance);
-            if (found.info?.hasNativeView) {
-                instanceViewCache.set(instance, found);
-                cached = found;
-                // Cache this as the working instance for this component
-                if (componentId && !workingInstanceCache.has(componentId)) {
-                    workingInstanceCache.set(componentId, instance);
-                    if (VERBOSE) {
-                        console.info('[ns-hmr][vue-runtime] Cached working instance for component:', componentId);
-                    }
-                }
-            }
-        }
-        const hasNativeView = cached?.info?.hasNativeView || false;
-        const view = cached?.info?.view;
-        if (VERBOSE) {
-            console.info('[ns-hmr][vue-runtime] isNSViewReady check:', {
-                hasEl: !!cached?.el,
-                elType: cached?.el?.constructor?.name,
-                hasNativeView,
-                suspendCount: cached?.info?.suspendCount,
-                isLoaded: cached?.info?.isLoaded,
-                view: !!view,
-                viewType: view?.constructor?.name,
-                fromCache: instanceViewCache.has(instance),
-                usingWorkingInstance: componentId && workingInstanceCache.has(componentId),
-                componentId: componentId || 'none'
-            });
-        }
-        if (!hasNativeView) {
-            if (VERBOSE)
-                console.info('[ns-hmr][vue-runtime] Not ready: no native view');
-            return false;
-        }
-        if (typeof cached?.info?.suspendCount === 'number' && cached.info.suspendCount !== 0) {
-            if (VERBOSE)
-                console.info('[ns-hmr][vue-runtime] Not ready: suspended', { suspendCount: cached.info.suspendCount });
-            return false;
-        }
-        if (typeof cached?.info?.isLoaded === 'boolean' && cached.info.isLoaded === false) {
-            if (VERBOSE)
-                console.info('[ns-hmr][vue-runtime] Not ready: not loaded');
-            return false;
-        }
-        if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime] View is ready for update');
-    }
-    catch (e) {
-        if (VERBOSE)
-            console.warn('[ns-hmr][vue-runtime] isNSViewReady failed:', e?.message);
-        return false;
-    }
-    return true;
-}
-const __postUpdateStabilized = new WeakSet();
-const __postUpdateFollowed = new WeakSet();
-// Cache the last resolved element for an internal instance to help stabilization find it later
-const __lastResolvedEl = new WeakMap();
-// Guard to avoid blasting global layout more than once per instance
-const __globalLayoutRequested = new WeakSet();
-function stabilizeNativeLayout(internal, attempt = 1) {
-    try {
-        if (!internal || __postUpdateStabilized.has(internal))
-            return;
-        // Prefer the last-resolved element if we have one; otherwise probe fresh
-        let cached = __lastResolvedEl.get(internal) || null;
-        let probe = cached || findNSViewFromInternal(internal);
-        let el = probe.el;
-        let info = probe.info;
-        // If still no native view, attempt to walk up a couple of parent components to find a parent view
-        let parentInfo = null;
-        if (!info?.hasNativeView) {
-            try {
-                let p = internal.parent;
-                let hops = 0;
-                while (p && hops < 3 && !(parentInfo && parentInfo.hasNativeView)) {
-                    try {
-                        const pp = findNSViewFromInternal(p);
-                        if (pp && pp.info && pp.info.hasNativeView) {
-                            parentInfo = pp.info;
-                            break;
-                        }
-                    }
-                    catch { }
-                    p = p.parent;
-                    hops++;
-                }
-            }
-            catch { }
-        }
-        const v = info.view;
-        const nv = info.nativeView;
-        // If this instance has a working native view, set it as current working instance
-        if (info?.hasNativeView && probe.el) {
-            setCurrentWorkingInstance(internal);
-            if (VERBOSE) {
-                console.info('[ns-hmr][vue-runtime] stabilizeNativeLayout found working instance');
-            }
-        }
-        if (VERBOSE) {
-            try {
-                const name = v && v.constructor ? v.constructor.name : undefined;
-                const snap = {
-                    attempt,
-                    hasView: !!v,
-                    hasNativeView: !!nv,
-                    viewType: name,
-                    hasVNode: !!(internal && internal.vnode),
-                    hasSubTree: !!(internal && internal.subTree),
-                    parentHasNativeView: !!(parentInfo && parentInfo.hasNativeView),
-                };
-                console.info('[ns-hmr][vue-runtime] stabilizeNativeLayout', snap);
-            }
-            catch { }
-        }
-        // If not yet attached or wrapper view not yet resolved, retry shortly (up to 5 attempts)
-        if ((!nv || !v) && attempt < 5) {
-            // On the third attempt, try a remedial internal.update once to nudge vnode attachment
-            if (attempt === 3) {
-                try {
-                    typeof internal?.update === 'function' && internal.update();
-                }
-                catch { }
-            }
-            // First a microtask, then a frame on subsequent attempts
-            if (attempt === 1) {
-                return void scheduleMicrotask(() => stabilizeNativeLayout(internal, attempt + 1));
-            }
-            return void scheduleNextFrame(() => stabilizeNativeLayout(internal, attempt + 1));
-        }
-        // Light-touch layout refresh
-        let did = false;
-        try {
-            if (v && typeof v.requestLayout === 'function') {
-                v.requestLayout();
-                did = true;
-            }
-        }
-        catch { }
-        if (!did && nv) {
-            // Try common NativeScript native view layout methods
-            try {
-                if (typeof nv.setNeedsLayout === 'function') {
-                    nv.setNeedsLayout();
-                    did = true;
-                }
-            }
-            catch { }
-            try {
-                if (!did && typeof nv.setNeedsDisplay === 'function') {
-                    nv.setNeedsDisplay();
-                    did = true;
-                }
-            }
-            catch { }
-            try {
-                if (!did && typeof nv.requestLayout === 'function') {
-                    nv.requestLayout();
-                    did = true;
-                }
-            }
-            catch { }
-            try {
-                if (!did && typeof nv.invalidate === 'function') {
-                    nv.invalidate();
-                    did = true;
-                }
-            }
-            catch { }
-            // For iOS views
-            try {
-                if (!did && typeof nv.setNeedsLayout === 'function') {
-                    nv.setNeedsLayout();
-                    did = true;
-                }
-            }
-            catch { }
-            try {
-                if (!did && typeof nv.layoutIfNeeded === 'function') {
-                    nv.layoutIfNeeded();
-                    did = true;
-                }
-            }
-            catch { }
-        }
-        // Page-level fallback: request layout on the nearest Page to flush subtree
-        if (!did) {
-            try {
-                const candidateView = v || (parentInfo && parentInfo.view) || null;
-                const page = candidateView && (candidateView.page || candidateView._page);
-                if (page && typeof page.requestLayout === 'function') {
-                    page.requestLayout();
-                    did = true;
-                }
-            }
-            catch { }
-        }
-        // If we didn't find a child view but a parent has a native view, request layout there
-        if (!did && parentInfo && parentInfo.nativeView) {
-            try {
-                const pnv = parentInfo.nativeView;
-                if (typeof pnv.setNeedsLayout === 'function') {
-                    pnv.setNeedsLayout();
-                    did = true;
-                }
-                else if (typeof pnv.requestLayout === 'function') {
-                    pnv.requestLayout();
-                    did = true;
-                }
-            }
-            catch { }
-        }
-        // Minor CSS state poke if layout wasn’t available
-        if (!did) {
-            try {
-                if (v && typeof v._onCssStateChange === 'function') {
-                    v._onCssStateChange();
-                    did = true;
-                }
-            }
-            catch { }
-        }
-        // As a final fallback before giving up: request layout on topmost Frame or root view once
-        if (!did && attempt >= 4 && !__globalLayoutRequested.has(internal)) {
-            try {
-                const req = globalThis.require;
-                const core = req && (() => { try {
-                    return req('@nativescript/core');
-                }
-                catch {
-                    return null;
-                } })();
-                if (core) {
-                    let flushed = false;
-                    try {
-                        const Frame = core.Frame;
-                        const top = Frame && (typeof Frame.topmost === 'function' ? Frame.topmost() : null);
-                        if (top) {
-                            if (typeof top.requestLayout === 'function') {
-                                top.requestLayout();
-                                flushed = true;
-                            }
-                            else if (top.nativeViewProtected && typeof top.nativeViewProtected.setNeedsLayout === 'function') {
-                                top.nativeViewProtected.setNeedsLayout();
-                                flushed = true;
-                            }
-                            else if (top.nativeView && typeof top.nativeView.requestLayout === 'function') {
-                                top.nativeView.requestLayout();
-                                flushed = true;
-                            }
-                        }
-                    }
-                    catch { }
-                    if (!flushed) {
-                        try {
-                            const App = core.Application || core.app || core.application;
-                            const root = App && (typeof App.getRootView === 'function' ? App.getRootView() : null);
-                            if (root) {
-                                if (typeof root.requestLayout === 'function') {
-                                    root.requestLayout();
-                                    flushed = true;
-                                }
-                                else if (root.nativeViewProtected && typeof root.nativeViewProtected.setNeedsLayout === 'function') {
-                                    root.nativeViewProtected.setNeedsLayout();
-                                    flushed = true;
-                                }
-                                else if (root.nativeView && typeof root.nativeView.requestLayout === 'function') {
-                                    root.nativeView.requestLayout();
-                                    flushed = true;
-                                }
-                            }
-                        }
-                        catch { }
-                    }
-                    if (VERBOSE)
-                        console.info('[ns-hmr][vue-runtime] global layout fallback', { flushed });
-                    if (flushed)
-                        did = true;
-                }
-            }
-            catch { }
-            try {
-                __globalLayoutRequested.add(internal);
-            }
-            catch { }
-        }
-        // Only mark stabilized when wrapper view is present or we exhausted retries
-        if (did || attempt >= 5) {
-            if (v || attempt >= 5) {
-                try {
-                    __postUpdateStabilized.add(internal);
-                }
-                catch { }
-            }
-            else {
-                // Schedule one final microtask check before giving up
-                scheduleMicrotask(() => stabilizeNativeLayout(internal, Math.min(attempt + 1, 5)));
-            }
-        }
-    }
-    catch { }
-}
-function scheduleDeferredUpdate(internal, reason) {
-    try {
-        const prev = __pendingUpdateAttempts.get(internal) || 0;
-        const attempt = prev + 1;
-        if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime] deferring update', { attempt, reason });
-        if (attempt > MAX_DEFER_ATTEMPTS) {
-            if (VERBOSE)
-                console.warn('[ns-hmr][vue-runtime] max deferral attempts reached; giving up for this instance');
-            return;
-        }
-        __pendingUpdateAttempts.set(internal, attempt);
-        const delay = Math.min(BASE_DEFER_MS * attempt, 80);
-        // Prefer nextTick when available, then timeout
-        try {
-            const req = globalThis.require;
-            const vueMod = req && (() => { try {
-                return req('vue');
-            }
-            catch {
-                return null;
-            } })();
-            const nsv = req && (() => { try {
-                return req('nativescript-vue');
-            }
-            catch {
-                return null;
-            } })();
-            const nextTick = (vueMod && vueMod.nextTick) || (nsv && nsv.nextTick);
-            if (VERBOSE)
-                console.info('[ns-hmr][vue-runtime] scheduleDeferredUpdate nextTick found:', typeof nextTick === 'function');
-            if (typeof nextTick === 'function') {
-                return void nextTick(() => {
-                    try {
-                        setTimeout(() => { try {
-                            internal?.update && internal.update();
-                        }
-                        catch { } }, delay);
-                    }
-                    catch { }
-                });
-            }
-        }
-        catch { }
-        setTimeout(() => { try {
-            internal?.update && internal.update();
-        }
-        catch { } }, delay);
-    }
-    catch { }
-}
-function dumpRuntime(label, rt) {
-    try {
-        const g = globalThis;
-        const hasRt = !!rt;
-        const keys = rt && typeof rt === 'object' ? Object.keys(rt) : [];
-        const map = rt && (rt.map || rt.records);
-        const recordKeys = map && typeof map.keys === 'function' ? Array.from(map.keys()) : (map && typeof map === 'object' ? Object.keys(map) : []);
-        const flags = {
-            hasRuntime: hasRt,
-            hasRerender: !!(rt && rt.rerender),
-            hasReload: !!(rt && rt.reload),
-            keys,
-            recordCount: recordKeys ? recordKeys.length : 0,
-            hooksApplied: !!g.__NS_VUE_HOOKS_APPLIED__,
-            hasNSVue: !!(g.require && (() => { try {
-                g.require('nativescript-vue');
-                return true;
-            }
-            catch {
-                return false;
-            } })()),
-            hasVue: !!(g.require && (() => { try {
-                g.require('vue');
-                return true;
-            }
-            catch {
-                return false;
-            } })()),
-        };
-        console.info(`[ns-hmr][vue-runtime] ${label}`, flags);
-    }
-    catch { }
-}
-export function initializeVueHMRRuntime() {
-    return ensureVueHMRRuntimeEnhanced();
-}
-export function ensureVueHMRRuntimeEnhanced() {
-    try {
-        const g = global;
-        let rt = g.__VUE_HMR_RUNTIME__;
-        if (!rt) {
-            if (VERBOSE)
-                console.info('[ns-hmr][vue-runtime] Vue HMR runtime not present yet; attempting lazy init');
-            // In ES modules mode, skip require() and use direct global access
-            let Vue = null;
-            // Try to get Vue from global namespace or require (NativeScript ES modules)
-            try {
-                Vue = g.Vue || g.__VUE__;
-                if (Vue) {
-                    if (VERBOSE)
-                        console.info('[ns-hmr][vue-runtime] Vue module loaded via globals:', { hasVue: !!Vue, keys: Vue ? Object.keys(Vue).slice(0, 10) : [] });
-                }
-                else {
-                    if (VERBOSE)
-                        console.info('[ns-hmr][vue-runtime] Vue not found in global namespace, checking require fallback');
-                    // Only try require() if globals failed and we're sure it's available
-                    const req = globalThis.require;
-                    if (req && typeof req === 'function') {
-                        try {
-                            Vue = req('vue');
-                            if (VERBOSE)
-                                console.info('[ns-hmr][vue-runtime] Vue module loaded via require:', { hasVue: !!Vue, keys: Vue ? Object.keys(Vue).slice(0, 10) : [] });
-                        }
-                        catch (e) {
-                            if (VERBOSE)
-                                console.warn('[ns-hmr][vue-runtime] Vue require failed:', e.message);
-                        }
-                    }
-                }
-                // Force Vue HMR runtime initialization if not already done
-                if (Vue && !g.__VUE_HMR_RUNTIME__) {
-                    // Check if Vue has HMR functionality
-                    if (Vue.createApp && !g.__VUE_HMR_RUNTIME__) {
-                        if (VERBOSE)
-                            console.info('[ns-hmr][vue-runtime] Manually initializing Vue HMR runtime');
-                        // Create a minimal HMR runtime that Vue can recognize
-                        g.__VUE_HMR_RUNTIME__ = {
-                            createRecord: () => true,
-                            reload: () => { },
-                            rerender: () => { },
-                            updateStyle: () => { },
-                            isRecorded: () => false,
-                            map: new Map()
-                        };
-                        if (VERBOSE)
-                            console.info('[ns-hmr][vue-runtime] Created minimal Vue HMR runtime');
-                    }
-                }
-            }
-            catch (e) {
-                if (VERBOSE)
-                    console.warn('[ns-hmr][vue-runtime] Vue module loading failed:', e.message || String(e));
-            }
-            // Also try to require nativescript-vue if available
-            try {
-                const req = globalThis.require;
-                if (req && typeof req === 'function') {
-                    try {
-                        req('nativescript-vue');
-                    }
-                    catch { }
-                }
-            }
-            catch { }
-            rt = g.__VUE_HMR_RUNTIME__;
-            if (!rt) {
-                if (VERBOSE) {
-                    console.info('[ns-hmr][vue-runtime] Vue HMR runtime still unavailable after lazy init');
-                    dumpRuntime('after-lazy-init', rt);
-                    console.info('[ns-hmr][vue-runtime] Using minimal fallback Vue HMR runtime (local only)');
-                }
-                try {
-                    rt = installFallbackHMRRuntime();
-                    // In ES modules mode, enhance the fallback with ES modules detection
-                    if (rt && !g.__VUE_HMR_RUNTIME__) {
-                        // Set global reference for ES modules compatibility
-                        g.__VUE_HMR_RUNTIME__ = rt;
-                        if (VERBOSE)
-                            console.info('[ns-hmr][vue-runtime] Set global Vue HMR runtime for ES modules compatibility');
-                        // Try to detect Vue through NativeScript ES modules
-                        try {
-                            const detectVueInESModules = () => {
-                                // In NativeScript ES modules environment, look for Vue in globals
-                                const possibleVue = g.Vue || g.__VUE__ || g.vue;
-                                if (possibleVue && possibleVue.createApp) {
-                                    if (VERBOSE)
-                                        console.info('[ns-hmr][vue-runtime] Found Vue in ES modules global space');
-                                    return possibleVue;
-                                }
-                                return null;
-                            };
-                            const esVue = detectVueInESModules();
-                            if (esVue) {
-                                // Enhance runtime with ES modules Vue reference
-                                rt.__esModulesVue = esVue;
-                                if (VERBOSE)
-                                    console.info('[ns-hmr][vue-runtime] Enhanced runtime with ES modules Vue reference');
-                            }
-                        }
-                        catch (esErr) {
-                            if (VERBOSE)
-                                console.warn('[ns-hmr][vue-runtime] ES modules Vue detection failed:', esErr);
-                        }
-                    }
-                    /* IMPORTANT: do NOT assign to global to avoid blocking real runtime later */
-                }
-                catch (e) {
-                    console.warn('[ns-hmr][vue-runtime] Failed to create fallback runtime:', e?.message || String(e));
-                    return null;
-                }
-            }
-        }
-        if (VERBOSE)
-            dumpRuntime('before-enhance', rt);
-        if (rt.__nsEnhanced)
-            return rt;
-        const enhanced = enhanceVueHMRRuntime(rt);
-        enhanced.__nsEnhanced = true;
-        if (VERBOSE)
-            dumpRuntime('after-enhance', enhanced);
-        // Trigger hook setup now that Vue is available
-        try {
-            const g = globalThis;
-            if (g.__ns_attemptHookSetup) {
-                g.__ns_attemptHookSetup();
-            }
-        }
-        catch { }
-        // Register any existing components that were tracked before HMR runtime was available
-        try {
-            registerExistingComponents(enhanced);
-        }
-        catch (e) {
-            if (VERBOSE)
-                console.warn('[ns-hmr][vue-runtime] Failed to register existing components:', e?.message);
-        }
-        return enhanced;
-    }
-    catch (error) {
-        console.warn('[ns-hmr][vue-runtime] Error ensuring Vue HMR runtime:', error?.message);
-        return null;
-    }
-}
-function enhanceVueHMRRuntime(existingRuntime) {
-    const enhanced = { ...existingRuntime };
-    const originalReload = enhanced.reload;
-    const originalRerender = enhanced.rerender;
-    enhanced.reload = function (id, newDef) {
-        if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime] Enhanced reload for:', id);
-        try {
-            if (originalReload)
-                originalReload.call(this, id, newDef);
-            handleNativeScriptComponentReload(id, newDef);
-        }
-        catch (error) {
-            console.warn('[ns-hmr][vue-runtime] Enhanced reload failed:', error?.message);
-            if (originalReload)
-                originalReload.call(this, id, newDef);
-        }
-    };
-    enhanced.rerender = function (id, newRender) {
-        if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime] Enhanced rerender for:', id);
-        try {
-            try {
-                globalThis.__NS_LAST_RERENDER_ID__ = id;
-            }
-            catch { }
-            // Set current component ID for working instance tracking
-            currentComponentId = id;
-            if (originalRerender)
-                originalRerender.call(this, id, newRender);
-            try {
-                handleNativeScriptComponentRerender(id, newRender, enhanced);
-            }
-            catch { }
-        }
-        catch (error) {
-            console.warn('[ns-hmr][vue-runtime] Enhanced rerender failed:', error?.message);
-            if (originalRerender)
-                originalRerender.call(this, id, newRender);
-        }
-        finally {
-            // Clear the current component ID after processing
-            currentComponentId = null;
-        }
-    };
-    return enhanced;
-}
-function normalizeIdToFile(id) {
-    try {
-        let s = String(id || '');
-        s = s.split('?')[0];
-        s = s.replace(/\\/g, '/');
-        return s;
-    }
-    catch {
-        return id;
-    }
-}
-function installFallbackHMRRuntime() {
-    const records = new Map();
-    const api = {
-        __nsFallback: true,
-        map: records,
-        createRecord(id, initialDef) { const key = String(id); if (records.has(key))
-            return true; records.set(key, { def: initialDef || {}, instances: new Set() }); if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime:fallback] createRecord', key); return true; },
-        isRecorded(id) { return records.has(String(id)); },
-        registerInstance(id, instance) { const key = String(id); if (!records.has(key))
-            this.createRecord(key, (instance && (instance.$?.type || instance.type)) || {}); const rec = records.get(key); rec.instances.add(instance); if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime:fallback] registerInstance', key); },
-        rerender(id, newRender) {
-            const key = String(id);
-            const rec = records.get(key);
-            if (rec && rec.def) {
-                try {
-                    rec.def.render = newRender;
-                }
-                catch { }
-            }
-            const targets = [];
-            if (rec)
-                targets.push(...Array.from(rec.instances));
-            try {
-                const file = normalizeIdToFile(key);
-                const more = componentTracker.findInstancesByFile(file);
-                for (const ins of more)
-                    targets.push(ins);
-            }
-            catch { }
-            let applied = 0;
-            for (const ins of targets) {
-                try {
-                    applyRenderAndTriggerWithId(ins, newRender, key);
-                    applied++;
-                }
-                catch { }
-            }
-            if (applied === 0) {
-                try {
-                    applied += tryPatchInstancesFromRootByFileSuffix(key, newRender);
-                }
-                catch { }
-                try {
-                    applied += tryPatchInstancesFromRootByName(key, newRender, api);
-                }
-                catch { }
-            }
-            if (VERBOSE)
-                console.info('[ns-hmr][vue-runtime:fallback] rerender applied for', key, 'instances:', applied);
-        },
-        reload(id, newDef) { const key = String(id); const rec = records.get(key); if (rec) {
-            try {
-                Object.assign(rec.def || (rec.def = {}), newDef);
-            }
-            catch { }
-        } this.rerender(key, (newDef && newDef.render) ? newDef.render : (() => { })); if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime:fallback] reload applied for', key); },
-        updateStyle() { },
-    };
-    return api;
-}
-function handleNativeScriptComponentReload(id, newDef) {
-    try {
-        if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime] NativeScript component reload for:', id);
-    }
-    catch (error) {
-        if (VERBOSE)
-            console.warn('[ns-hmr][vue-runtime] NativeScript component reload failed:', error?.message);
-    }
-}
-function handleNativeScriptComponentRerender(id, newRender, runtime) {
-    try {
-        if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime] NativeScript component rerender for:', id);
-        const map = runtime.map || runtime.records;
-        let record = null;
-        if (map) {
-            if (typeof map.get === 'function')
-                record = map.get(id) || null;
-            else if (map[id])
-                record = map[id];
-        }
-        // Let Vue runtime update instances; we just stabilize the root and any known instances after a tick
-        try {
-            scheduleMicrotask(() => { try {
-                const g = globalThis;
-                const root = g.__NS_VUE_ROOT_INSTANCE__;
-                if (root)
-                    stabilizeNativeLayout(root.$ || root, 1);
-            }
-            catch { } });
-        }
-        catch { }
-    }
-    catch (error) {
-        if (VERBOSE)
-            console.warn('[ns-hmr][vue-runtime] NativeScript component rerender failed:', error?.message);
-    }
-}
-function baseFileSuffixesFromId(id) {
-    try {
-        const noQuery = String(id || '').split('?')[0].replace(/\\/g, '/');
-        const base = noQuery.split('/').pop() || '';
-        const relFromSrc = noQuery.replace(/^.*?\/src\//, '/src/');
-        const relNoLead = relFromSrc.replace(/^\//, '');
-        const suffixes = new Set();
-        if (base)
-            suffixes.add('/' + base);
-        if (relFromSrc)
-            suffixes.add(relFromSrc);
-        if (relNoLead)
-            suffixes.add('/' + relNoLead);
-        if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime] baseFileSuffixesFromId', { id, suffixes: Array.from(suffixes) });
-        return Array.from(suffixes);
-    }
-    catch {
-        return [];
-    }
-}
-function getComponentType(obj) { try {
-    return (obj && (obj.$?.type || obj.type)) || null;
-}
-catch {
-    return null;
-} }
-function getComponentName(obj) { try {
-    const t = getComponentType(obj);
-    const n = (t && (t.__name || t.name)) || '';
-    return String(n || '').trim();
-}
-catch {
-    return '';
-} }
-function forceUpdateInstance(ins, componentId) {
-    try {
-        const internal = ins.$ || ins;
-        // If the underlying NativeScript view isn't ready (loading/suspended), defer the update
-        try {
-            const probe = findNSViewFromInternal(internal);
-            const el = probe.el;
-            const resolved = probe.info;
-            // If this instance has a working native view, set it as current working instance
-            if (resolved?.hasNativeView && el) {
-                setCurrentWorkingInstance(internal, componentId);
-                if (VERBOSE) {
-                    console.info('[ns-hmr][vue-runtime] forceUpdateInstance found working instance');
-                }
-            }
-            // Cache last resolved element right away for stabilization to use soon after
-            try {
-                __lastResolvedEl.set(internal, { el, info: resolved });
-            }
-            catch { }
-            const suspendCount = resolved.suspendCount;
-            const isLoaded = resolved.isLoaded;
-            const isMounted = typeof internal?.isMounted === 'boolean' ? internal.isMounted : undefined;
-            const isSuspended = typeof suspendCount === 'number' && suspendCount !== 0;
-            // Require loaded when available to avoid re-entrant creation on Frame/Page
-            const elReady = isNSViewReady(el) && (typeof isLoaded === 'boolean' ? isLoaded === true : true);
-            // Decode NativeScript suspend flags for richer logs
-            let flagsInfo = undefined;
-            try {
-                if (typeof suspendCount === 'number') {
-                    const LOADED = 1 << 20;
-                    const NATIVEVIEW = 1 << 21;
-                    const UISETUP = 1 << 22;
-                    const FLAGS_MASK = LOADED | NATIVEVIEW | UISETUP;
-                    const inc = suspendCount & ~FLAGS_MASK;
-                    flagsInfo = {
-                        suspendCount,
-                        inc,
-                        LOADED: (suspendCount & LOADED) !== 0,
-                        NATIVEVIEW: (suspendCount & NATIVEVIEW) !== 0,
-                        UISETUP: (suspendCount & UISETUP) !== 0,
-                    };
-                }
-            }
-            catch { }
-            const notReady = (isMounted === false) || !elReady || isSuspended;
-            if (VERBOSE) {
-                try {
-                    const elType = el && el.constructor ? el.constructor.name : (el ? typeof el : 'null');
-                    console.info('[ns-hmr][vue-runtime] update-check', { isMounted, isLoaded, elReady, isSuspended, elType, hasNativeView: resolved.hasNativeView, isRootView: resolved.isRootView, flags: flagsInfo });
-                }
-                catch { }
-            }
-            if (notReady) {
-                if (VERBOSE)
-                    console.info('[ns-hmr][vue-runtime] deferring update: NS view not ready', { isMounted, isLoaded, suspendCount, elReady, hasNativeView: resolved.hasNativeView });
-                scheduleDeferredUpdate(internal, 'not-ready');
-                return;
-            }
-            // Clear any previous deferral attempts now that we're ready
-            try {
-                __pendingUpdateAttempts.delete(internal);
-            }
-            catch { }
-        }
-        catch { }
-        // If the component tree includes Frame/Page, avoid immediate updates: schedule on next frame(s)
-        if (instanceHasFrameOrPage(internal)) {
-            if (VERBOSE)
-                console.info('[ns-hmr][vue-runtime] frame/page detected; scheduling via scheduler and next frames');
-            try {
-                const eff = internal.effect;
-                if (eff && typeof eff.scheduler === 'function') {
-                    scheduleNextFrame(() => { try {
-                        eff.scheduler();
-                    }
-                    catch { } scheduleNextFrame(() => stabilizeNativeLayout(internal)); });
-                    return;
-                }
-            }
-            catch { }
-            scheduleNextFrame(() => { try {
-                internal?.update && internal.update();
-            }
-            catch { } scheduleNextFrame(() => stabilizeNativeLayout(internal)); });
-            return;
-        }
-        // Prefer scheduler then nextTick before attempting direct update
-        try {
-            const eff = internal.effect;
-            if (eff && typeof eff.scheduler === 'function') {
-                if (VERBOSE) {
-                    console.info('[ns-hmr][vue-runtime] About to call effect.scheduler()', {
-                        hasEffect: !!eff,
-                        effectKeys: eff ? Object.keys(eff).slice(0, 10) : [],
-                        schedulerType: typeof eff.scheduler
-                    });
-                }
-                try {
-                    eff.scheduler();
-                    if (VERBOSE)
-                        console.info('[ns-hmr][vue-runtime] effect.scheduler() executed successfully');
-                    // Also try to force a re-render by marking the effect as dirty
-                    if (typeof eff.trigger === 'function') {
-                        eff.trigger();
-                        if (VERBOSE)
-                            console.info('[ns-hmr][vue-runtime] effect.trigger() called');
-                    }
-                    // Force update the instance as well
-                    if (typeof internal.update === 'function') {
-                        scheduleMicrotask(() => {
-                            try {
-                                internal.update();
-                                if (VERBOSE)
-                                    console.info('[ns-hmr][vue-runtime] internal.update() called after scheduler');
-                            }
-                            catch (e) {
-                                if (VERBOSE)
-                                    console.warn('[ns-hmr][vue-runtime] internal.update() failed:', e?.message);
-                            }
-                        });
-                    }
-                    // Force a complete re-render cycle - try internal render method
-                    if (typeof internal.render === 'function') {
-                        scheduleMicrotask(() => {
-                            try {
-                                if (VERBOSE)
-                                    console.info('[ns-hmr][vue-runtime] Triggering internal.render() for complete re-render');
-                                // Validate render context before calling render
-                                const hasValidContext = internal.ctx || internal.setupState || internal.data;
-                                if (!hasValidContext) {
-                                    if (VERBOSE)
-                                        console.warn('[ns-hmr][vue-runtime] No valid render context found, skipping internal.render()');
-                                    return;
-                                }
-                                // Set up proper render context
-                                const originalCtx = internal.ctx;
-                                const originalScope = internal.scope;
-                                try {
-                                    const newVNode = internal.render.call(internal, internal.ctx || internal.setupState || internal.data, internal.renderCache || {}, internal.props || {}, internal.setupState || {}, internal.data || {}, internal.$options || {});
-                                    if (VERBOSE)
-                                        console.info('[ns-hmr][vue-runtime] internal.render() result:', {
-                                            hasVNode: !!newVNode,
-                                            vNodeType: newVNode?.type?.name || newVNode?.type || 'unknown'
-                                        });
-                                    // Apply new VNode by replacing subTree and scheduling an update
-                                    if (newVNode) {
-                                        if (VERBOSE)
-                                            console.info('[ns-hmr][vue-runtime] New vNode created, applying via subTree replacement');
-                                        try {
-                                            internal.subTree = newVNode;
-                                        }
-                                        catch { }
-                                        if (internal.update && typeof internal.update === 'function') {
-                                            scheduleMicrotask(() => {
-                                                try {
-                                                    internal.update();
-                                                    if (VERBOSE)
-                                                        console.info('[ns-hmr][vue-runtime] Triggered component update after subTree replacement');
-                                                }
-                                                catch (e) {
-                                                    if (VERBOSE)
-                                                        console.warn('[ns-hmr][vue-runtime] Component update after subTree replacement failed:', e?.message);
-                                                }
-                                            });
-                                        }
-                                    }
-                                }
-                                finally {
-                                    // Restore original context
-                                    if (originalCtx)
-                                        internal.ctx = originalCtx;
-                                    if (originalScope)
-                                        internal.scope = originalScope;
-                                }
-                            }
-                            catch (e) {
-                                if (VERBOSE)
-                                    console.warn('[ns-hmr][vue-runtime] internal.render() failed:', e?.message, e?.stack);
-                            }
-                        });
-                    }
-                    // Enhanced NativeScript-specific component update approach
-                    scheduleMicrotask(() => {
-                        try {
-                            if (VERBOSE)
-                                console.info('[ns-hmr][vue-runtime] Starting NativeScript-specific component update');
-                            const nsEl = findNSViewFromInternal(internal);
-                            if (nsEl && nsEl.info && nsEl.info.view) {
-                                const view = nsEl.info.view;
-                                const nativeView = nsEl.info.nativeView;
-                                if (VERBOSE)
-                                    console.info('[ns-hmr][vue-runtime] Found NativeScript view for update:', {
-                                        hasView: !!view,
-                                        hasNativeView: !!nativeView,
-                                        viewType: view?.constructor?.name || typeof view
-                                    });
-                                // Step 1: Force Vue component to re-evaluate its render function using Vue 3 compatible methods
-                                if (internal.effect) {
-                                    try {
-                                        // Use Vue 3's proper effect triggering methods instead of setting readonly 'dirty' property
-                                        if (typeof internal.effect.trigger === 'function') {
-                                            internal.effect.trigger();
-                                            if (VERBOSE)
-                                                console.info('[ns-hmr][vue-runtime] Triggered Vue effect via trigger()');
-                                        }
-                                        else if (typeof internal.effect.run === 'function') {
-                                            // Force effect to run again
-                                            internal.effect.run();
-                                            if (VERBOSE)
-                                                console.info('[ns-hmr][vue-runtime] Triggered Vue effect via run()');
-                                        }
-                                        else {
-                                            // Fallback: try to schedule the effect
-                                            if (typeof internal.effect.scheduler === 'function') {
-                                                internal.effect.scheduler();
-                                                if (VERBOSE)
-                                                    console.info('[ns-hmr][vue-runtime] Triggered Vue effect via scheduler()');
-                                            }
-                                            else {
-                                                if (VERBOSE)
-                                                    console.warn('[ns-hmr][vue-runtime] No compatible Vue effect trigger method found');
-                                            }
-                                        }
-                                    }
-                                    catch (e) {
-                                        if (VERBOSE)
-                                            console.warn('[ns-hmr][vue-runtime] Vue effect triggering failed:', e?.message);
-                                    }
-                                }
-                                // Step 2: Clear any cached render results
-                                if (internal.renderCache) {
-                                    const cacheKeys = Object.keys(internal.renderCache);
-                                    internal.renderCache = {};
-                                    if (VERBOSE)
-                                        console.info('[ns-hmr][vue-runtime] Cleared render cache:', cacheKeys.length, 'entries');
-                                }
-                                // Step 3: Force NativeScript view updates
-                                if (nativeView) {
-                                    // Platform-specific layout forcing
-                                    const isIOS = globalThis.__ios || (nativeView.setNeedsLayout && !nativeView.requestLayout);
-                                    const isAndroid = globalThis.__android || (nativeView.requestLayout && !nativeView.setNeedsLayout);
-                                    if (isIOS) {
-                                        // iOS-specific layout forcing
-                                        if (nativeView.setNeedsLayout) {
-                                            nativeView.setNeedsLayout();
-                                            if (VERBOSE)
-                                                console.info('[ns-hmr][vue-runtime] Called iOS setNeedsLayout()');
-                                        }
-                                        if (nativeView.layoutIfNeeded) {
-                                            nativeView.layoutIfNeeded();
-                                            if (VERBOSE)
-                                                console.info('[ns-hmr][vue-runtime] Called iOS layoutIfNeeded()');
-                                        }
-                                    }
-                                    else if (isAndroid) {
-                                        // Android-specific layout forcing
-                                        if (nativeView.requestLayout) {
-                                            nativeView.requestLayout();
-                                            if (VERBOSE)
-                                                console.info('[ns-hmr][vue-runtime] Called Android requestLayout()');
-                                        }
-                                        if (nativeView.invalidate) {
-                                            nativeView.invalidate();
-                                            if (VERBOSE)
-                                                console.info('[ns-hmr][vue-runtime] Called Android invalidate()');
-                                        }
-                                    }
-                                    else {
-                                        // Fallback: try both but log appropriately
-                                        if (nativeView.setNeedsLayout) {
-                                            nativeView.setNeedsLayout();
-                                            if (VERBOSE)
-                                                console.info('[ns-hmr][vue-runtime] Called iOS setNeedsLayout() (fallback)');
-                                        }
-                                        if (nativeView.requestLayout) {
-                                            nativeView.requestLayout();
-                                            if (VERBOSE)
-                                                console.info('[ns-hmr][vue-runtime] Called Android requestLayout() (fallback)');
-                                        }
-                                    }
-                                }
-                                // Step 4: Force NativeScript view hierarchy update
-                                if (view) {
-                                    // Try NativeScript's own update mechanisms
-                                    if (view.requestLayout && typeof view.requestLayout === 'function') {
-                                        view.requestLayout();
-                                        if (VERBOSE)
-                                            console.info('[ns-hmr][vue-runtime] Called NativeScript view requestLayout()');
-                                    }
-                                    if (view._onCssStateChange && typeof view._onCssStateChange === 'function') {
-                                        view._onCssStateChange();
-                                        if (VERBOSE)
-                                            console.info('[ns-hmr][vue-runtime] Called view CSS state change');
-                                    }
-                                    if (view._redrawNativeBackground && typeof view._redrawNativeBackground === 'function') {
-                                        view._redrawNativeBackground();
-                                        if (VERBOSE)
-                                            console.info('[ns-hmr][vue-runtime] Called view background redraw');
-                                    }
-                                }
-                                // Step 5: Trigger Vue's update cycle in NativeScript-safe way
-                                if (internal.update && typeof internal.update === 'function') {
-                                    // Use setTimeout to break out of current execution context
-                                    setTimeout(() => {
-                                        try {
-                                            internal.update();
-                                            if (VERBOSE)
-                                                console.info('[ns-hmr][vue-runtime] Called Vue internal.update() via setTimeout');
-                                        }
-                                        catch (e) {
-                                            if (VERBOSE)
-                                                console.warn('[ns-hmr][vue-runtime] Vue internal.update() failed:', e?.message);
-                                        }
-                                    }, 0);
-                                }
-                            }
-                            else {
-                                if (VERBOSE)
-                                    console.warn('[ns-hmr][vue-runtime] No NativeScript view found for update');
-                            }
-                        }
-                        catch (e) {
-                            if (VERBOSE)
-                                console.warn('[ns-hmr][vue-runtime] NativeScript component update failed:', e?.message);
-                        }
-                    });
-                    // Experimental: Try to force a complete component rebuild
-                    scheduleMicrotask(() => {
-                        try {
-                            if (VERBOSE)
-                                console.info('[ns-hmr][vue-runtime] Attempting experimental complete component refresh');
-                            // Clear more Vue caches that might be blocking updates
-                            if (internal.renderCache) {
-                                const oldLen = Object.keys(internal.renderCache).length;
-                                internal.renderCache = {};
-                                if (VERBOSE)
-                                    console.info('[ns-hmr][vue-runtime] Cleared renderCache entries:', oldLen);
-                            }
-                            // Try to force Vue to think the component has changed
-                            if (internal.dirtyLevel !== undefined) {
-                                internal.dirtyLevel = 3; // Force dirty
-                                if (VERBOSE)
-                                    console.info('[ns-hmr][vue-runtime] Set dirtyLevel to 3');
-                            }
-                            // Try to force the component's patch
-                            if (internal.parent && internal.parent.update) {
-                                internal.parent.update();
-                                if (VERBOSE)
-                                    console.info('[ns-hmr][vue-runtime] Called parent.update()');
-                            }
-                            // Try to force app-level update
-                            const app = internal.appContext?.app;
-                            if (app && app._instance && app._instance.update) {
-                                app._instance.update();
-                                if (VERBOSE)
-                                    console.info('[ns-hmr][vue-runtime] Called app._instance.update()');
-                            }
-                            // Force re-evaluation of computed properties
-                            if (internal.scope && internal.scope.effects) {
-                                for (const effect of internal.scope.effects) {
-                                    if (effect && effect.scheduler) {
-                                        effect.scheduler();
-                                        if (VERBOSE)
-                                            console.info('[ns-hmr][vue-runtime] Triggered scope effect scheduler');
-                                    }
-                                }
-                            }
-                        }
-                        catch (e) {
-                            if (VERBOSE)
-                                console.warn('[ns-hmr][vue-runtime] Experimental refresh failed:', e?.message);
-                        }
-                    });
-                }
-                catch (e) {
-                    if (VERBOSE)
-                        console.warn('[ns-hmr][vue-runtime] effect.scheduler() failed:', e?.message);
-                }
-                scheduleMicrotask(() => stabilizeNativeLayout(internal));
-                return;
-            }
-            else {
-                if (VERBOSE) {
-                    console.info('[ns-hmr][vue-runtime] No effect.scheduler available', {
-                        hasEffect: !!eff,
-                        hasScheduler: eff && typeof eff.scheduler === 'function',
-                        effectType: eff?.constructor?.name,
-                        effectKeys: eff ? Object.keys(eff).slice(0, 10) : []
-                    });
-                }
-            }
-        }
-        catch (e) {
-            if (VERBOSE)
-                console.warn('[ns-hmr][vue-runtime] Effect scheduler attempt failed:', e?.message);
-        }
-        // Prefer scheduling on nextTick before attempting immediate update to avoid NS creation timing
-        try {
-            const req = globalThis.require;
-            const vueMod = req && (() => { try {
-                return req('vue');
-            }
-            catch {
-                return null;
-            } })();
-            const nsv = req && (() => { try {
-                return req('nativescript-vue');
-            }
-            catch {
-                return null;
-            } })();
-            const nextTick = (vueMod && vueMod.nextTick) || (nsv && nsv.nextTick);
-            if (VERBOSE)
-                console.info('[ns-hmr][vue-runtime] forceUpdate nextTick found:', typeof nextTick === 'function');
-            if (typeof nextTick === 'function') {
-                if (VERBOSE)
-                    console.info('[ns-hmr][vue-runtime] scheduling nextTick update (preferred path)');
-                nextTick(() => {
-                    try {
-                        internal?.update && internal.update();
-                        if (VERBOSE)
-                            console.info('[ns-hmr][vue-runtime] nextTick(preferred) internal.update');
-                        // After update, schedule stabilization on the next microtask to allow vnode.el to attach
-                        try {
-                            scheduleMicrotask(() => stabilizeNativeLayout(internal));
-                            // And one-time next-frame follow-up update to flush any late vnode attachments
-                            if (!__postUpdateFollowed.has(internal)) {
-                                __postUpdateFollowed.add(internal);
-                                scheduleNextFrame(() => {
-                                    try {
-                                        typeof internal?.update === 'function' && internal.update();
-                                    }
-                                    catch { }
-                                    scheduleMicrotask(() => stabilizeNativeLayout(internal));
-                                });
-                            }
-                        }
-                        catch { }
-                    }
-                    catch (e) {
-                        if (VERBOSE)
-                            console.warn('[ns-hmr][vue-runtime] nextTick(preferred) update failed:', e?.message);
-                        if (e && String(e.message || e).includes('entry.create')) {
-                            scheduleDeferredUpdate(internal, 'entry.create');
-                        }
-                        else {
-                            // For non-entry.create errors, try gentle approach
-                            scheduleGentleRerender(internal);
-                        }
-                    }
-                });
-                return;
-            }
-        }
-        catch { }
-        if (typeof internal?.update === 'function') {
-            try {
-                internal.update();
-                try {
-                    __pendingUpdateAttempts.delete(internal);
-                }
-                catch { }
-                if (VERBOSE)
-                    console.info('[ns-hmr][vue-runtime] internal.update');
-                try {
-                    scheduleMicrotask(() => stabilizeNativeLayout(internal));
-                    // And one-time next-frame follow-up update to flush any late vnode attachments
-                    if (!__postUpdateFollowed.has(internal)) {
-                        __postUpdateFollowed.add(internal);
-                        scheduleNextFrame(() => {
-                            try {
-                                typeof internal?.update === 'function' && internal.update();
-                            }
-                            catch { }
-                            scheduleMicrotask(() => stabilizeNativeLayout(internal));
-                        });
-                    }
-                }
-                catch { }
-                return;
-            }
-            catch (e) {
-                if (VERBOSE)
-                    console.warn('[ns-hmr][vue-runtime] internal.update failed:', e?.message);
-                // If NativeScript is still creating views, defer and retry
-                if (e && String(e.message || e).includes('entry.create')) {
-                    scheduleDeferredUpdate(internal, 'entry.create');
-                    return;
-                }
-                else {
-                    // For other errors, try gentle approach
-                    scheduleGentleRerender(internal);
-                    return;
-                }
-            }
-        }
-        try {
-            const eff = internal.effect;
-            if (eff && typeof eff.run === 'function') {
-                eff.run();
-                if (VERBOSE)
-                    console.info('[ns-hmr][vue-runtime] effect.run()');
-                return;
-            }
-            if (eff && typeof eff.scheduler === 'function') {
-                eff.scheduler();
-                if (VERBOSE)
-                    console.info('[ns-hmr][vue-runtime] effect.scheduler()');
-                return;
-            }
-        }
-        catch { }
-        try {
-            const vue = globalThis.require && globalThis.require('nativescript-vue');
-            const nextTick = (vue && vue.nextTick) || (globalThis.require && globalThis.require('vue')?.nextTick);
-            if (typeof nextTick === 'function') {
-                nextTick(() => { try {
-                    internal?.update && internal.update();
-                    if (VERBOSE)
-                        console.info('[ns-hmr][vue-runtime] nextTick internal.update');
-                }
-                catch (e) {
-                    if (VERBOSE)
-                        console.warn('[ns-hmr][vue-runtime] nextTick update failed:', e?.message);
-                } });
-                return;
-            }
-        }
-        catch { }
-        function attemptReloadForInstance(internal) {
-            try {
-                const g = globalThis;
-                const rt = g.__VUE_HMR_RUNTIME__;
-                if (!rt || typeof rt.reload !== 'function')
-                    return;
-                const type = internal?.type || internal?.proxy?.type || internal?.vnode?.type;
-                const file = (type && (type.__file || type.file)) ? String(type.__file || type.file).replace(/\\/g, '/') : '';
-                const recentId = g.__NS_LAST_RERENDER_ID__ ? String(g.__NS_LAST_RERENDER_ID__) : '';
-                const candidates = new Set();
-                if (recentId)
-                    candidates.add(recentId);
-                if (file) {
-                    const suffixes = baseFileSuffixesFromId(file);
-                    // Scan runtime records and match by suffix
-                    const map = rt.map || rt.records || {};
-                    const keys = map && typeof map.keys === 'function'
-                        ? Array.from(map.keys())
-                        : (map && typeof map === 'object' ? Object.keys(map) : []);
-                    for (const k of keys) {
-                        for (const s of suffixes) {
-                            if (String(k).endsWith(s))
-                                candidates.add(String(k));
-                        }
-                    }
-                }
-                const ids = Array.from(candidates);
-                if (VERBOSE)
-                    console.info('[ns-hmr][vue-runtime] Attempting component-local reload', { file, ids });
-                for (const id of ids) {
-                    try {
-                        rt.reload(id, { /* best-effort */});
-                        if (VERBOSE)
-                            console.info('[ns-hmr][vue-runtime] Reload triggered for', id);
-                        break;
-                    }
-                    catch (e) {
-                        if (VERBOSE)
-                            console.warn('[ns-hmr][vue-runtime] Reload failed for', id, e?.message);
-                    }
-                }
-            }
-            catch { }
-        }
-        if (VERBOSE) {
-            try {
-                const keys = internal ? Object.keys(internal).slice(0, 30) : [];
-                console.warn('[ns-hmr][vue-runtime] No safe update path found for instance', { hasInternal: !!internal, internalKeys: keys });
-            }
-            catch { }
-        }
-    }
-    catch { }
-}
-export function applyRenderAndTrigger(ins, newRender) {
-    return applyRenderAndTriggerWithId(ins, newRender);
-}
-export function applyRenderAndTriggerWithId(ins, newRender, componentId) {
-    try {
-        const internal = ins.$ || ins;
-        const type = internal?.type || (ins && ins.type) || null;
-        if (VERBOSE) {
-            try {
-                const prevTypeRender = type && type.render;
-                const prevVNodeTypeRender = internal?.vnode?.type && internal.vnode.type.render;
-                // Also surface some readiness info for the target instance
-                const vnode = internal?.vnode;
-                const el = vnode && vnode.el;
-                const resolved = resolveNSView(el);
-                const suspendCount = resolved.suspendCount;
-                const hasNativeView = resolved.hasNativeView;
-                const flags = (() => {
-                    try {
-                        if (typeof suspendCount !== 'number')
-                            return undefined;
-                        const LOADED = 1 << 20;
-                        const NATIVEVIEW = 1 << 21;
-                        const UISETUP = 1 << 22;
-                        const FLAGS_MASK = LOADED | NATIVEVIEW | UISETUP;
-                        const inc = suspendCount & ~FLAGS_MASK;
-                        return {
-                            suspendCount,
-                            inc,
-                            LOADED: (suspendCount & LOADED) !== 0,
-                            NATIVEVIEW: (suspendCount & NATIVEVIEW) !== 0,
-                            UISETUP: (suspendCount & UISETUP) !== 0,
-                        };
-                    }
-                    catch {
-                        return undefined;
-                    }
-                })();
-                console.info('[ns-hmr][vue-runtime] patching renders (minimal)', {
-                    name: (type && (type.__name || type.name)) || undefined,
-                    hadTypeRender: typeof prevTypeRender === 'function',
-                    hadVNodeTypeRender: typeof prevVNodeTypeRender === 'function',
-                    hasNativeView,
-                    flags
-                });
-            }
-            catch { }
-        }
-        // IMPORTANT: patch the component type.render, vnode.type.render, and internal.render so next updates use new render
-        try {
-            if (type)
-                type.render = newRender;
-        }
-        catch { }
-        try {
-            if (internal?.vnode?.type)
-                internal.vnode.type.render = newRender;
-        }
-        catch { }
-        try {
-            if (internal)
-                internal.render = newRender;
-        }
-        catch { }
-        // Clear render cache so compiled template changes take effect immediately
-        try {
-            if (internal && Array.isArray(internal.renderCache)) {
-                const len = internal.renderCache.length;
-                internal.renderCache.length = 0;
-                if (VERBOSE)
-                    console.info('[ns-hmr][vue-runtime] cleared instance.renderCache', { prevLen: len });
-            }
-            else if (internal && internal.renderCache) {
-                internal.renderCache = [];
-                if (VERBOSE)
-                    console.info('[ns-hmr][vue-runtime] reset instance.renderCache to empty array');
-            }
-        }
-        catch { }
-        if (VERBOSE) {
-            try {
-                const file = (type && type.__file) ? String(type.__file) : undefined;
-                const name = (type && (type.__name || type.name)) ? String(type.__name || type.name) : undefined;
-                console.info('[ns-hmr][vue-runtime] applyRenderAndTrigger', { file, name, hasType: !!type, hasVNodeType: !!(internal?.vnode?.type) });
-            }
-            catch { }
-        }
-    }
-    catch { }
-    // Check if the instance is ready for update before forcing
-    try {
-        const ready = isNSViewReady(ins, componentId);
-        if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime] applyRenderAndTrigger readiness:', { ready });
-        if (!ready) {
-            if (VERBOSE)
-                console.info('[ns-hmr][vue-runtime] Instance not ready for update, trying progressive approach');
-            // Instead of giving up, try a more progressive approach
-            // First try the gentle approach, but with a fallback to direct update
-            try {
-                scheduleGentleRerender(ins, componentId);
-                // Also schedule a backup direct update after a delay in case gentle approach fails
-                setTimeout(() => {
-                    try {
-                        if (VERBOSE)
-                            console.info('[ns-hmr][vue-runtime] Backup direct update attempt');
-                        forceUpdateInstance(ins, componentId);
-                    }
-                    catch (e) {
-                        if (VERBOSE)
-                            console.warn('[ns-hmr][vue-runtime] Backup update failed:', e?.message);
-                    }
-                }, 100);
-            }
-            catch (e) {
-                if (VERBOSE)
-                    console.warn('[ns-hmr][vue-runtime] Progressive approach failed, falling back to direct update:', e?.message);
-                forceUpdateInstance(ins, componentId);
-            }
-            return;
-        }
-    }
-    catch (e) {
-        if (VERBOSE)
-            console.warn('[ns-hmr][vue-runtime] Readiness check failed, proceeding with direct update:', e?.message);
-    }
-    forceUpdateInstance(ins);
-}
-function tryPatchInstancesFromRootByFileSuffix(id, newRender) {
-    const g = globalThis;
-    const root = g.__NS_VUE_ROOT_INSTANCE__;
-    if (!root)
-        return 0;
-    const suffixes = baseFileSuffixesFromId(id);
-    let patched = 0;
-    const maybePatch = (ins) => {
-        try {
-            const type = getComponentType(ins);
-            const file = type && type.__file ? String(type.__file).replace(/\\/g, '/') : '';
-            if (file) {
-                for (const suf of suffixes) {
-                    if (file.endsWith(suf)) {
-                        applyRenderAndTrigger(ins, newRender);
-                        patched++;
-                        if (VERBOSE)
-                            console.info('[ns-hmr][vue-runtime] patched instance via file suffix match', { file, suf, setType: !!type, setVNode: !!(ins?.vnode?.type), setInternal: true });
-                        break;
-                    }
-                }
-            }
-        }
-        catch { }
-    };
-    const enqueueChildren = (node, q) => {
-        try {
-            if (!node)
-                return;
-            const internal = (node.$ ? node.$ : node);
-            if (internal?.subTree)
-                q.push(internal.subTree);
-            if (node && typeof node === 'object') {
-                try {
-                    const comp = node.component;
-                    if (comp)
-                        q.push(comp);
-                }
-                catch { }
-                const ch = node.children || node.child || null;
-                if (Array.isArray(ch)) {
-                    for (const c of ch) {
-                        if (c && typeof c === 'object')
-                            q.push(c);
-                    }
-                }
-                else if (ch && typeof ch === 'object') {
-                    q.push(ch);
-                }
-            }
-        }
-        catch { }
-    };
-    const queue = [root];
-    while (queue.length) {
-        const cur = queue.shift();
-        try {
-            maybePatch(cur);
-        }
-        catch { }
-        try {
-            enqueueChildren(cur, queue);
-        }
-        catch { }
-    }
-    return patched;
-}
-function baseNameFromId(id) { try {
-    const noQ = String(id || '').split('?')[0].replace(/\\/g, '/');
-    const base = (noQ.split('/').pop() || '').replace(/\.vue$/i, '');
-    return base;
-}
-catch {
-    return '';
-} }
-function tryPatchInstancesFromRootByName(id, newRender, runtime) {
-    const g = globalThis;
-    const root = g.__NS_VUE_ROOT_INSTANCE__;
-    if (!root)
-        return 0;
-    const target = baseNameFromId(id);
-    if (!target)
-        return 0;
-    const targetLower = target.toLowerCase();
-    let patched = 0;
-    const maybePatch = (ins) => {
-        try {
-            const type = getComponentType(ins);
-            const name = (type && (type.__name || type.name)) ? String(type.__name || type.name) : '';
-            if (name && name.toLowerCase() === targetLower) {
-                applyRenderAndTrigger(ins, newRender);
-                patched++;
-                if (VERBOSE) {
-                    try {
-                        const vnode = (ins && ins.vnode) || ((ins && ins.$) ? ins.$.vnode : undefined);
-                        const el = vnode && vnode.el;
-                        const suspendCount = el && typeof el === 'object' ? el._suspendNativeUpdatesCount : undefined;
-                        const isLoaded = el && typeof el === 'object' ? el._isLoaded : undefined;
-                        const isMounted = typeof ins?.isMounted === 'boolean' ? ins.isMounted : undefined;
-                        console.info('[ns-hmr][vue-runtime] patched instance via name match', { name, target: targetLower, setType: !!type, setVNode: !!(ins?.vnode?.type), setInternal: true, isMounted, isLoaded, suspendCount });
-                    }
-                    catch { }
-                }
-                try {
-                    if (runtime && typeof runtime.registerInstance === 'function')
-                        runtime.registerInstance(id, ins);
-                }
-                catch { }
-            }
-        }
-        catch { }
-    };
-    const enqueueChildren = (node, q) => {
-        try {
-            if (!node)
-                return;
-            const internal = (node.$ ? node.$ : node);
-            if (internal && internal.subTree)
-                q.push(internal.subTree);
-            if (node && typeof node === 'object') {
-                try {
-                    const comp = node.component;
-                    if (comp)
-                        q.push(comp);
-                }
-                catch { }
-                const ch = node.children || node.child || null;
-                if (Array.isArray(ch)) {
-                    for (const c of ch) {
-                        if (c && typeof c === 'object')
-                            q.push(c);
-                    }
-                }
-                else if (ch && typeof ch === 'object') {
-                    q.push(ch);
-                }
-            }
-        }
-        catch { }
-    };
-    const queue = [root];
-    while (queue.length) {
-        const cur = queue.shift();
-        try {
-            maybePatch(cur);
-        }
-        catch { }
-        try {
-            enqueueChildren(cur, queue);
-        }
-        catch { }
-    }
-    return patched;
-}
-// New function to handle gentle re-rendering without forcing component recreation
-function scheduleGentleRerender(internal, componentId) {
-    try {
-        if (VERBOSE)
-            console.info('[ns-hmr][vue-runtime] scheduleGentleRerender');
-        // First approach: invalidate the render effect using Vue 3 compatible methods
-        try {
-            const renderEffect = internal.renderEffect || internal.effect;
-            if (renderEffect) {
-                // Use Vue 3's proper effect triggering instead of setting readonly 'dirty' property
-                if (typeof renderEffect.trigger === 'function') {
-                    renderEffect.trigger();
-                    if (VERBOSE)
-                        console.info('[ns-hmr][vue-runtime] gentle update: triggered render effect via trigger()');
-                }
-                else if (typeof renderEffect.run === 'function') {
-                    renderEffect.run();
-                    if (VERBOSE)
-                        console.info('[ns-hmr][vue-runtime] gentle update: triggered render effect via run()');
-                }
-                else if (typeof renderEffect.scheduler === 'function') {
-                    renderEffect.scheduler();
-                    if (VERBOSE)
-                        console.info('[ns-hmr][vue-runtime] gentle update: triggered render effect via scheduler()');
-                }
-                else {
-                    if (VERBOSE)
-                        console.warn('[ns-hmr][vue-runtime] gentle update: no compatible render effect trigger method found');
-                }
-                // Trigger scheduler if available for gentle scheduling
-                if (typeof renderEffect.scheduler === 'function') {
-                    const req = globalThis.require;
-                    const vueMod = req && (() => { try {
-                        return req('vue');
-                    }
-                    catch {
-                        return null;
-                    } })();
-                    const nextTick = vueMod && vueMod.nextTick;
-                    if (typeof nextTick === 'function') {
-                        nextTick(() => {
-                            try {
-                                renderEffect.scheduler();
-                                if (VERBOSE)
-                                    console.info('[ns-hmr][vue-runtime] gentle rerender via scheduler');
-                                // Also request layout to ensure visual update
-                                try {
-                                    const { el, info } = findNSViewFromInternal(internal);
-                                    if (info.view && typeof info.view.requestLayout === 'function') {
-                                        info.view.requestLayout();
-                                    }
-                                    else if (info.nativeView && typeof info.nativeView.setNeedsLayout === 'function') {
-                                        info.nativeView.setNeedsLayout();
-                                    }
-                                }
-                                catch { }
-                            }
-                            catch (e) {
-                                if (VERBOSE)
-                                    console.warn('[ns-hmr][vue-runtime] gentle scheduler failed:', e?.message);
-                            }
-                        });
-                    }
-                    else {
-                        renderEffect.scheduler();
-                        // Request layout after scheduler
-                        setTimeout(() => {
-                            try {
-                                const { el, info } = findNSViewFromInternal(internal);
-                                if (info.view && typeof info.view.requestLayout === 'function') {
-                                    info.view.requestLayout();
-                                }
-                                else if (info.nativeView && typeof info.nativeView.setNeedsLayout === 'function') {
-                                    info.nativeView.setNeedsLayout();
-                                }
-                            }
-                            catch { }
-                        }, 0);
-                    }
-                    return;
-                }
-            }
-        }
-        catch (e) {
-            if (VERBOSE)
-                console.warn('[ns-hmr][vue-runtime] gentle effect invalidation failed:', e?.message);
-        }
-        // Fallback: schedule a deferred update with longer delay to give view time to stabilize
-        const attempt = (__pendingUpdateAttempts.get(internal) || 0) + 1;
-        __pendingUpdateAttempts.set(internal, attempt);
-        const delay = Math.min(BASE_DEFER_MS * attempt * 2, 200); // Longer delays for gentle approach
-        setTimeout(() => {
-            try {
-                const { el } = findNSViewFromInternal(internal);
-                if (isNSViewReady(internal)) {
-                    if (VERBOSE)
-                        console.info('[ns-hmr][vue-runtime] gentle deferred update - view ready, applying');
-                    try {
-                        // Try multiple update approaches for better coverage
-                        let updateApplied = false;
-                        // Method 1: Use effect scheduler if available
-                        const eff = internal.effect;
-                        if (eff && typeof eff.scheduler === 'function') {
-                            eff.scheduler();
-                            updateApplied = true;
-                            if (VERBOSE)
-                                console.info('[ns-hmr][vue-runtime] gentle update: effect.scheduler() called');
-                        }
-                        // Method 2: Direct internal update
-                        if (internal?.update && typeof internal.update === 'function') {
-                            internal.update();
-                            updateApplied = true;
-                            if (VERBOSE)
-                                console.info('[ns-hmr][vue-runtime] gentle update: internal.update() called');
-                        }
-                        // Method 3: Force component re-render
-                        const vnode = internal?.vnode;
-                        if (vnode && !updateApplied) {
-                            // Try to trigger Vue's re-render mechanisms
-                            if (typeof internal.renderCache?.clear === 'function') {
-                                internal.renderCache.clear();
-                            }
-                            if (Array.isArray(internal.renderCache)) {
-                                internal.renderCache.length = 0;
-                            }
-                            if (VERBOSE)
-                                console.info('[ns-hmr][vue-runtime] gentle update: cleared render cache');
-                        }
-                        if (VERBOSE)
-                            console.info('[ns-hmr][vue-runtime] gentle update completed, applied:', updateApplied);
-                        // If gentle update failed, try proper Vue component lifecycle approach
-                        if (!updateApplied) {
-                            try {
-                                if (VERBOSE)
-                                    console.info('[ns-hmr][vue-runtime] Gentle update failed, attempting Vue component lifecycle approach');
-                                // Get the Vue HMR runtime for proper component updates
-                                const vueRuntime = ensureVueHMRRuntimeEnhanced();
-                                const componentId = getComponentIdFromInternal(internal);
-                                if (vueRuntime && componentId) {
-                                    // Use Vue's official HMR rerender instead of manual effect manipulation
-                                    if (typeof vueRuntime.rerender === 'function') {
-                                        if (VERBOSE)
-                                            console.info('[ns-hmr][vue-runtime] Using Vue HMR runtime rerender for component:', componentId);
-                                        // Get the new render function from the component type
-                                        const componentType = internal.type || internal.vnode?.type;
-                                        if (componentType && componentType.render) {
-                                            vueRuntime.rerender(componentId, componentType.render);
-                                            if (VERBOSE)
-                                                console.info('[ns-hmr][vue-runtime] Vue HMR rerender called successfully');
-                                        }
-                                        else {
-                                            if (VERBOSE)
-                                                console.warn('[ns-hmr][vue-runtime] No render function found for Vue HMR rerender');
-                                        }
-                                    }
-                                    // Also try Vue's reload as backup
-                                    if (typeof vueRuntime.reload === 'function') {
-                                        const componentDef = internal.type || internal.vnode?.type;
-                                        if (componentDef) {
-                                            vueRuntime.reload(componentId, componentDef);
-                                            if (VERBOSE)
-                                                console.info('[ns-hmr][vue-runtime] Vue HMR reload called as backup');
-                                        }
-                                    }
-                                }
-                                else {
-                                    if (VERBOSE)
-                                        console.warn('[ns-hmr][vue-runtime] No Vue HMR runtime or component ID available for lifecycle approach');
-                                }
-                                // Force component instance update through proper Vue channels
-                                if (internal.parent && internal.parent.update) {
-                                    internal.parent.update();
-                                    if (VERBOSE)
-                                        console.info('[ns-hmr][vue-runtime] Triggered parent component update');
-                                }
-                                // Force root app update if available
-                                const g = globalThis;
-                                const root = g.__NS_VUE_ROOT_INSTANCE__;
-                                if (root && root.$ && typeof root.$.update === 'function') {
-                                    root.$.update();
-                                    if (VERBOSE)
-                                        console.info('[ns-hmr][vue-runtime] Triggered root instance update');
-                                }
-                            }
-                            catch (e) {
-                                if (VERBOSE)
-                                    console.warn('[ns-hmr][vue-runtime] Vue component lifecycle approach failed:', e?.message);
-                            }
-                        }
-                        // Force native layout updates to ensure visual changes appear
-                        try {
-                            const probe = findNSViewFromInternal(internal);
-                            if (probe.info?.view) {
-                                const view = probe.info.view;
-                                if (typeof view.requestLayout === 'function') {
-                                    view.requestLayout();
-                                    if (VERBOSE)
-                                        console.info('[ns-hmr][vue-runtime] gentle update: requested layout');
-                                }
-                                if (probe.info.nativeView && typeof probe.info.nativeView.setNeedsLayout === 'function') {
-                                    probe.info.nativeView.setNeedsLayout();
-                                    if (VERBOSE)
-                                        console.info('[ns-hmr][vue-runtime] gentle update: set needs layout');
-                                }
-                            }
-                        }
-                        catch (e) {
-                            if (VERBOSE)
-                                console.warn('[ns-hmr][vue-runtime] Layout update failed:', e?.message);
-                        }
-                    }
-                    catch (e) {
-                        if (VERBOSE)
-                            console.warn('[ns-hmr][vue-runtime] gentle update failed:', e?.message);
-                    }
-                    __pendingUpdateAttempts.delete(internal);
-                }
-                else {
-                    if (attempt < MAX_DEFER_ATTEMPTS) {
-                        if (VERBOSE)
-                            console.info('[ns-hmr][vue-runtime] gentle deferred update - view not ready, retrying');
-                        scheduleGentleRerender(internal, componentId);
-                    }
-                    else {
-                        if (VERBOSE)
-                            console.warn('[ns-hmr][vue-runtime] giving up on gentle rerender after max attempts');
-                        // Last resort: force update anyway
-                        try {
-                            if (VERBOSE)
-                                console.info('[ns-hmr][vue-runtime] last resort: forcing update despite view state');
-                            internal?.update && internal.update();
-                            __pendingUpdateAttempts.delete(internal);
-                        }
-                        catch (e) {
-                            if (VERBOSE)
-                                console.warn('[ns-hmr][vue-runtime] last resort update failed:', e?.message);
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                if (VERBOSE)
-                    console.warn('[ns-hmr][vue-runtime] gentle deferred update failed:', e?.message);
-                if (attempt < MAX_DEFER_ATTEMPTS) {
-                    scheduleGentleRerender(internal, componentId);
-                }
-            }
-        }, delay);
-    }
-    catch (e) {
-        if (VERBOSE)
-            console.warn('[ns-hmr][vue-runtime] scheduleGentleRerender failed:', e?.message);
-    }
-}
-// Note: Avoid auto-initializing Vue HMR runtime here to prevent fallback
-// runtime creation and noisy logs at app boot. The webpack5-style handler
-// manages HMR runtime setup explicitly.