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

package/hmr/server/websocket.js

@@ -1,5 +1,5 @@
 import { createRequire } from 'node:module';
-import { normalizeStrayCoreStringLiterals, fixDanglingCoreFrom, normalizeAnyCoreSpecToBridge } from './core-sanitize.js';
+import { normalizeStrayCoreStringLiterals, fixDanglingCoreFrom, normalizeAnyCoreSpecToBridge, isDeepCoreSubpath, rewriteSpecifiersForDevice } from './core-sanitize.js';
 // AST tooling for robust transformations
 import { parse as babelParse } from '@babel/parser';
 import { genCode } from '../helpers/babel.js';
@@ -30,6 +30,23 @@ import { typescriptServerStrategy } from '../frameworks/typescript/server/strate
 import { buildInlineTemplateBlock, createProcessSfcCode, extractTemplateRender, processTemplateVariantMinimal } from '../frameworks/vue/server/sfc-transforms.js';
 import { astExtractImportsAndStripTypes } from '../helpers/ast-extract.js';
 import { getProjectAppPath, getProjectAppRelativePath, getProjectAppVirtualPath } from '../../helpers/utils.js';
+import { buildRuntimeConfig, generateImportMap } from './import-map.js';
+import { getCliFlags } from '../../helpers/cli-flags.js';
+// Build a serialized process.env object from CLI --env.* flags.
+// This is injected into every HTTP-served module so app code referencing
+// process.env.TEST_ENV (etc.) works on device in HMR dev mode.
+const __processEnvEntries = { NODE_ENV: 'development' };
+try {
+    const flags = getCliFlags();
+    for (const [k, v] of Object.entries(flags)) {
+        // Skip internal NativeScript build flags
+        if (['ios', 'android', 'visionos', 'platform', 'hmr', 'verbose'].includes(k))
+            continue;
+        __processEnvEntries[k] = String(v);
+    }
+}
+catch { }
+const __processEnvJson = JSON.stringify(__processEnvEntries);
 const { parse, compileTemplate, compileScript } = vueSfcCompiler;
 const APP_ROOT_DIR = getProjectAppPath();
 const APP_VIRTUAL_PREFIX = getProjectAppVirtualPath();
@@ -84,6 +101,33 @@ function isNativeScriptCoreModule(spec) {
 function isNativeScriptPluginModule(spec) {
     return /^@nativescript\//i.test(spec || '') && !isNativeScriptCoreModule(spec || '');
 }
+function isLikelyNativeScriptRuntimePluginSpecifier(spec) {
+    if (!spec)
+        return false;
+    const s = spec.replace(PAT.QUERY_PATTERN, '');
+    if (/^(?:\.|\/|https?:\/\/)/i.test(s))
+        return false;
+    if (s.startsWith('@@/'))
+        return false;
+    if (s.startsWith('~/'))
+        return false;
+    if (s.startsWith('@/'))
+        return false;
+    if (/\.vue(?:\?|$)/i.test(s))
+        return false;
+    const root = extractRootPackageName(s) || s;
+    if (!root)
+        return false;
+    if (isNativeScriptCoreModule(root))
+        return false;
+    if (/^(?:vue|nativescript-vue)(?:\b|\/)/i.test(root))
+        return false;
+    if (/^@nativescript\//i.test(root))
+        return true;
+    if (/^(?:@nativescript-community|@nstudio|@mleleux)\//i.test(root))
+        return true;
+    return /(?:^|\/)nativescript(?:$|[-_])/i.test(root);
+}
 // Looser detector for NativeScript plugin-style specifiers that should be resolved
 // via device require() rather than HTTP during HMR. This includes popular community
 // scopes in addition to @nativescript/* (excluding core).
@@ -112,7 +156,518 @@ function isLikelyNativeScriptPluginSpecifier(spec) {
     // Treat any other bare package id as device-resolved (require) during HMR
     return true;
 }
-export function ensureNativeScriptModuleBindings(code) {
+export function tryReadRawExplicitJavaScriptModule(spec, projectRoot) {
+    if (!spec || !spec.startsWith('/'))
+        return null;
+    if (spec.startsWith('/@id/') || spec.startsWith('/@fs/'))
+        return null;
+    if (!/\.js$/i.test(spec) || /\.(?:mjs|cjs)$/i.test(spec))
+        return null;
+    // NativeScript runtime plugins rely on Vite's transform pipeline to apply
+    // platform-aware entry resolution and preserve root-entry routing semantics.
+    // Reading their on-disk JS directly recreates raw relative imports such as
+    // `./gesturehandler`, which can reintroduce HTTP ESM cycles during HMR.
+    try {
+        const nodeModulesSpecifier = normalizeNodeModulesSpecifier(spec);
+        if (nodeModulesSpecifier) {
+            const pkgName = extractRootPackageName(nodeModulesSpecifier);
+            if (isLikelyNativeScriptRuntimePluginSpecifier(pkgName)) {
+                return null;
+            }
+        }
+    }
+    catch { }
+    const root = path.resolve(projectRoot);
+    const absPath = path.resolve(root, `.${spec}`);
+    const rel = path.relative(root, absPath);
+    if (!rel || rel.startsWith('..') || path.isAbsolute(rel))
+        return null;
+    if (!existsSync(absPath))
+        return null;
+    try {
+        const code = readFileSync(absPath, 'utf-8');
+        if (/from\s*['"](?:node:)?module['"]/.test(code) || /\bcreateRequire\b/.test(code)) {
+            return null;
+        }
+        return {
+            code,
+            resolvedId: spec,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function canonicalizeTransformRequestCacheKey(url, projectRoot) {
+    if (!url)
+        return url;
+    const [rawPath, rawQuery = ''] = url.split('?', 2);
+    let normalizedPath = rawPath;
+    const root = projectRoot ? projectRoot.replace(/\\/g, '/') : '';
+    if (normalizedPath.startsWith('/@fs/')) {
+        const fsPath = normalizedPath.slice('/@fs'.length).replace(/\\/g, '/');
+        if (root && fsPath.startsWith(root)) {
+            const rel = fsPath.slice(root.length);
+            normalizedPath = rel.startsWith('/') ? rel : `/${rel}`;
+        }
+    }
+    else if (root && normalizedPath.replace(/\\/g, '/').startsWith(root)) {
+        const rel = normalizedPath.replace(/\\/g, '/').slice(root.length);
+        normalizedPath = rel.startsWith('/') ? rel : `/${rel}`;
+    }
+    if (!rawQuery) {
+        return normalizedPath;
+    }
+    const params = new URLSearchParams(rawQuery);
+    params.delete('t');
+    params.delete('v');
+    const kept = Array.from(params.entries()).sort(([leftKey, leftValue], [rightKey, rightValue]) => {
+        if (leftKey === rightKey) {
+            return leftValue.localeCompare(rightValue);
+        }
+        return leftKey.localeCompare(rightKey);
+    });
+    if (!kept.length) {
+        return normalizedPath;
+    }
+    const normalizedQuery = new URLSearchParams();
+    for (const [key, value] of kept) {
+        normalizedQuery.append(key, value);
+    }
+    return `${normalizedPath}?${normalizedQuery.toString()}`;
+}
+const MODULE_IMPORT_ANALYSIS_PLUGINS = ['typescript', 'jsx', 'importMeta', 'topLevelAwait', 'classProperties', 'classPrivateProperties', 'classPrivateMethods', 'decorators-legacy'];
+function collectTopLevelImportRecords(code) {
+    if (!code || typeof code !== 'string' || !/\bimport\b/.test(code)) {
+        return [];
+    }
+    try {
+        const ast = babelParse(code, {
+            sourceType: 'module',
+            plugins: MODULE_IMPORT_ANALYSIS_PLUGINS,
+        });
+        const body = ast?.program?.body;
+        if (!Array.isArray(body)) {
+            return [];
+        }
+        return body
+            .filter((node) => t.isImportDeclaration(node) && typeof node.start === 'number' && typeof node.end === 'number' && typeof node.source?.value === 'string')
+            .map((node) => ({
+            start: node.start,
+            end: node.end,
+            text: code.slice(node.start, node.end),
+            source: node.source.value,
+            hasOnlyNamedSpecifiers: Array.isArray(node.specifiers) && node.specifiers.length > 0 && node.specifiers.every((spec) => t.isImportSpecifier(spec)),
+            namedBindings: Array.isArray(node.specifiers)
+                ? node.specifiers
+                    .filter((spec) => t.isImportSpecifier(spec) && typeof spec.start === 'number' && typeof spec.end === 'number')
+                    .map((spec) => ({
+                    importedName: t.isIdentifier(spec.imported) ? spec.imported.name : String(spec.imported?.value || ''),
+                    text: code.slice(spec.start, spec.end),
+                }))
+                : [],
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function hoistTopLevelStaticImports(code) {
+    const imports = collectTopLevelImportRecords(code);
+    if (!imports.length) {
+        return code;
+    }
+    let stripped = code;
+    for (const imp of [...imports].sort((left, right) => right.start - left.start)) {
+        stripped = stripped.slice(0, imp.start) + stripped.slice(imp.end);
+    }
+    const hoisted = [];
+    const seen = new Set();
+    for (const imp of imports) {
+        const text = imp.text.trim();
+        if (!text || seen.has(text)) {
+            continue;
+        }
+        seen.add(text);
+        hoisted.push(text);
+    }
+    if (!hoisted.length) {
+        return stripped;
+    }
+    return `${hoisted.join('\n')}\n${stripped.replace(/^\s*\n+/, '')}`;
+}
+export function buildBootProgressSnippet(bootModuleLabel) {
+    const normalizedLabel = JSON.stringify(String(bootModuleLabel || '').replace(/\\/g, '/'));
+    return [
+        `const __nsBootGlobal=globalThis;`,
+        `try{if(!__nsBootGlobal.__NS_HMR_BOOT_COMPLETE__){const __nsBootApi=__nsBootGlobal.__NS_HMR_DEV_OVERLAY__;if(__nsBootApi&&typeof __nsBootApi.setBootStage==='function'){const __nsBootCount=(__nsBootGlobal.__NS_HMR_BOOT_MODULE_COUNT__=Number(__nsBootGlobal.__NS_HMR_BOOT_MODULE_COUNT__||0)+1);__nsBootGlobal.__NS_HMR_BOOT_LAST_MODULE__=${normalizedLabel};const __nsBootNow=Date.now();const __nsBootLast=Number(__nsBootGlobal.__NS_HMR_BOOT_LAST_PROGRESS_AT__||0);if(__nsBootCount<=8||__nsBootCount%6===0||__nsBootNow-__nsBootLast>90){__nsBootGlobal.__NS_HMR_BOOT_LAST_PROGRESS_AT__=__nsBootNow;const __nsBootProgress=Math.min(94,82+Math.min(10,Math.round((Math.log(__nsBootCount+1)/Math.LN2)*2)));__nsBootApi.setBootStage('importing-main',{detail:'Evaluated '+__nsBootCount+' modules\\n'+__nsBootGlobal.__NS_HMR_BOOT_LAST_MODULE__,attempt:Number(__nsBootGlobal.__NS_HMR_BOOT_MAIN_ATTEMPT__||1),attempts:Number(__nsBootGlobal.__NS_HMR_BOOT_MAIN_ATTEMPTS__||6),progress:__nsBootProgress});}}}}catch(__nsBootErr){}`,
+        `if(!__nsBootGlobal.__NS_HMR_BOOT_COMPLETE__){const __nsBootCount=Number(__nsBootGlobal.__NS_HMR_BOOT_MODULE_COUNT__||0);if(__nsBootCount<=24||__nsBootCount%8===0){await new Promise((resolve)=>setTimeout(resolve,0));}}`,
+        '',
+    ].join('\n');
+}
+function rewriteVitePrebundleImportsForDevice(code, preserveVendorImports) {
+    const imports = collectTopLevelImportRecords(code);
+    if (!imports.length) {
+        return code;
+    }
+    const edits = [];
+    for (const imp of imports) {
+        const source = imp.source;
+        const depMatch = source.match(/(?:^|\/)node_modules\/\.vite\/deps\/(.+)$/);
+        const depPath = depMatch?.[1] || (source.startsWith('.vite/deps/') ? source.slice('.vite/deps/'.length) : null);
+        if (!depPath) {
+            continue;
+        }
+        let replacement = '';
+        if (preserveVendorImports) {
+            const canonical = resolveVendorFromCandidate(`.vite/deps/${depPath}`);
+            const bareSpecifier = canonical || viteDepsPathToBareSpecifier(depPath);
+            if (bareSpecifier) {
+                replacement = imp.text.replace(source, bareSpecifier);
+            }
+        }
+        edits.push({
+            start: imp.start,
+            end: imp.end,
+            text: replacement,
+        });
+    }
+    if (!edits.length) {
+        return code;
+    }
+    let next = code;
+    for (const edit of edits.sort((left, right) => right.start - left.start)) {
+        next = next.slice(0, edit.start) + edit.text + next.slice(edit.end);
+    }
+    return next;
+}
+function buildNodeModuleProvenancePrelude(sourceId) {
+    if (!sourceId) {
+        return '';
+    }
+    const cleaned = sourceId.replace(PAT.QUERY_PATTERN, '');
+    let normalized = normalizeNodeModulesSpecifier(cleaned);
+    if (!normalized) {
+        const viteDepsMatch = cleaned.match(/(?:^|\/)node_modules\/\.vite\/deps\/([^?#]+)/);
+        if (viteDepsMatch?.[1]) {
+            normalized = `.vite/deps/${viteDepsMatch[1]}`;
+        }
+    }
+    if (!normalized) {
+        return '';
+    }
+    let packageSpecifier = normalized;
+    let via = 'node_modules';
+    if (normalized.startsWith('.vite/deps/')) {
+        via = 'vite-deps';
+        packageSpecifier = viteDepsPathToBareSpecifier(normalized.slice('.vite/deps/'.length)) || normalized;
+    }
+    const rootPackage = extractRootPackageName(packageSpecifier);
+    if (!rootPackage) {
+        return '';
+    }
+    return `try { const __nsRecord = globalThis.__NS_RECORD_MODULE_PROVENANCE__; if (typeof __nsRecord === 'function') { __nsRecord(${JSON.stringify(rootPackage)}, ${JSON.stringify({ kind: 'http-esm', specifier: packageSpecifier, url: sourceId, via })}); } } catch {}\n`;
+}
+export function collectGraphUpdateModulesForHotUpdate(options) {
+    const targets = new Map();
+    const addTarget = (mod) => {
+        const id = mod?.id?.replace(/\?.*$/, '');
+        if (!id)
+            return;
+        if (!targets.has(id)) {
+            targets.set(id, mod);
+        }
+    };
+    if (options.flavor === 'angular' && /\.(html|htm)$/i.test(options.file)) {
+        for (const mod of options.modules || []) {
+            for (const importer of mod?.importers || []) {
+                const importerId = importer?.id || '';
+                if (/\.[cm]?[jt]sx?(?:$|\?)/i.test(importerId)) {
+                    addTarget(importer);
+                }
+            }
+        }
+        if (!targets.size) {
+            addTarget(options.getModuleById(options.file.replace(/\.(html|htm)$/i, '.ts')));
+            addTarget(options.getModuleById(options.file.replace(/\.(html|htm)$/i, '.js')));
+        }
+        return Array.from(targets.values());
+    }
+    if (!options.file.endsWith('.vue')) {
+        addTarget(options.getModuleById(options.file) || options.getModuleById(options.file + '?vue'));
+    }
+    return Array.from(targets.values());
+}
+export function collectAngularHotUpdateRoots(options) {
+    const roots = [];
+    const seenIds = new Set();
+    const seenObjects = new Set();
+    const addRoot = (mod) => {
+        if (!mod) {
+            return;
+        }
+        if (mod.id) {
+            if (seenIds.has(mod.id)) {
+                return;
+            }
+            seenIds.add(mod.id);
+            roots.push(mod);
+            return;
+        }
+        if (seenObjects.has(mod)) {
+            return;
+        }
+        seenObjects.add(mod);
+        roots.push(mod);
+    };
+    if (/\.(html|htm)$/i.test(options.file)) {
+        for (const mod of collectGraphUpdateModulesForHotUpdate({
+            file: options.file,
+            flavor: 'angular',
+            modules: options.modules,
+            getModuleById: options.getModuleById,
+        })) {
+            addRoot(mod);
+        }
+        return roots;
+    }
+    if (!/\.(m|c)?ts$/i.test(options.file)) {
+        return roots;
+    }
+    for (const mod of options.modules || []) {
+        addRoot(mod);
+    }
+    for (const mod of options.getModulesByFile?.(options.file) || []) {
+        addRoot(mod);
+    }
+    if (!roots.length) {
+        addRoot(options.getModuleById(options.file));
+    }
+    return roots;
+}
+export function collectAngularTransitiveImportersForInvalidation(options) {
+    const visited = new Set();
+    const collected = new Map();
+    const isExcluded = options.isExcluded ?? ((id) => id.includes('/node_modules/'));
+    const maxDepth = Math.max(1, Math.floor(options.maxDepth ?? 16));
+    const normalizeId = (value) => (value ?? '').replace(/\?.*$/, '');
+    const walk = (mod, depth) => {
+        if (!mod || visited.has(mod)) {
+            return;
+        }
+        visited.add(mod);
+        if (depth >= maxDepth) {
+            return;
+        }
+        const importers = mod.importers;
+        if (!importers) {
+            return;
+        }
+        for (const importer of importers) {
+            if (!importer)
+                continue;
+            const importerId = normalizeId(importer.id);
+            if (!importerId) {
+                walk(importer, depth + 1);
+                continue;
+            }
+            if (isExcluded(importerId)) {
+                continue;
+            }
+            if (!collected.has(importerId)) {
+                collected.set(importerId, importer);
+            }
+            walk(importer, depth + 1);
+        }
+    };
+    for (const mod of options.modules || []) {
+        walk(mod, 0);
+    }
+    return Array.from(collected.values());
+}
+export function shouldInvalidateAngularTransitiveImporters(options) {
+    if (options.flavor !== 'angular') {
+        return false;
+    }
+    return /\.(?:html|htm|(m|c)?[jt]sx?)$/i.test(options.file);
+}
+export function shouldSuppressDefaultViteHotUpdate(options) {
+    if (options.flavor !== 'angular') {
+        return false;
+    }
+    return /\.(html|htm|ts)$/i.test(options.file);
+}
+export function normalizeHotReloadMatchPath(raw, root) {
+    let normalized = String(raw || '')
+        .split('?')[0]
+        .replace(/\\/g, '/')
+        .replace(/^file:\/\//, '');
+    if (root) {
+        const rootNormalized = root.replace(/\\/g, '/');
+        if (normalized.startsWith(rootNormalized)) {
+            normalized = normalized.slice(rootNormalized.length);
+        }
+    }
+    if (!normalized.startsWith('/')) {
+        normalized = `/${normalized}`;
+    }
+    return normalized;
+}
+export function shouldSuppressViteFullReloadPayload(options) {
+    const { payload, pendingEntries, root } = options;
+    const now = options.now ?? Date.now();
+    if (!payload || payload.type !== 'full-reload') {
+        return false;
+    }
+    const payloadPath = typeof payload.path === 'string' && payload.path !== '*' ? normalizeHotReloadMatchPath(payload.path, root) : null;
+    const payloadTriggeredBy = typeof payload.triggeredBy === 'string' ? normalizeHotReloadMatchPath(payload.triggeredBy, root) : null;
+    for (const entry of pendingEntries) {
+        if (!entry || entry.expiresAt <= now) {
+            continue;
+        }
+        if (payloadTriggeredBy === entry.absPath || payloadTriggeredBy === entry.relPath || payloadPath === entry.relPath || payloadPath === entry.absPath) {
+            return true;
+        }
+    }
+    return false;
+}
+export function createSharedTransformRequestRunner(transformRequest, onTimeout, options = {}) {
+    const inFlight = new Map();
+    const recentResults = new Map();
+    const cacheGenerations = new Map();
+    const queue = [];
+    const maxConcurrent = Math.max(1, Math.floor(options.maxConcurrent ?? 1));
+    const resultCacheTtlMs = Math.max(0, Math.floor(options.resultCacheTtlMs ?? 0));
+    const getResultCacheKey = options.getResultCacheKey ?? ((url) => url);
+    let activeCount = 0;
+    const getCacheGeneration = (cacheKey) => cacheGenerations.get(cacheKey) ?? 0;
+    const invalidateCacheKey = (cacheKey) => {
+        cacheGenerations.set(cacheKey, getCacheGeneration(cacheKey) + 1);
+        recentResults.delete(cacheKey);
+    };
+    const pruneRecentResults = () => {
+        if (!recentResults.size) {
+            return;
+        }
+        const now = Date.now();
+        for (const [key, entry] of recentResults) {
+            if (entry.expiresAt <= now) {
+                recentResults.delete(key);
+            }
+        }
+    };
+    const rememberRecentResult = (url, result, generation) => {
+        if (!result || resultCacheTtlMs <= 0) {
+            return;
+        }
+        const cacheKey = getResultCacheKey(url);
+        if (getCacheGeneration(cacheKey) !== generation) {
+            return;
+        }
+        recentResults.delete(cacheKey);
+        recentResults.set(cacheKey, {
+            expiresAt: Date.now() + resultCacheTtlMs,
+            result,
+        });
+        if (recentResults.size > 512) {
+            const oldestKey = recentResults.keys().next().value;
+            if (oldestKey) {
+                recentResults.delete(oldestKey);
+            }
+        }
+    };
+    const runNext = () => {
+        while (activeCount < maxConcurrent) {
+            const next = queue.shift();
+            if (!next) {
+                return;
+            }
+            activeCount += 1;
+            next();
+        }
+    };
+    const schedule = (task) => {
+        let resolveStarted = null;
+        const started = new Promise((resolve) => {
+            resolveStarted = resolve;
+        });
+        const execution = new Promise((resolve, reject) => {
+            queue.push(() => {
+                let started;
+                resolveStarted?.();
+                try {
+                    started = Promise.resolve(task());
+                }
+                catch (error) {
+                    started = Promise.reject(error);
+                }
+                started.then(resolve, reject).finally(() => {
+                    activeCount = Math.max(0, activeCount - 1);
+                    runNext();
+                });
+            });
+            runNext();
+        });
+        return { execution, started };
+    };
+    const withTimeout = (entry, url, timeoutMs) => {
+        if (!(timeoutMs > 0)) {
+            return entry.execution;
+        }
+        return entry.started.then(() => new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                try {
+                    onTimeout?.(url, timeoutMs);
+                }
+                catch { }
+            }, timeoutMs);
+            entry.execution.then(resolve, reject).finally(() => {
+                clearTimeout(timer);
+            });
+        }));
+    };
+    const runner = ((url, timeoutMs = 120000) => {
+        pruneRecentResults();
+        const cacheKey = getResultCacheKey(url);
+        const generation = getCacheGeneration(cacheKey);
+        const recent = recentResults.get(cacheKey);
+        if (recent && recent.expiresAt > Date.now()) {
+            return Promise.resolve(recent.result);
+        }
+        const existingExecution = inFlight.get(url);
+        if (existingExecution && existingExecution.generation === generation && existingExecution.cacheKey === cacheKey) {
+            return withTimeout(existingExecution, url, timeoutMs);
+        }
+        const scheduled = schedule(async () => {
+            const result = await Promise.resolve(transformRequest(url));
+            rememberRecentResult(url, result, generation);
+            return result;
+        });
+        let execution;
+        execution = scheduled.execution.finally(() => {
+            if (inFlight.get(url)?.execution === execution) {
+                inFlight.delete(url);
+            }
+        });
+        const entry = { execution, started: scheduled.started, cacheKey, generation };
+        inFlight.set(url, entry);
+        return withTimeout(entry, url, timeoutMs);
+    });
+    runner.invalidate = (url) => {
+        invalidateCacheKey(getResultCacheKey(url));
+    };
+    runner.invalidateMany = (urls) => {
+        for (const url of urls || []) {
+            runner.invalidate(url);
+        }
+    };
+    runner.clear = () => {
+        recentResults.clear();
+        cacheGenerations.clear();
+    };
+    return runner;
+}
+export function ensureNativeScriptModuleBindings(code, options) {
     // Proceed even if a vendor manifest isn't available; we'll still vendor-bind
     // likely NativeScript plugin-style specifiers (e.g., 'pinia', '@scope/pkg')
     // via require() so device can resolve them from the app bundle.
@@ -165,6 +720,11 @@ export function ensureNativeScriptModuleBindings(code) {
         }
         const specifier = rawSpec.replace(PAT.QUERY_PATTERN, '');
         let canonical = resolveVendorFromCandidate(specifier);
+        const runtimePluginSpecifier = isLikelyNativeScriptRuntimePluginSpecifier(canonical || specifier);
+        if (options?.preserveNonPluginVendorImports && !runtimePluginSpecifier) {
+            preservedImports.push(original);
+            return pfx || '';
+        }
         // If not found in vendor manifest, treat well-known NativeScript plugin-style packages
         // as require() based modules so the device can resolve them from the app bundle or vendor.
         if (!canonical && isLikelyNativeScriptPluginSpecifier(specifier)) {
@@ -216,6 +776,11 @@ export function ensureNativeScriptModuleBindings(code) {
         const original = full.replace(/^\n/, '');
         const specifier = rawSpec.replace(PAT.QUERY_PATTERN, '');
         let canonical = resolveVendorFromCandidate(specifier);
+        const runtimePluginSpecifier = isLikelyNativeScriptRuntimePluginSpecifier(canonical || specifier);
+        if (options?.preserveNonPluginVendorImports && !runtimePluginSpecifier) {
+            preservedImports.push(original);
+            return _pfx || '';
+        }
         if (!canonical && isLikelyNativeScriptPluginSpecifier(specifier)) {
             canonical = specifier;
         }
@@ -318,6 +883,34 @@ function guardBareDynamicImports(code) {
         return code;
     }
 }
+function ensureDynamicHmrImportHelper(code) {
+    try {
+        if (!code.includes('__nsDynamicHmrImport('))
+            return code;
+        if (code.includes('const __nsDynamicHmrImport ='))
+            return code;
+        const helper = 'const __nsDynamicHmrImport = (spec) => {\n' +
+            "  const __nsm = '/ns' + '/m';\n" +
+            "  try { if (!spec || spec === '@') { return import(new URL(__nsm + '/__invalid_at__.mjs', import.meta.url).href); } } catch {}\n" +
+            '  try {\n' +
+            "    if (typeof spec === 'string' && spec.startsWith(__nsm + '/')) {\n" +
+            "      if (spec.includes('/__ns_hmr__/')) { return import(new URL(spec, import.meta.url).href); }\n" +
+            '      const g = globalThis;\n' +
+            "      const nonce = typeof g.__NS_HMR_IMPORT_NONCE__ === 'number' ? g.__NS_HMR_IMPORT_NONCE__ : 0;\n" +
+            "      const tag = nonce ? `n${nonce}` : 'live';\n" +
+            "      const nextPath = __nsm + '/__ns_hmr__/' + encodeURIComponent(tag) + spec.slice(__nsm.length);\n" +
+            "      const origin = typeof g.__NS_HTTP_ORIGIN__ === 'string' && /^https?:\\/\\//.test(g.__NS_HTTP_ORIGIN__) ? g.__NS_HTTP_ORIGIN__ : '';\n" +
+            '      return import(origin ? origin + nextPath : new URL(nextPath, import.meta.url).href);\n' +
+            '    }\n' +
+            '  } catch {}\n' +
+            '  return import(spec);\n' +
+            '};\n';
+        return helper + code;
+    }
+    catch {
+        return code;
+    }
+}
 function normalizeNativeScriptCoreSpecifier(spec) {
     let normalized = spec.replace(/@nativescript[_-]core/gi, '@nativescript/core').replace(/@nativescript\/core\/index\.js$/i, '@nativescript/core/index.js');
     if (normalized.startsWith('/node_modules/')) {
@@ -331,7 +924,7 @@ function normalizeNativeScriptCoreSpecifier(spec) {
     }
     return normalized;
 }
-function normalizeNodeModulesSpecifier(spec) {
+export function normalizeNodeModulesSpecifier(spec) {
     if (!spec) {
         return null;
     }
@@ -354,7 +947,7 @@ function normalizeNodeModulesSpecifier(spec) {
     }
     return subPath.startsWith('/') ? subPath.slice(1) : subPath;
 }
-function resolveVendorFromCandidate(specifier) {
+export function resolveVendorFromCandidate(specifier) {
     if (!specifier) {
         return null;
     }
@@ -375,9 +968,27 @@ function resolveVendorFromCandidate(specifier) {
             return flatMatch;
         }
         for (const [flatKey, canonical] of flattenedMap.entries()) {
-            if (flattenedId === flatKey || flattenedId.startsWith(`${flatKey}_`)) {
+            if (flattenedId === flatKey) {
                 return canonical;
             }
+            if (flattenedId.startsWith(`${flatKey}_`)) {
+                // The suffix after the flat key represents a subpath.
+                // Convert it back: e.g., "_solid" → "solid", "_store_dist_x" → "store/dist/x"
+                // Only resolve to the root vendor module if it's a file/dist subpath.
+                // Entry-point subpaths (e.g., _solid, _store) have different exports
+                // and must NOT be collapsed to the root.
+                const flatSuffix = flattenedId.slice(flatKey.length + 1);
+                const subpath = flatSuffix.replace(/_/g, '/');
+                if (isFileDistSubpath(subpath)) {
+                    return canonical;
+                }
+                // Check if there's an alias for this subpath entry
+                const aliasKey = `${canonical}/${subpath.split('/')[0]}`;
+                if (manifest.aliases?.[aliasKey] && manifest.modules[manifest.aliases[aliasKey]]) {
+                    return manifest.aliases[aliasKey];
+                }
+                // Entry-point subpath — don't collapse to root
+            }
         }
         const guessedId = flattenedId.replace(/__/g, '.').replace(/_/g, '/');
         if (guessedId && guessedId !== flattenedId) {
@@ -415,16 +1026,279 @@ function resolveVendorFromCandidate(specifier) {
     }
     return null;
 }
+function resolveCandidateFilePath(candidate, projectRoot) {
+    const cleaned = candidate.replace(PAT.QUERY_PATTERN, '');
+    if (!cleaned)
+        return null;
+    const root = path.resolve(projectRoot);
+    let absPath = null;
+    if (cleaned.startsWith('/@fs/')) {
+        absPath = cleaned.slice('/@fs'.length);
+    }
+    else if (cleaned.includes('/node_modules/')) {
+        absPath = path.resolve(root, `.${cleaned}`);
+    }
+    else if (/^(?:[A-Za-z]:)?\//.test(cleaned)) {
+        absPath = path.resolve(cleaned);
+    }
+    if (!absPath) {
+        return null;
+    }
+    const rel = path.relative(root, absPath);
+    if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) {
+        return null;
+    }
+    return existsSync(absPath) ? absPath : null;
+}
+export function filterExistingNodeModulesTransformCandidates(spec, candidates, projectRoot) {
+    const cleanedSpec = spec.replace(PAT.QUERY_PATTERN, '');
+    if (!cleanedSpec.includes('/node_modules/')) {
+        return candidates;
+    }
+    return candidates.filter((candidate) => !!resolveCandidateFilePath(candidate, projectRoot));
+}
 function findVendorPrefix(specifier, manifest) {
-    const { modules } = manifest;
+    const { modules, aliases } = manifest;
     const keys = Object.keys(modules || {});
     for (const key of keys) {
-        if (specifier === key || specifier.startsWith(`${key}/`)) {
+        if (specifier === key) {
             return key;
         }
+        if (specifier.startsWith(`${key}/`)) {
+            const subpath = specifier.slice(key.length + 1);
+            // Only match file/dist subpaths (e.g., solid-js/dist/dev.js → solid-js).
+            // Entry-point subpaths (e.g., solid-js/store) are separate packages
+            // and must NOT be collapsed to the root vendor module.
+            if (isFileDistSubpath(subpath)) {
+                return key;
+            }
+            // Check if there's an explicit alias for this subpath
+            const aliasKey = `${key}/${subpath.split('/')[0]}`;
+            if (aliases?.[aliasKey] && modules[aliases[aliasKey]]) {
+                return aliases[aliasKey];
+            }
+            // Entry-point subpath with no alias — don't vendor-resolve
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Convert a Vite .vite/deps/ filename back to a bare specifier with subpath,
+ * using the vendor manifest to determine where the package name ends and the
+ * subpath begins.
+ *
+ * e.g., "@nativescript_tanstack-router_solid.js" → "@nativescript/tanstack-router/solid"
+ *       "solid-js.js" → "solid-js"
+ *
+ * Returns null if no known package prefix matches.
+ */
+function viteDepsPathToBareSpecifier(depPath) {
+    const manifest = getVendorManifest();
+    if (!manifest)
+        return null;
+    const flatId = extractVitePrebundleId(`.vite/deps/${depPath}`);
+    if (!flatId)
+        return null;
+    const flatMap = getFlattenedManifestMap(manifest);
+    // Try exact match first
+    if (flatMap.has(flatId)) {
+        return flatMap.get(flatId);
+    }
+    // Try prefix match: find the longest matching vendor flat key
+    let bestKey = '';
+    let bestCanonical = '';
+    for (const [flatKey, canonical] of flatMap.entries()) {
+        if (flatId.startsWith(`${flatKey}_`) && flatKey.length > bestKey.length) {
+            bestKey = flatKey;
+            bestCanonical = canonical;
+        }
+    }
+    if (bestKey && bestCanonical) {
+        // Convert the suffix back to a subpath
+        const flatSuffix = flatId.slice(bestKey.length + 1);
+        const subpath = flatSuffix.replace(/_/g, '/');
+        return `${bestCanonical}/${subpath}`;
     }
     return null;
 }
+function isFileDistSubpath(subpath) {
+    const firstSegment = subpath.split('/')[0];
+    // Starts with a known build/dist directory segment → file path
+    const FILE_DIST_DIRS = new Set(['dist', 'src', 'lib', 'build', 'esm', 'cjs', 'es', 'umd', 'module', 'bundle', 'output', '_esm', '_cjs']);
+    if (FILE_DIST_DIRS.has(firstSegment)) {
+        return true;
+    }
+    // Single segment with file extension → file path (e.g., "index.js")
+    if (!subpath.includes('/') && /\.[a-zA-Z0-9]+$/.test(subpath)) {
+        return true;
+    }
+    return false;
+}
+// ── Package exports reverse map ──────────────────────────────────────────────
+// Resolves Vite's resolved file paths back to original bare specifiers using
+// the package's own package.json exports field. This eliminates the fragile
+// heuristic that tried to guess main entry vs. subpath from file paths.
+const _exportsReverseMapCache = new Map();
+/**
+ * Resolve the concrete file path from a package.json exports condition value.
+ * Handles nested condition objects: { "esm2022": { "default": "./file.mjs" } }
+ */
+function resolveExportConditionValue(conditions) {
+    if (typeof conditions === 'string')
+        return conditions;
+    if (typeof conditions !== 'object' || conditions === null)
+        return null;
+    const obj = conditions;
+    for (const key of ['esm2022', 'esm', 'esm2015', 'import', 'module', 'default']) {
+        if (key in obj) {
+            const result = resolveExportConditionValue(obj[key]);
+            if (result)
+                return result;
+        }
+    }
+    for (const val of Object.values(obj)) {
+        if (typeof val === 'string')
+            return val;
+    }
+    return null;
+}
+/**
+ * Build a reverse map from file paths → bare specifiers for a package.
+ *
+ * Example for @angular/common:
+ *   "fesm2022/common.mjs" → "@angular/common"        (exports["."])
+ *   "fesm2022/http.mjs"   → "@angular/common/http"   (exports["./http"])
+ *
+ * For packages without exports field, uses main/module fields.
+ */
+function getExportsReverseMap(pkgName, projectRoot) {
+    const cached = _exportsReverseMapCache.get(pkgName);
+    if (cached)
+        return cached;
+    const map = new Map();
+    try {
+        const pkgJsonPath = path.join(projectRoot, 'node_modules', pkgName, 'package.json');
+        const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+        if (pkgJson.exports && typeof pkgJson.exports === 'object') {
+            for (const [entryPoint, conditions] of Object.entries(pkgJson.exports)) {
+                // Skip wildcard patterns (./locales/*, etc.) and non-JS exports
+                if (entryPoint.includes('*') || entryPoint.endsWith('.json'))
+                    continue;
+                const resolvedPath = resolveExportConditionValue(conditions);
+                if (resolvedPath && typeof resolvedPath === 'string') {
+                    const normalized = resolvedPath.replace(/^\.\//, '');
+                    const bareSpec = entryPoint === '.' ? pkgName : `${pkgName}/${entryPoint.replace(/^\.\//, '')}`;
+                    map.set(normalized, bareSpec);
+                }
+            }
+        }
+        // Fallback: main/module field for packages without exports
+        if (map.size === 0) {
+            for (const field of ['module', 'main']) {
+                const value = pkgJson[field];
+                if (value && typeof value === 'string') {
+                    const normalized = value.replace(/^\.\//, '');
+                    map.set(normalized, pkgName);
+                    // Also store without extension for NativeScript platform resolution
+                    const withoutExt = normalized.replace(/\.[^.]+$/, '');
+                    if (withoutExt !== normalized) {
+                        map.set(withoutExt, pkgName);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    catch {
+        // Package.json not found or unreadable
+    }
+    _exportsReverseMapCache.set(pkgName, map);
+    return map;
+}
+/**
+ * Extract the root package name from a node_modules specifier.
+ * "@angular/common/fesm2022/http.mjs" → "@angular/common"
+ * "tslib/tslib.es6.mjs" → "tslib"
+ */
+function extractRootPackageName(spec) {
+    if (spec.startsWith('@')) {
+        const parts = spec.split('/');
+        return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : spec;
+    }
+    return spec.split('/')[0];
+}
+/**
+ * Determine whether a vendor package import should go through the vendor bridge
+ * (bare specifier) or HTTP (full URL), using the package's exports map.
+ *
+ * Returns:
+ *   { route: 'vendor', bareSpec: string }  — use vendor bridge with this bare specifier
+ *   { route: 'http' }                      — serve via HTTP
+ *   null                                   — not a vendor package
+ */
+function resolveVendorRouting(nodeModulesSpec, projectRoot) {
+    const pkgName = extractRootPackageName(nodeModulesSpec);
+    const subpath = nodeModulesSpec.slice(pkgName.length).replace(/^\//, '');
+    const pkgBaseName = pkgName.split('/').pop() || '';
+    const isRootLevelMainEntry = (() => {
+        if (!subpath || subpath.includes('/')) {
+            return false;
+        }
+        const withoutExt = subpath.replace(/\.[^.]+$/, '');
+        const withoutPlatform = withoutExt.replace(/\.(ios|android|visionos)$/i, '');
+        return withoutPlatform === 'index' || withoutPlatform === pkgBaseName;
+    })();
+    // Runtime NativeScript plugins must preserve require()-style loading even when
+    // they are not part of the vendor manifest. Many community packages rely on
+    // singleton side effects or tolerate CommonJS circular initialization that
+    // would fail under plain HTTP ESM evaluation.
+    if (isLikelyNativeScriptRuntimePluginSpecifier(pkgName) && (!subpath || isRootLevelMainEntry)) {
+        return { route: 'vendor', bareSpec: pkgName };
+    }
+    // Check if this package is in the vendor manifest
+    const manifest = getVendorManifest();
+    if (!manifest?.modules?.[pkgName]) {
+        return null;
+    }
+    // Platform-specific NativeScript plugin main entries should still use the
+    // vendor bridge so device require() preserves singleton side effects.
+    // Their named/default bindings are synthesized later by
+    // ensureNativeScriptModuleBindings, so they do not rely on ns-vendor:// ESM
+    // exports directly.
+    if (/\.(ios|android|visionos)\.(js|ts|mjs|mts)$/i.test(nodeModulesSpec) && isLikelyNativeScriptRuntimePluginSpecifier(pkgName) && isRootLevelMainEntry) {
+        return { route: 'vendor', bareSpec: pkgName };
+    }
+    // Other platform-specific files still go via HTTP.
+    if (/\.(ios|android|visionos)\.(js|ts|mjs|mts)$/.test(nodeModulesSpec)) {
+        return { route: 'http' };
+    }
+    // No subpath → bare package specifier → vendor bridge
+    if (!subpath) {
+        return { route: 'vendor', bareSpec: pkgName };
+    }
+    // Use exports reverse map to detect subpath entries — these MUST go to HTTP
+    // to avoid collapsing e.g. @angular/common/http → @angular/common
+    const reverseMap = getExportsReverseMap(pkgName, projectRoot);
+    const originalSpec = reverseMap.get(subpath);
+    if (originalSpec && originalSpec !== pkgName) {
+        // Subpath entry (e.g., fesm2022/http.mjs → @angular/common/http) → HTTP
+        return { route: 'http' };
+    }
+    // For vendor routing, only use the vendor bridge for root-level main entries
+    // (single-segment paths like "index.js", "tslib.es6.mjs"). Multi-segment
+    // build output paths (fesm2022/core.mjs, dist/index.js) go to HTTP even if
+    // they ARE the main entry — the ns-vendor:// protocol in HMR mode does not
+    // reliably serve all named ES exports for complex packages.
+    if (!subpath.includes('/')) {
+        const lastSegment = subpath.replace(/\.[^.]+$/, '');
+        if (lastSegment === 'index' || lastSegment === pkgBaseName || lastSegment.startsWith(pkgBaseName + '.')) {
+            return { route: 'vendor', bareSpec: pkgName };
+        }
+    }
+    // Default: HTTP — safe for all module types and preserves all named exports
+    return { route: 'http' };
+}
 function stripCoreGlobalsImports(code) {
     const pattern = /^\s*(?:import\s+(?:[^'"\n]*from\s+)?|export\s+\*\s+from\s+)["'][^"']*(?:@nativescript(?:[/_-])core(?:[\/_-])globals|@nativescript_core_globals)[^"']*["'];?\s*$/gm;
     return code.replace(pattern, '');
@@ -471,6 +1345,109 @@ function ensureGuardPlainDynamicImports(code, origin) {
         return code;
     }
 }
+/**
+ * Expand `export * from "url"` into explicit named re-exports.
+ *
+ * NativeScript's HTTP ESM loader on iOS/Android may not correctly propagate
+ * `export * from` re-exports across HTTP module boundaries — the importing
+ * module's namespace object gets only direct exports, missing re-exported
+ * names. This function resolves each `export * from` by fetching the target
+ * module, scanning for its named exports, and replacing the star export with
+ * explicit `export { name1, name2, ... } from "url"`.
+ *
+ * Only expands star exports pointing to node_modules HTTP URLs to avoid
+ * unnecessary work for app source files (which are typically not re-exported).
+ */
+async function expandStarExports(code, server, projectRoot, verbose) {
+    const STAR_RE = /^[ \t]*(export\s+\*\s+from\s+["'])([^"']+)(["'];?)[ \t]*$/gm;
+    let match;
+    const replacements = [];
+    while ((match = STAR_RE.exec(code)) !== null) {
+        const url = match[2];
+        // Only expand node_modules star exports served over HTTP
+        if (!url.includes('/node_modules/'))
+            continue;
+        replacements.push({ full: match[0], url, prefix: match[1], suffix: match[3] });
+    }
+    if (!replacements.length)
+        return code;
+    for (const rep of replacements) {
+        try {
+            // Strip HTTP origin to get a Vite-resolvable path
+            let vitePath = rep.url.replace(/^https?:\/\/[^/]+/, '');
+            // Strip /ns/m/ prefix to get the node_modules path
+            vitePath = vitePath.replace(/^\/ns\/m\//, '/');
+            // Strip boot-path prefix used during initial HTTP boot progress tracking.
+            vitePath = vitePath.replace(/^\/__ns_boot__\/[^/]+/, '');
+            // Strip HMR cache-busting path segments
+            vitePath = vitePath.replace(/\/__ns_hmr__\/[^/]+/, '');
+            const r = await server.transformRequest(vitePath);
+            if (!r?.code)
+                continue;
+            const names = extractExportedNames(r.code);
+            if (!names.length)
+                continue;
+            // Replace `export * from "url"` with explicit named re-exports
+            const explicit = `export { ${names.join(', ')} } from ${JSON.stringify(rep.url)};`;
+            code = code.replace(rep.full, explicit);
+            if (verbose) {
+                console.log(`[ns/m] expanded export* → ${names.length} names from ${vitePath}`);
+            }
+        }
+        catch { }
+    }
+    return code;
+}
+/**
+ * Extract named export identifiers from a module's source code.
+ * Handles: export function/class/const/let/var NAME, export { NAME },
+ * export { NAME as ALIAS }, and export * from (recursive marker).
+ * Does NOT follow `export * from` chains — only direct exports.
+ */
+function extractExportedNames(code) {
+    const names = new Set();
+    // export function NAME / export class NAME / export async function NAME
+    const declRe = /\bexport\s+(?:async\s+)?(?:function|class)\s+([A-Za-z_$][\w$]*)/g;
+    let m;
+    while ((m = declRe.exec(code)) !== null) {
+        names.add(m[1]);
+    }
+    // export const/let/var NAME (handles destructuring and multiple declarators)
+    const varRe = /\bexport\s+(?:const|let|var)\s+([^=;{]+)/g;
+    while ((m = varRe.exec(code)) !== null) {
+        // Simple case: `export const foo = ...`
+        const decl = m[1].trim();
+        // Could be `{ a, b }` (destructuring) or `foo, bar` (multiple) or just `foo`
+        if (decl.startsWith('{')) {
+            const inner = decl.replace(/^\{|\}$/g, '');
+            for (const part of inner.split(',')) {
+                const name = part.split(':')[0].trim(); // handle { orig: alias }
+                if (/^[A-Za-z_$][\w$]*$/.test(name))
+                    names.add(name);
+            }
+        }
+        else {
+            const name = decl.split(/[\s,=]/)[0].trim();
+            if (/^[A-Za-z_$][\w$]*$/.test(name))
+                names.add(name);
+        }
+    }
+    // export { NAME, NAME as ALIAS, ... } (without `from`)
+    // and export { NAME, ... } from "..." (re-exports)
+    const braceRe = /\bexport\s*\{([^}]+)\}/g;
+    while ((m = braceRe.exec(code)) !== null) {
+        for (const part of m[1].split(',')) {
+            const trimmed = part.trim();
+            // `name as alias` → use alias; `name` → use name
+            const asMatch = trimmed.match(/\S+\s+as\s+(\S+)/);
+            const name = asMatch ? asMatch[1] : trimmed.split(/\s/)[0];
+            if (name && /^[A-Za-z_$][\w$]*$/.test(name) && name !== 'default') {
+                names.add(name);
+            }
+        }
+    }
+    return Array.from(names);
+}
 // Heal accidental "import ... = expr" assignments produced by upstream transforms.
 // These are invalid JS; convert to equivalent const assignments.
 function repairImportEqualsAssignments(code) {
@@ -521,6 +1498,11 @@ function ensureVersionedCoreImports(code, origin, ver) {
     catch { }
     return code;
 }
+export function buildVersionedCoreSubpathAliasModule(sub, ver) {
+    const normalizedSub = (sub || '').replace(/^\/+/, '');
+    const canonicalUrl = `/ns/core/${ver}?p=${normalizedSub}`;
+    return `import * as __ns_core_alias from ${JSON.stringify(canonicalUrl)};\n` + `export default (__ns_core_alias.default || __ns_core_alias);\n` + `export * from ${JSON.stringify(canonicalUrl)};\n`;
+}
 // Hardened removal of Vite's virtual dynamic-import-helper. Some variants (side-effect only
 // or minified forms) slipped past earlier regexes causing runtime attempts to resolve
 // /@id/__x00__vite/dynamic-import-helper.js which does not exist in the device mirror.
@@ -809,68 +1791,15 @@ function cleanCode(code) {
     result = ACTIVE_STRATEGY.preClean(result);
     result = ACTIVE_STRATEGY.rewriteFrameworkImports(result);
     // Vendor manifest-driven import rewrites
+    // NOTE: Static and side-effect vendor imports are intentionally NOT rewritten here.
+    // They are left as import statements so that ensureNativeScriptModuleBindings()
+    // (called later in processCodeForDevice) can transform them using the robust
+    // __nsVendorRequire + __nsPick pattern that works on device.
+    // Only dynamic imports are handled here since ensureNativeScriptModuleBindings
+    // does not process dynamic import() calls.
     try {
         const manifest = getVendorManifest();
         if (manifest) {
-            // Pattern: capture full import statement (static) with optional bindings
-            // import X from 'pkg'; | import {a,b as c} from "pkg"; | import * as ns from 'pkg';
-            const staticImportRE = /(import\s+([^;]*?)\s+from\s*["'])([^"']+)(["'];?)/g;
-            result = result.replace(staticImportRE, (full, pre, bindings, spec, post) => {
-                // Do not vendor-rewrite @nativescript/core — handled by the unified HTTP bridge later
-                if (isNativeScriptCoreModule(spec))
-                    return full;
-                const resolved = resolveVendorSpecifier(spec);
-                if (!resolved || /^@nativescript\/core(\b|\/)/i.test(resolved))
-                    return full; // not vendor or is core
-                // Determine binding style
-                const trimmed = (bindings || '').trim();
-                let injected = '';
-                if (!trimmed || trimmed === '') {
-                    // Side-effect import: import 'pkg'; -> we drop it (vendor already evaluated)
-                    return `/* vendor side-effect dropped: ${spec} */`;
-                }
-                // Default + named or default only
-                // Examples of trimmed:
-                //   defaultExport
-                //   { a, b as c }
-                //   * as ns
-                //   defaultExport, { a, b }
-                const globalAccessor = `globalThis.__nsVendor && globalThis.__nsVendor(${JSON.stringify(resolved)})`;
-                const ensureHelper = `globalThis.__nsVendor=require? (globalThis.__nsVendor|| (globalThis.__nsVendor=(id)=>{const m=(globalThis.__NS_VENDOR_MANIFEST__?globalThis.__NS_VENDOR_MANIFEST__.modules[id]:null);return (globalThis.__nsModules && globalThis.__nsModules.get? (globalThis.__nsModules.get(id)||globalThis.__nsModules.get(m?.id||id)):undefined);})):globalThis.__nsVendor`;
-                if (trimmed.startsWith('{')) {
-                    // Named only
-                    injected = `${ensureHelper}; const ${trimmed} = ${globalAccessor} || {};`;
-                }
-                else if (trimmed.startsWith('*')) {
-                    // Namespace import: * as ns
-                    const m = /\*\s+as\s+(\w+)/.exec(trimmed);
-                    if (m) {
-                        injected = `${ensureHelper}; const ${m[1]} = ${globalAccessor} || {};`;
-                    }
-                }
-                else if (trimmed.includes(',')) {
-                    // default plus named
-                    const parts = trimmed.split(',');
-                    const def = parts[0].trim();
-                    const named = parts.slice(1).join(',').trim();
-                    injected = `${ensureHelper}; const __vmod = ${globalAccessor} || {}; const ${def} = __vmod.default || __vmod; const ${named} = __vmod;`;
-                }
-                else {
-                    // default only
-                    injected = `${ensureHelper}; const ${trimmed} = (${globalAccessor}||{}).default || ${globalAccessor};`;
-                }
-                return injected;
-            });
-            // Bare side-effect imports: import 'pkg';
-            const sideEffectRE = /(import\s*["'])([^"']+)(["'];?)/g;
-            result = result.replace(sideEffectRE, (full, pre, spec, post) => {
-                if (isNativeScriptCoreModule(spec))
-                    return full;
-                const resolved = resolveVendorSpecifier(spec);
-                if (!resolved || /^@nativescript\/core(\b|\/)/i.test(resolved))
-                    return full;
-                return `/* vendor side-effect skipped: ${spec} */`;
-            });
             // Dynamic import rewrites: import('pkg') -> Promise.resolve(__nsVendor('id'))
             const dynImportRE = /(import\(\s*["'])([^"']+)(["']\s*\))/g;
             result = result.replace(dynImportRE, (full, pre, spec, post) => {
@@ -1023,15 +1952,169 @@ function normalizeAbsoluteFilesystemImport(spec, importerPath, projectRoot) {
     if (!absolute || absolute === spec) {
         return null;
     }
-    return absolute;
+    return absolute;
+}
+/**
+ * After the Angular linker runs on code that Vite has already resolved (bare
+ * specifiers → full URLs), the linker injects NEW import statements with bare
+ * specifiers (e.g. `import {Component} from '@angular/core'`).  These cause:
+ *   1. Duplicate-identifier SyntaxErrors (the name was already imported via URL)
+ *   2. Unresolvable bare specifiers at runtime on device
+ *
+ * This function:
+ *   • builds a map  packageName → resolvedURL  from existing resolved imports
+ *   • collects all binding names already imported per package
+ *   • for each bare-specifier import, removes duplicate bindings
+ *   • rewrites any genuinely-new bindings to use the resolved URL
+ */
+function deduplicateLinkerImports(code) {
+    if (!code)
+        return code;
+    try {
+        const imports = collectTopLevelImportRecords(code);
+        if (!imports.length) {
+            return code;
+        }
+        // ── Step 1: collect resolved imports already in the file ──────────
+        const pkgUrlMap = new Map();
+        const pkgBindings = new Map();
+        for (const imp of imports) {
+            const url = imp.source;
+            if (!/^https?:\/\//.test(url) && !url.startsWith('/')) {
+                continue;
+            }
+            const nmIdx = url.lastIndexOf('/node_modules/');
+            if (nmIdx === -1)
+                continue;
+            const afterNm = url.substring(nmIdx + '/node_modules/'.length);
+            const parts = afterNm.split('/');
+            const pkg = parts[0].startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
+            if (!pkgUrlMap.has(pkg))
+                pkgUrlMap.set(pkg, url);
+            if (imp.namedBindings.length) {
+                if (!pkgBindings.has(pkg))
+                    pkgBindings.set(pkg, new Set());
+                for (const binding of imp.namedBindings) {
+                    if (binding.importedName)
+                        pkgBindings.get(pkg).add(binding.importedName);
+                }
+            }
+        }
+        if (pkgUrlMap.size === 0)
+            return code;
+        // ── Step 2: rewrite bare-specifier imports ───────────────────────
+        const edits = [];
+        for (const imp of imports) {
+            if (!imp.hasOnlyNamedSpecifiers) {
+                continue;
+            }
+            const specifier = imp.source;
+            if (specifier.startsWith('/') || specifier.startsWith('.') || specifier.startsWith('http')) {
+                continue;
+            }
+            const parts = specifier.split('/');
+            const pkg = specifier.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
+            const url = pkgUrlMap.get(pkg);
+            if (!url) {
+                continue;
+            }
+            const existing = pkgBindings.get(pkg) || new Set();
+            const newBindings = imp.namedBindings.filter((binding) => !existing.has(binding.importedName));
+            if (newBindings.length === 0) {
+                edits.push({ start: imp.start, end: imp.end, text: '' });
+                continue;
+            }
+            if (newBindings.length === imp.namedBindings.length) {
+                continue;
+            }
+            for (const binding of newBindings) {
+                existing.add(binding.importedName);
+            }
+            edits.push({
+                start: imp.start,
+                end: imp.end,
+                text: `import { ${newBindings.map((binding) => binding.text).join(', ')} } from ${JSON.stringify(url)};`,
+            });
+        }
+        if (!edits.length) {
+            return code;
+        }
+        let next = code;
+        for (const edit of edits.sort((left, right) => right.start - left.start)) {
+            next = next.slice(0, edit.start) + edit.text + next.slice(edit.end);
+        }
+        return next;
+    }
+    catch {
+        return code;
+    }
+}
+export function wrapCommonJsModuleForDevice(code) {
+    if (!code)
+        return code;
+    try {
+        const hasExportDefault = /\bexport\s+default\b/.test(code) || /export\s*\{\s*default\s*(?:as\s*default)?\s*\}/.test(code);
+        const hasNamedExports = /\bexport\s+(?:const|let|var|function|class|async)\b/.test(code) || /\bexport\s*\{/.test(code);
+        const hasCjsExports = /\bmodule\s*\.\s*exports\b/.test(code) || /\bexports\s*\.\s*\w/.test(code);
+        if (hasExportDefault || hasNamedExports || !hasCjsExports) {
+            return code;
+        }
+        const namedExports = new Set();
+        const exportsRe = /\bexports\s*\.\s*([A-Za-z_$][\w$]*)\s*=/g;
+        let em;
+        while ((em = exportsRe.exec(code)) !== null) {
+            const name = em[1];
+            if (name !== '__esModule' && name !== 'default') {
+                namedExports.add(name);
+            }
+        }
+        const defPropRe = /Object\s*\.\s*defineProperty\s*\(\s*exports\s*,\s*['"]([^'"]+)['"]/g;
+        while ((em = defPropRe.exec(code)) !== null) {
+            const name = em[1];
+            if (name !== '__esModule' && name !== 'default') {
+                namedExports.add(name);
+            }
+        }
+        let suffix = `\nvar __cjs_mod = module.exports;\nexport default __cjs_mod;\n`;
+        if (namedExports.size) {
+            const entries = Array.from(namedExports);
+            const temps = entries.map((name, i) => `var __cjs_e${i} = __cjs_mod[${JSON.stringify(name)}];`);
+            const reExports = entries.map((name, i) => `__cjs_e${i} as ${name}`);
+            suffix += `${temps.join(' ')}\nexport { ${reExports.join(', ')} };\n`;
+        }
+        const prelude = `var module = { exports: {} }; var exports = module.exports;\n` +
+            `var __ns_cjs_require_base = (typeof globalThis.__nsBaseRequire === 'function' ? globalThis.__nsBaseRequire : (typeof globalThis.__nsRequire === 'function' ? globalThis.__nsRequire : (typeof globalThis.require === 'function' ? globalThis.require : undefined)));\n` +
+            `var __ns_cjs_require_kind = (typeof globalThis.__nsBaseRequire === 'function' ? 'base-require' : (typeof globalThis.__nsRequire === 'function' ? 'vendor-require' : 'global-require'));\n` +
+            `var require = function(spec) {\n` +
+            `  if (!__ns_cjs_require_base) { throw new Error('require is not defined'); }\n` +
+            `  try { var __nsRecord = globalThis.__NS_RECORD_MODULE_PROVENANCE__; if (typeof __nsRecord === 'function') { __nsRecord(String(spec), { kind: __ns_cjs_require_kind, specifier: String(spec), via: 'cjs-wrapper', parent: (typeof import.meta !== 'undefined' && import.meta && import.meta.url) ? import.meta.url : undefined }); } } catch (e) {}\n` +
+            `  var mod = __ns_cjs_require_base(spec);\n` +
+            `  try {\n` +
+            `    if (mod && (typeof mod === 'object' || typeof mod === 'function') && mod.default !== undefined) {\n` +
+            `      var keys = [];\n` +
+            `      try { keys = Object.keys(mod); } catch (e) {}\n` +
+            `      var defaultOnly = keys.length === 1 && keys[0] === 'default';\n` +
+            `      var esModuleOnly = keys.length === 2 && keys.indexOf('default') !== -1 && keys.indexOf('__esModule') !== -1;\n` +
+            `      if (mod.__esModule || defaultOnly || esModuleOnly) { return mod.default; }\n` +
+            `    }\n` +
+            `  } catch (e) {}\n` +
+            `  return mod;\n` +
+            `};\n`;
+        return `${prelude}${code}${suffix}`;
+    }
+    catch {
+        return code;
+    }
 }
 /**
  * Process code for device: inject globals, remove framework imports
  */
-function processCodeForDevice(code, isVitePreBundled) {
+function processCodeForDevice(code, isVitePreBundled, preserveVendorImports = false, isNodeModule = false, sourceId) {
     let result = code;
     // Ensure Angular partial declarations are linked before any sanitizers run so runtime never hits the JIT path.
     result = linkAngularPartialsIfNeeded(result);
+    // Post-linker: deduplicate/resolve imports the Angular linker injected with bare specifiers
+    result = deduplicateLinkerImports(result);
     // First: aggressively strip any lingering virtual dynamic-import-helper before anything else.
     // Doing this up-front prevents downstream dependency collection from seeing the virtual id.
     result = stripViteDynamicImportVirtual(result);
@@ -1042,13 +2125,17 @@ function processCodeForDevice(code, isVitePreBundled) {
     // Inject ALL NativeScript/build globals at the top (matching global-defines.ts)
     // This ensures any code using __DEV__, __ANDROID__, __IOS__, etc. works correctly
     const allGlobals = [
+        // Minimal process shim — populated with CLI --env.* flags at module load time.
+        // In production builds, Vite/Rollup replaces process.env.* statically.
+        // In HMR dev mode the code runs as-is on device, so we need the shim.
+        `if (typeof process === "undefined") { globalThis.process = { env: ${__processEnvJson} }; } else if (!process.env) { process.env = ${__processEnvJson}; }`,
         'const __ANDROID__ = globalThis.__ANDROID__ !== undefined ? globalThis.__ANDROID__ : false;',
         'const __IOS__ = globalThis.__IOS__ !== undefined ? globalThis.__IOS__ : false;',
         'const __VISIONOS__ = globalThis.__VISIONOS__ !== undefined ? globalThis.__VISIONOS__ : false;',
         'const __APPLE__ = globalThis.__APPLE__ !== undefined ? globalThis.__APPLE__ : (__IOS__ || __VISIONOS__);',
         'const __DEV__ = globalThis.__DEV__ !== undefined ? globalThis.__DEV__ : false;',
         'const __COMMONJS__ = globalThis.__COMMONJS__ !== undefined ? globalThis.__COMMONJS__ : false;',
-        'const __NS_WEBPACK__ = globalThis.__NS_WEBPACK__ !== undefined ? globalThis.__NS_WEBPACK__ : true;',
+        'const __NS_WEBPACK__ = globalThis.__NS_WEBPACK__ !== undefined ? globalThis.__NS_WEBPACK__ : false;',
         'const __NS_ENV_VERBOSE__ = globalThis.__NS_ENV_VERBOSE__ !== undefined ? !!globalThis.__NS_ENV_VERBOSE__ : false;',
         "const __CSS_PARSER__ = globalThis.__CSS_PARSER__ !== undefined ? globalThis.__CSS_PARSER__ : 'css-tree';",
         'const __UI_USE_XML_PARSER__ = globalThis.__UI_USE_XML_PARSER__ !== undefined ? globalThis.__UI_USE_XML_PARSER__ : true;',
@@ -1056,19 +2143,29 @@ function processCodeForDevice(code, isVitePreBundled) {
         'const __TEST__ = globalThis.__TEST__ !== undefined ? globalThis.__TEST__ : false;',
     ];
     result = allGlobals.join('\n') + '\n' + result;
-    // Prefer AST-based normalization for imports and helper aliases; fallback regex if parsing fails
-    try {
-        result = astNormalizeModuleImportsAndHelpers(result);
+    const nodeModuleProvenancePrelude = buildNodeModuleProvenancePrelude(sourceId);
+    if (nodeModuleProvenancePrelude) {
+        result = nodeModuleProvenancePrelude + result;
     }
-    catch { }
-    // Verify there are no duplicate top-level const/let bindings after AST normalization
-    try {
-        result = astVerifyAndAnnotateDuplicates(result);
+    // AST normalization: inject /ns/rt helper aliases for underscore-prefixed identifiers.
+    // ONLY for app source files — library code in node_modules should be served as-is.
+    // Running the normalizer on libraries like tslib injects harmful destructures
+    // (e.g., `const { SuppressedError } = __ns_rt_ns_1`) that shadow globals.
+    if (!isNodeModule) {
+        try {
+            result = astNormalizeModuleImportsAndHelpers(result);
+        }
+        catch { }
+        // Verify there are no duplicate top-level const/let bindings after AST normalization
+        try {
+            result = astVerifyAndAnnotateDuplicates(result);
+        }
+        catch { }
     }
-    catch { }
-    // If AST marker present, skip regex-based helper alias injection to avoid duplicates
-    // Accept both line and block comment markers emitted by the normalizer
-    if (!/^\s*(?:\/\/|\/\*) \[ast-normalized\]/m.test(result)) {
+    // If AST marker present OR this is a node_modules file, skip regex-based helper
+    // alias injection. Library code should NOT get /ns/rt destructures injected —
+    // underscore-prefixed identifiers in libraries are internal variables, not NS helpers.
+    if (!isNodeModule && !/^\s*(?:\/\/|\/\*) \[ast-normalized\]/m.test(result)) {
         try {
             const underscored = new Set();
             const re = /(^|[^.\w$])_([A-Za-z]\w*)\b/g;
@@ -1149,7 +2246,11 @@ function processCodeForDevice(code, isVitePreBundled) {
         result = result.replace(/(^|\n)([\t ]*import\s+[^;]*?\s+from)\s*\n\s*("\/?node_modules\/\.vite\/deps\/[^"\n]+"\s*;?\s*)/gm, (_m, p1, p2, p3) => `${p1}${p2} ${p3}`);
     }
     catch { }
-    result = ensureNativeScriptModuleBindings(result);
+    // When preserveVendorImports is true (HMR /ns/m/ endpoint), skip the
+    // __nsVendorRequire + __nsPick rewrite. Vendor imports stay as bare
+    // specifiers so the device-side import map resolves them via V8's native
+    // module system, which correctly handles export * re-exports.
+    result = preserveVendorImports ? ensureNativeScriptModuleBindings(result, { preserveNonPluginVendorImports: true }) : ensureNativeScriptModuleBindings(result);
     // Repair any accidental "import ... = expr" assignments that may have slipped in.
     try {
         result = repairImportEqualsAssignments(result);
@@ -1158,10 +2259,7 @@ function processCodeForDevice(code, isVitePreBundled) {
     // Strip Vite prebundle deps imports (both named and side-effect) and any malformed const string artifacts
     // Example problematic line observed: const "/node_modules/.vite/deps/@nativescript_firebase-messaging.js?v=...";
     if (/node_modules\/\.vite\/deps\//.test(result)) {
-        // Named imports from prebundle deps
-        result = result.replace(/^[\t ]*import\s+[^;]*from\s+["']\/?node_modules\/\.vite\/deps\/[^"']+["'];?\s*$/gm, '');
-        // Side-effect only imports from prebundle deps
-        result = result.replace(/^[\t ]*import\s+["']\/?node_modules\/\.vite\/deps\/[^"']+["'];?\s*$/gm, '');
+        result = rewriteVitePrebundleImportsForDevice(result, preserveVendorImports);
         // Malformed const string lines accidentally produced by upstream transforms
         result = result.replace(/^[\t ]*const\s+["']\/?node_modules\/\.vite\/deps\/[^"']+["'];?\s*$/gm, '// [hmr-sanitize] stripped malformed const prebundle ref\n');
         // Naked string-only lines pointing at prebundle deps
@@ -1248,7 +2346,7 @@ function processCodeForDevice(code, isVitePreBundled) {
     }
     // Ensure vendor bindings also apply after potential wrapper injections above
     // (idempotent: second pass will be a no-op if imports already consumed).
-    result = ensureNativeScriptModuleBindings(result);
+    result = preserveVendorImports ? ensureNativeScriptModuleBindings(result, { preserveNonPluginVendorImports: true }) : ensureNativeScriptModuleBindings(result);
     try {
         result = repairImportEqualsAssignments(result);
     }
@@ -1315,6 +2413,9 @@ function processCodeForDevice(code, isVitePreBundled) {
                 .join(', ');
             const reNamed = /(^|\n)\s*import\s*\{([^}]+)\}\s*from\s*["']((?:https?:\/\/[^"']+)?\/ns\/core(?:\/[\d]+)?(?:\?p=[^"']+)?)['"];?\s*/gm;
             result = result.replace(reNamed, (_full, pfx, specList, src) => {
+                // Deep subpath URLs serve actual ESM with real named exports — skip.
+                if (isDeepCoreSubpath(src))
+                    return _full;
                 __core_ns_seq++;
                 const tmp = `__ns_core_ns${__core_ns_seq}`;
                 const decl = `const { ${toDestructureCore(specList)} } = ${tmp};`;
@@ -1322,6 +2423,8 @@ function processCodeForDevice(code, isVitePreBundled) {
             });
             const reMixed = /(^|\n)\s*import\s+([A-Za-z_$][\w$]*)\s*,\s*\{([^}]+)\}\s*from\s*["']((?:https?:\/\/[^"']+)?\/ns\/core(?:\/[\d]+)?(?:\?p=[^"']+)?)['"];?\s*/gm;
             result = result.replace(reMixed, (_full, pfx, defName, specList, src) => {
+                if (isDeepCoreSubpath(src))
+                    return _full;
                 const decl = `const { ${toDestructureCore(specList)} } = ${defName};`;
                 return `${pfx}import ${defName} from ${JSON.stringify(src)};\n${decl}\n`;
             });
@@ -1335,8 +2438,11 @@ function processCodeForDevice(code, isVitePreBundled) {
         // Keep a single semicolon before the import to avoid generating ';;'
         result = result.replace(/;\s*import\s+/g, ';\nimport ');
         result = result.replace(/}\s*import\s+/g, '}\nimport ');
-        // Fallback: ensure any static import that isn't at start of line gets a newline before it
-        result = result.replace(/([^\n])\s*(import\s+[^;\n]*\s+from\s*["'][^"']+["'])/g, '$1\n$2');
+        // Fallback: ensure any static import that isn't at start of line gets a newline before it.
+        // Only match after statement-ending characters (;, }, ), ], quotes) — NOT after `*` or
+        // spaces inside JSDoc comment blocks, which would accidentally extract example imports
+        // from documentation comments and hoist them as real code.
+        result = result.replace(/([;}\)\]'"`])\s*(import\s+[^;\n]*\s+from\s*["'][^"']+["'])/g, '$1\n$2');
     }
     catch { }
     // Collapse duplicate destructuring from the same temp namespace var (e.g., multiple const { x } = __ns_rt_ns1)
@@ -1370,22 +2476,13 @@ function processCodeForDevice(code, isVitePreBundled) {
     // always come before any statements that might reference their bindings. This ordering avoids
     // device runtimes that are stricter about imports-first semantics during module instantiation.
     try {
-        const importLineRe = /^\s*import\s+[^;]+;?\s*$/gm;
-        const lines = [];
-        result = result.replace(importLineRe, (imp) => {
-            lines.push(imp.trim());
-            return '';
-        });
-        if (lines.length) {
-            const hoisted = Array.from(new Set(lines)).join('\n') + '\n';
-            result = hoisted + result;
-        }
+        result = hoistTopLevelStaticImports(result);
     }
     catch { }
     // Final safety: normalize any lingering named imports from /ns/rt into default+destructure
-    // Skip when AST normalization marker present to avoid introducing duplicate temp imports
+    // Skip for node_modules (no /ns/rt helpers needed) and when AST marker present
     try {
-        if (!/^\s*\/\* \[ast-normalized\] \*\//m.test(result)) {
+        if (!isNodeModule && !/^\s*\/\* \[ast-normalized\] \*\//m.test(result)) {
             result = ensureDestructureRtImports(result);
         }
     }
@@ -1531,6 +2628,13 @@ function assertNoOptimizedArtifacts(code, contextLabel) {
                 }
             }
             if (localCore.test(ln)) {
+                // Comments can never cause split-realm risk at runtime — skip them.
+                // Library authors commonly reference @nativescript/core in comments
+                // (e.g. TSDoc /// <reference> directives, module resolution notes).
+                const trimmed = ln.trimStart();
+                if (trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*')) {
+                    continue;
+                }
                 offenders.push(`${i + 1}: ${ln.substring(0, 200)} [local-core-path]`);
             }
             if (offenders.length >= 10)
@@ -1555,6 +2659,7 @@ function assertNoOptimizedArtifacts(code, contextLabel) {
 function ensureDestructureCoreImports(code) {
     try {
         let result = code;
+        let coreImportCounter = 0;
         const toDestructure = (specList) => specList
             .split(',')
             .map((s) => s.trim())
@@ -1567,13 +2672,19 @@ function ensureDestructureCoreImports(code) {
         // import { A, B } from '/ns/core[/ver][?p=...]'
         const reNamed = /(^|\n)\s*import\s*\{([^}]+)\}\s*from\s*["']((?:https?:\/\/[^"']+)?\/ns\/core(?:\/[\d]+)?(?:\?p=[^"']+)?)['"];?\s*/gm;
         result = result.replace(reNamed, (_full, pfx, specList, src) => {
-            const tmp = `__ns_core_ns_re`; // temp binding name is not reused elsewhere after hoist
+            // Deep subpath URLs serve actual ESM with real named exports — skip.
+            if (isDeepCoreSubpath(src))
+                return _full;
+            const tmp = `__ns_core_ns_re${coreImportCounter > 0 ? `_${coreImportCounter}` : ''}`;
+            coreImportCounter++;
             const decl = `const { ${toDestructure(specList)} } = ${tmp};`;
             return `${pfx}import ${tmp} from ${JSON.stringify(src)};\n${decl}\n`;
         });
         // import Default, { A, B } from '/ns/core[...]'
         const reMixed = /(^|\n)\s*import\s+([A-Za-z_$][\w$]*)\s*,\s*\{([^}]+)\}\s*from\s*["']((?:https?:\/\/[^"']+)?\/ns\/core(?:\/[\d]+)?(?:\?p=[^"']+)?)['"];?\s*/gm;
         result = result.replace(reMixed, (_full, pfx, defName, specList, src) => {
+            if (isDeepCoreSubpath(src))
+                return _full;
             const decl = `const { ${toDestructure(specList)} } = ${defName};`;
             return `${pfx}import ${defName} from ${JSON.stringify(src)};\n${decl}\n`;
         });
@@ -1685,14 +2796,16 @@ function dedupeRtNamedImportsAgainstDestructures(code) {
 /**
  * THE SINGLE REWRITE FUNCTION - used everywhere for consistency
  */
-function rewriteImports(code, importerPath, sfcFileMap, depFileMap, projectRoot, verbose = false, outputDirOverrideRel, httpOrigin) {
+export function rewriteImports(code, importerPath, sfcFileMap, depFileMap, projectRoot, verbose = false, outputDirOverrideRel, httpOrigin, resolveVendorAsHttp = false) {
     let result = code;
     const httpOriginSafe = httpOrigin;
+    const isDynamicImportPrefix = (prefix) => /import\(\s*["']?$/.test(prefix.trimStart());
     const importerDir = path.posix.dirname(importerPath);
     // Determine importer output relative path (project-relative .mjs) to compute relative imports consistently
     const importerOutRel = outputDirOverrideRel || getProjectRelativeImportPath(importerPath, projectRoot) || stripToProjectRelative(importerPath, projectRoot).replace(/\.(ts|js|tsx|jsx|mjs|mts|cts)$/i, '.mjs');
     const importerOutDir = importerOutRel ? path.posix.dirname(importerOutRel) : '';
     const ensureRel = (p) => (p.startsWith('.') ? p : `./${p}`);
+    const isNsSfcSpecifier = (spec) => /^(?:https?:\/\/[^/]+)?\/ns\/sfc(?:\/\d+)?(?:\/|$)/.test(spec.replace(PAT.QUERY_PATTERN, ''));
     // Normalize all @nativescript/core imports to the unified HTTP ESM core bridge to guarantee a single realm on device
     try {
         let coreAliasIdx = 0;
@@ -1835,6 +2948,16 @@ function rewriteImports(code, importerPath, sfcFileMap, depFileMap, projectRoot,
             return `${prefix}${stub}${suffix}`;
         }
         spec = normalizeNativeScriptCoreSpecifier(spec);
+        // Route Vite virtual modules (/@solid-refresh, etc.) through /ns/m/ so their
+        // internal imports (e.g. solid-js) get vendor-rewritten by our pipeline.
+        // Skip known Vite internals (/@vite/, /@id/, /@fs/) which are handled elsewhere.
+        if (spec.startsWith('/@') && !/^\/@(?:vite|id|fs)\//.test(spec)) {
+            const out = `/ns/m${spec}`;
+            if (httpOriginSafe) {
+                return `${prefix}${httpOriginSafe}${out}${suffix}`;
+            }
+            return `${prefix}${out}${suffix}`;
+        }
         // Route internal NS endpoints to absolute HTTP origin for device
         if (spec.startsWith('/ns/')) {
             if (httpOriginSafe) {
@@ -1847,19 +2970,30 @@ function rewriteImports(code, importerPath, sfcFileMap, depFileMap, projectRoot,
         }
         const nodeModulesSpecifier = normalizeNodeModulesSpecifier(spec);
         const candidateNativeScriptSpec = nodeModulesSpecifier ?? spec;
-        const vendorCanonical = resolveVendorFromCandidate(nodeModulesSpecifier ?? spec);
-        if (vendorCanonical) {
-            if (nodeModulesSpecifier) {
-                return `${prefix}${nodeModulesSpecifier.replace(PAT.QUERY_PATTERN, '')}${suffix}`;
-            }
-            return `${prefix}${spec.replace(PAT.QUERY_PATTERN, '')}${suffix}`;
-        }
-        if (isNativeScriptPluginModule(candidateNativeScriptSpec)) {
-            const bareSpecifier = candidateNativeScriptSpec.replace(PAT.QUERY_PATTERN, '');
-            return `${prefix}${bareSpecifier}${suffix}`;
-        }
+        // ── Node modules routing ──────────────────────────────────────
+        // Uses the package's own package.json exports field to determine
+        // whether an import is the main entry (→ vendor bridge) or a
+        // subpath entry (→ HTTP). This replaces the old heuristic-based
+        // approach that tried to guess from file paths.
         if (nodeModulesSpecifier) {
-            return `${prefix}${nodeModulesSpecifier}${suffix}`;
+            const vendorRouting = resolveVendorRouting(nodeModulesSpecifier, projectRoot);
+            if (vendorRouting) {
+                if (vendorRouting.route === 'vendor') {
+                    return `${prefix}${vendorRouting.bareSpec}${suffix}`;
+                }
+                // Vendor package but subpath/platform-specific → HTTP
+                const httpSpec = `/ns/m/node_modules/${nodeModulesSpecifier}`;
+                if (httpOriginSafe) {
+                    return `${prefix}${httpOriginSafe}${httpSpec}${suffix}`;
+                }
+                return `${prefix}${httpSpec}${suffix}`;
+            }
+            // Not a vendor package → serve via HTTP from Vite dev server
+            const httpSpec = `/ns/m/node_modules/${nodeModulesSpecifier}`;
+            if (httpOriginSafe) {
+                return `${prefix}${httpOriginSafe}${httpSpec}${suffix}`;
+            }
+            return `${prefix}${httpSpec}${suffix}`;
         }
         // Handle .vue imports
         if (PAT.VUE_FILE_PATTERN.test(spec)) {
@@ -1916,6 +3050,11 @@ function rewriteImports(code, importerPath, sfcFileMap, depFileMap, projectRoot,
             const baseId = absMaybe ? toAppModuleBaseId(absMaybe, projectRoot) : null; // e.g. /src/foo.mjs
             if (baseId) {
                 const httpSpec = `/ns/m${baseId}`;
+                if (isDynamicImportPrefix(prefix)) {
+                    if (verbose)
+                        console.log(`[rewrite][http] dynamic relative app import → ${httpSpec} (from ${spec})`);
+                    return `__nsDynamicHmrImport(${JSON.stringify(httpSpec)})`;
+                }
                 if (verbose)
                     console.log(`[rewrite][http] relative app import → ${httpSpec} (from ${spec})`);
                 return `${prefix}${httpSpec}${suffix}`;
@@ -1928,6 +3067,11 @@ function rewriteImports(code, importerPath, sfcFileMap, depFileMap, projectRoot,
             const baseId = toAppModuleBaseId(spec, projectRoot);
             if (baseId) {
                 const httpSpec = `/ns/m${baseId}`;
+                if (isDynamicImportPrefix(prefix)) {
+                    if (verbose)
+                        console.log(`[rewrite][http] dynamic app import → ${httpSpec} (from ${spec})`);
+                    return `__nsDynamicHmrImport(${JSON.stringify(httpSpec)})`;
+                }
                 if (verbose)
                     console.log(`[rewrite][http] absolute app import → ${httpSpec} (from ${spec})`);
                 return `${prefix}${httpSpec}${suffix}`;
@@ -1959,6 +3103,10 @@ function rewriteImports(code, importerPath, sfcFileMap, depFileMap, projectRoot,
     result = result.replace(PAT.IMPORT_PATTERN_2, replaceVueImport);
     result = result.replace(PAT.EXPORT_PATTERN, replaceVueImport);
     result = result.replace(PAT.IMPORT_PATTERN_3, replaceVueImport);
+    // Side-effect imports (import "spec") — must run AFTER named-import patterns
+    // since IMPORT_PATTERN_1 already handles `import ... from "spec"`.
+    result = result.replace(PAT.IMPORT_PATTERN_SIDE_EFFECT, replaceVueImport);
+    result = ensureDynamicHmrImportHelper(result);
     // Extra guard: map any lingering dynamic import('@') to a safe stub module path
     // to prevent device runtime normalization errors.
     // Example matched: import('@') or import("@") with optional whitespace before closing paren
@@ -1999,6 +3147,11 @@ function rewriteImports(code, importerPath, sfcFileMap, depFileMap, projectRoot,
     // In HTTP mode, skip legacy local-path rewrite to avoid mixing module origins
     result = result.replace(PAT.VUE_FILE_IMPORT, (_m, p1, spec, p3) => {
         if (httpOrigin) {
+            if (isNsSfcSpecifier(spec)) {
+                if (verbose)
+                    console.log(`[rewrite] .vue already routed (VUE_FILE_IMPORT http): ${spec}`);
+                return `${p1}${spec}${p3}`;
+            }
             // Route via /ns/sfc with full query preserved
             try {
                 let base = spec;
@@ -2064,6 +3217,8 @@ function rewriteImports(code, importerPath, sfcFileMap, depFileMap, projectRoot,
 function createHmrWebSocketPlugin(opts) {
     const verbose = !!opts.verbose;
     let wss = null;
+    let sharedTransformRequest;
+    const pendingAngularReloadSuppressions = new Map();
     const sfcFileMap = new Map();
     const depFileMap = new Map();
     // Generic module manifest (spec -> emitted relative .mjs path)
@@ -2078,6 +3233,22 @@ function createHmrWebSocketPlugin(opts) {
     // Transactional HMR batches: map graphVersion -> ordered list of changed ids for that version
     const txnBatches = new Map();
     const graph = new Map();
+    function rememberAngularReloadSuppression(root, file, ttlMs = 3000) {
+        const absPath = normalizeHotReloadMatchPath(file);
+        const relPath = normalizeHotReloadMatchPath(file, root);
+        pendingAngularReloadSuppressions.set(absPath, {
+            absPath,
+            relPath,
+            expiresAt: Date.now() + ttlMs,
+        });
+    }
+    function pruneAngularReloadSuppressions(now = Date.now()) {
+        for (const [key, entry] of pendingAngularReloadSuppressions) {
+            if (!entry || entry.expiresAt <= now) {
+                pendingAngularReloadSuppressions.delete(key);
+            }
+        }
+    }
     // Compute a dependency-closed, topologically sorted list of modules for a given set of changed ids.
     // Only include application modules we can serve (e.g., under /src and known .vue/.ts/.js entries in the graph).
     function computeTxnOrderForChanged(changedIds) {
@@ -2323,6 +3494,41 @@ function createHmrWebSocketPlugin(opts) {
             const httpServer = server.httpServer;
             if (!httpServer)
                 return;
+            const wsAny = server.ws;
+            if (!wsAny.__NS_ANGULAR_FULL_RELOAD_FILTER_INSTALLED__) {
+                const originalSend = server.ws.send.bind(server.ws);
+                wsAny.__NS_ANGULAR_FULL_RELOAD_FILTER_INSTALLED__ = true;
+                server.ws.send = ((payload, ...rest) => {
+                    pruneAngularReloadSuppressions();
+                    if (shouldSuppressViteFullReloadPayload({
+                        payload,
+                        pendingEntries: pendingAngularReloadSuppressions.values(),
+                        root: pluginRoot,
+                    })) {
+                        if (verbose) {
+                            console.log('[hmr-ws][angular] suppressed vite full-reload payload', payload);
+                        }
+                        return;
+                    }
+                    return originalSend(payload, ...rest);
+                });
+            }
+            // Default to serialized transform execution for deterministic HTTP HMR startup.
+            // Higher fan-out can be re-enabled explicitly via NS_VITE_HMR_TRANSFORM_CONCURRENCY.
+            const configuredTransformConcurrency = Number.parseInt(process.env.NS_VITE_HMR_TRANSFORM_CONCURRENCY || '1', 10);
+            const transformConcurrency = Number.isFinite(configuredTransformConcurrency) && configuredTransformConcurrency > 0 ? configuredTransformConcurrency : 1;
+            const configuredTransformCacheMs = Number.parseInt(process.env.NS_VITE_HMR_TRANSFORM_CACHE_MS || '15000', 10);
+            const transformCacheMs = Number.isFinite(configuredTransformCacheMs) && configuredTransformCacheMs >= 0 ? configuredTransformCacheMs : 15000;
+            sharedTransformRequest = createSharedTransformRequestRunner((url) => server.transformRequest(url), (url, timeoutMs) => {
+                try {
+                    console.warn('[ns:m] slow transformRequest for', url, '(>' + timeoutMs + 'ms)');
+                }
+                catch { }
+            }, {
+                maxConcurrent: transformConcurrency,
+                resultCacheTtlMs: transformCacheMs,
+                getResultCacheKey: (url) => canonicalizeTransformRequestCacheKey(url, pluginRoot),
+            });
             // Attempt early vendor manifest bootstrap once per server.
             if (!vendorBootstrapDone) {
                 vendorBootstrapDone = true;
@@ -2381,6 +3587,40 @@ function createHmrWebSocketPlugin(opts) {
                 }
                 catch { }
             });
+            // Import map endpoint: GET /ns/import-map.json
+            // Returns the import map + runtime config for __nsConfigureRuntime()
+            server.middlewares.use(async (req, res, next) => {
+                try {
+                    const urlObj = new URL(req.url || '', 'http://localhost');
+                    if (urlObj.pathname !== '/ns/import-map.json')
+                        return next();
+                    res.setHeader('Access-Control-Allow-Origin', '*');
+                    res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+                    if (req.method === 'OPTIONS') {
+                        res.statusCode = 204;
+                        res.end();
+                        return;
+                    }
+                    // Determine origin from request headers or server config
+                    const host = req.headers.host || 'localhost:5173';
+                    const protocol = 'http';
+                    const origin = `${protocol}://${host}`;
+                    const runtimeConfig = buildRuntimeConfig({
+                        origin,
+                        flavor: ACTIVE_STRATEGY?.flavor || 'typescript',
+                    });
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({
+                        importMap: JSON.parse(runtimeConfig.importMap),
+                        volatilePatterns: runtimeConfig.volatilePatterns,
+                    }, null, 2));
+                }
+                catch (err) {
+                    console.error('[import-map] error generating import map:', err?.message || err);
+                    res.statusCode = 500;
+                    res.end(JSON.stringify({ error: 'Failed to generate import map' }));
+                }
+            });
             // Dev-only HTTP ESM loader endpoint for device clients
             // 1) Legacy JSON module endpoint (kept temporarily): GET /ns-module?path=/abs -> { path, code, additionalFiles }
             server.middlewares.use(async (req, res, next) => {
@@ -2415,13 +3655,15 @@ function createHmrWebSocketPlugin(opts) {
                     // Transform via Vite with variant resolution (same as ws ns:fetch-module)
                     const hasExt = /\.(ts|tsx|js|jsx|mjs|mts|cts|vue)$/i.test(spec);
                     const baseNoExt = hasExt ? spec.replace(/\.(ts|tsx|js|jsx|mjs|mts|cts)$/i, '') : spec;
+                    const transformRoot = server.config?.root || process.cwd();
                     const candidates = [];
                     if (hasExt)
                         candidates.push(spec);
                     candidates.push(baseNoExt + '.ts', baseNoExt + '.js', baseNoExt + '.tsx', baseNoExt + '.jsx', baseNoExt + '.mjs', baseNoExt + '.mts', baseNoExt + '.cts', baseNoExt + '.vue', baseNoExt + '/index.ts', baseNoExt + '/index.js', baseNoExt + '/index.tsx', baseNoExt + '/index.jsx', baseNoExt + '/index.mjs');
+                    const transformCandidates = filterExistingNodeModulesTransformCandidates(spec, candidates, transformRoot);
                     let transformed = null;
                     let resolvedCandidate = null;
-                    for (const cand of candidates) {
+                    for (const cand of transformCandidates) {
                         try {
                             const r = await server.transformRequest(cand);
                             if (r?.code) {
@@ -2443,7 +3685,10 @@ function createHmrWebSocketPlugin(opts) {
                     code = REQUIRE_GUARD_SNIPPET + code;
                     // Apply same sanitation/rewrite pipeline used for WS path
                     code = cleanCode(code);
-                    code = processCodeForDevice(code, false);
+                    // preserveVendorImports=true: vendor imports stay as bare specifiers
+                    // for the device-side import map (ns-vendor://) instead of being
+                    // transformed to __nsVendorRequire calls with fragile __nsPick lookups.
+                    code = processCodeForDevice(code, false, true, /(?:^|\/)node_modules\//.test(resolvedCandidate || spec), resolvedCandidate || spec);
                     code = rewriteImports(code, spec, sfcFileMap, depFileMap, server.config?.root || process.cwd(), !!verbose, undefined, getServerOrigin(server));
                     code = ensureVariableDynamicImportHelper(code);
                     // Enforce upstream guarantee: no optimized deps or virtual ids remain
@@ -2499,7 +3744,7 @@ function createHmrWebSocketPlugin(opts) {
                             if (seen.has(depBase))
                                 continue;
                             seen.add(depBase);
-                            const depCandidates = [depBase + '.ts', depBase + '.js', depBase + '.tsx', depBase + '.jsx', depBase + '.mjs', depBase + '.mts', depBase + '.cts', depBase + '.vue', depBase + '/index.ts', depBase + '/index.js', depBase + '/index.tsx', depBase + '/index.jsx', depBase + '/index.mjs'];
+                            const depCandidates = filterExistingNodeModulesTransformCandidates(depBase, [depBase + '.ts', depBase + '.js', depBase + '.tsx', depBase + '.jsx', depBase + '.mjs', depBase + '.mts', depBase + '.cts', depBase + '.vue', depBase + '/index.ts', depBase + '/index.js', depBase + '/index.tsx', depBase + '/index.jsx', depBase + '/index.mjs'], transformRoot);
                             let depTrans = null;
                             let depResolved = null;
                             for (const c of depCandidates) {
@@ -2516,7 +3761,7 @@ function createHmrWebSocketPlugin(opts) {
                             if (depTrans?.code && depResolved) {
                                 let depCode = depTrans.code;
                                 depCode = cleanCode(depCode);
-                                depCode = processCodeForDevice(depCode, false);
+                                depCode = processCodeForDevice(depCode, false, true, /(?:^|\/)node_modules\//.test(depResolved), depResolved);
                                 depCode = rewriteImports(depCode, depResolved, sfcFileMap, depFileMap, server.config?.root || process.cwd(), !!verbose, undefined, getServerOrigin(server));
                                 depCode = ensureVariableDynamicImportHelper(depCode);
                                 try {
@@ -2568,6 +3813,7 @@ function createHmrWebSocketPlugin(opts) {
                     let spec = urlObj.searchParams.get('path') || '';
                     // Optional graph version pin for deterministic boot
                     const forcedVer = urlObj.searchParams.get('v');
+                    let bootTaggedRequest = false;
                     if (!spec) {
                         const base = '/ns/m';
                         let rest = urlObj.pathname.slice(base.length);
@@ -2585,22 +3831,36 @@ function createHmrWebSocketPlugin(opts) {
                         res.end('export {}\n');
                         return;
                     }
+                    const serverRoot = (server.config?.root || process.cwd());
                     spec = spec.replace(/[?#].*$/, '');
-                    // Accept path-based HMR cache-busting: /ns/m/__ns_hmr__/<tag>/<real-spec>
+                    // Accept path-based boot/HMR prefixes:
+                    //   /ns/m/__ns_boot__/b1/<real-spec>
+                    //   /ns/m/__ns_hmr__/<tag>/<real-spec>
+                    //   /ns/m/__ns_boot__/b1/__ns_hmr__/<tag>/<real-spec>
                     // The iOS HTTP ESM loader canonicalizes cache keys by stripping query params,
                     // so we must carry the cache-buster in the path.
                     try {
-                        const m = spec.match(/^\/?__ns_hmr__\/[^\/]+(\/.*)?$/);
-                        if (m) {
-                            spec = m[1] || '/';
+                        let changed = true;
+                        while (changed) {
+                            changed = false;
+                            const bootMatch = spec.match(/^\/?__ns_boot__\/[^\/]+(\/.*)?$/);
+                            if (bootMatch) {
+                                bootTaggedRequest = true;
+                                spec = bootMatch[1] || '/';
+                                changed = true;
+                            }
+                            const hmrMatch = spec.match(/^\/?__ns_hmr__\/[^\/]+(\/.*)?$/);
+                            if (hmrMatch) {
+                                spec = hmrMatch[1] || '/';
+                                changed = true;
+                            }
                         }
                     }
                     catch { }
                     // Normalize absolute filesystem paths back to project-relative ids (e.g. /src/app.ts)
                     try {
-                        const projectRoot = (server.config?.root || process.cwd());
                         const toPosix = (p) => p.replace(/\\/g, '/');
-                        const rootPosix = toPosix(projectRoot);
+                        const rootPosix = toPosix(serverRoot);
                         const specPosix = toPosix(spec);
                         // If spec is an absolute path under the project root, convert to '/'+relative
                         const isAbsFs = /^\//.test(specPosix) || /^[A-Za-z]:\//.test(spec); // posix or win drive
@@ -2615,6 +3875,36 @@ function createHmrWebSocketPlugin(opts) {
                         }
                     }
                     catch { }
+                    // Serve Vite virtual modules (/@id/ prefix). These are internal
+                    // virtual modules (e.g., \0nsvite:nsconfig-json for ~/package.json)
+                    // that don't exist on disk. Decode the ID and load via plugin container.
+                    if (spec.startsWith('/@id/')) {
+                        try {
+                            // First try Vite's transform pipeline directly
+                            const vr = await sharedTransformRequest(spec);
+                            if (vr?.code) {
+                                res.statusCode = 200;
+                                res.end(vr.code);
+                                return;
+                            }
+                        }
+                        catch { }
+                        try {
+                            // Fallback: decode the virtual module ID (__x00__ → \0) and
+                            // load through the plugin container directly
+                            const rawId = spec.slice('/@id/'.length).replace(/__x00__/g, '\0');
+                            const loadResult = await server.pluginContainer.load(rawId);
+                            if (loadResult) {
+                                const code = typeof loadResult === 'string' ? loadResult : loadResult.code;
+                                if (code) {
+                                    res.statusCode = 200;
+                                    res.end(code);
+                                    return;
+                                }
+                            }
+                        }
+                        catch { }
+                    }
                     if (spec.startsWith('@/'))
                         spec = APP_VIRTUAL_WITH_SLASH + spec.slice(2);
                     if (spec.startsWith('./'))
@@ -2624,18 +3914,33 @@ function createHmrWebSocketPlugin(opts) {
                     const hasExt = /\.(ts|tsx|js|jsx|mjs|mts|cts|vue)$/i.test(spec);
                     const baseNoExt = hasExt ? spec.replace(/\.(ts|tsx|js|jsx|mjs|mts|cts)$/i, '') : spec;
                     const candidates = [...(hasExt ? [spec] : []), baseNoExt + '.ts', baseNoExt + '.js', baseNoExt + '.tsx', baseNoExt + '.jsx', baseNoExt + '.mjs', baseNoExt + '.mts', baseNoExt + '.cts', baseNoExt + '.vue', baseNoExt + '/index.ts', baseNoExt + '/index.js', baseNoExt + '/index.tsx', baseNoExt + '/index.jsx', baseNoExt + '/index.mjs'];
+                    const transformCandidates = filterExistingNodeModulesTransformCandidates(spec, candidates, serverRoot);
                     let transformed = null;
                     let resolvedCandidate = null;
-                    for (const cand of candidates) {
-                        try {
-                            const r = await server.transformRequest(cand);
-                            if (r?.code) {
-                                transformed = r;
-                                resolvedCandidate = cand;
-                                break;
+                    const rawExplicitModule = tryReadRawExplicitJavaScriptModule(spec, serverRoot);
+                    if (rawExplicitModule) {
+                        transformed = { code: rawExplicitModule.code };
+                        resolvedCandidate = rawExplicitModule.resolvedId;
+                    }
+                    // Queue and dedupe transformRequest calls so heavy app graphs do not
+                    // overwhelm Vite with concurrent work. Slow-transform warnings start only
+                    // when the transform actually begins executing, and requests stay pending
+                    // until Vite returns a real result.
+                    const transformWithTimeout = (url, timeoutMs = 120000) => {
+                        return sharedTransformRequest(url, timeoutMs);
+                    };
+                    if (!transformed?.code) {
+                        for (const cand of transformCandidates) {
+                            try {
+                                const r = await transformWithTimeout(cand);
+                                if (r?.code) {
+                                    transformed = r;
+                                    resolvedCandidate = cand;
+                                    break;
+                                }
                             }
+                            catch { }
                         }
-                        catch { }
                     }
                     // Fallback 1: ask Vite to resolve the id, then transform the resolved id (handles aliases and virtual ids)
                     if (!transformed?.code) {
@@ -2643,7 +3948,7 @@ function createHmrWebSocketPlugin(opts) {
                             const rid = await server.pluginContainer?.resolveId?.(spec, undefined);
                             const ridStr = typeof rid === 'string' ? rid : rid?.id || null;
                             if (ridStr) {
-                                const r = await server.transformRequest(ridStr);
+                                const r = await transformWithTimeout(ridStr);
                                 if (r?.code) {
                                     transformed = r;
                                     resolvedCandidate = ridStr;
@@ -2652,27 +3957,49 @@ function createHmrWebSocketPlugin(opts) {
                         }
                         catch { }
                     }
+                    // Fallback 1b: if spec is a /node_modules/ path, extract bare specifier
+                    // and try resolveId with that. This handles package.json "exports" field
+                    // resolution (e.g., solid-js/jsx-runtime → solid-js/dist/solid.js).
+                    if (!transformed?.code && spec.includes('/node_modules/')) {
+                        try {
+                            const nmIdx = spec.lastIndexOf('/node_modules/');
+                            const bare = spec.slice(nmIdx + '/node_modules/'.length);
+                            if (bare && !bare.startsWith('.')) {
+                                const rid = await server.pluginContainer?.resolveId?.(bare, undefined);
+                                const ridStr = typeof rid === 'string' ? rid : rid?.id || null;
+                                if (ridStr) {
+                                    const r = await sharedTransformRequest(ridStr);
+                                    if (r?.code) {
+                                        transformed = r;
+                                        resolvedCandidate = ridStr;
+                                    }
+                                }
+                            }
+                        }
+                        catch { }
+                    }
                     // Fallback 2: try /@fs absolute path under project root (Vite file system alias)
                     if (!transformed?.code) {
                         try {
-                            const projectRoot = (server.config?.root || process.cwd());
                             const toPosix = (p) => p.replace(/\\/g, '/');
-                            const rootPosix = toPosix(projectRoot).replace(/\/$/, '');
+                            const rootPosix = toPosix(serverRoot).replace(/\/$/, '');
                             const absPosix = `${rootPosix}${spec.startsWith('/') ? '' : '/'}${spec}`;
                             const fsId = `/@fs${absPosix}`;
-                            const r = await server.transformRequest(fsId);
-                            if (r?.code) {
-                                transformed = r;
-                                resolvedCandidate = fsId;
+                            if (resolveCandidateFilePath(fsId, serverRoot)) {
+                                const r = await transformWithTimeout(fsId);
+                                if (r?.code) {
+                                    transformed = r;
+                                    resolvedCandidate = fsId;
+                                }
                             }
                         }
                         catch { }
                     }
                     // Fallback 3: try adding ?import to hint Vite's transform pipeline
                     if (!transformed?.code) {
-                        for (const cand of candidates) {
+                        for (const cand of transformCandidates) {
                             try {
-                                const r = await server.transformRequest(`${cand}${cand.includes('?') ? '&' : '?'}import`);
+                                const r = await transformWithTimeout(`${cand}${cand.includes('?') ? '&' : '?'}import`);
                                 if (r?.code) {
                                     transformed = r;
                                     resolvedCandidate = `${cand}?import`;
@@ -2682,39 +4009,67 @@ function createHmrWebSocketPlugin(opts) {
                             catch { }
                         }
                     }
-                    // Post-transform: inject cache-busting version for all internal /ns/m/* imports to avoid stale module reuse on device.
-                    // IMPORTANT: use PATH-based busting (not query) because the iOS HTTP ESM loader strips query params
-                    // when computing module cache keys.
+                    // Solid HMR: patch @@solid-refresh's $$refreshESM to do inline patching
+                    // during module re-evaluation instead of deferring to hot.accept() callback.
+                    // In NativeScript's HTTP ESM environment, accept callbacks are registered
+                    // but not invoked by the HMR client. By adding a direct patchRegistry()
+                    // call when hot.data already has a stored registry, component updates
+                    // apply immediately when the module re-evaluates.
                     try {
-                        if (transformed?.code) {
-                            const ver = Number(global.graphVersion || graphVersion || 0);
-                            let code = transformed.code;
-                            const prefix = `/ns/m/__ns_hmr__/v${ver}`;
-                            const rewrite = (p) => {
-                                try {
-                                    if (!p || typeof p !== 'string')
-                                        return p;
-                                    if (!p.startsWith('/ns/m/'))
-                                        return p;
-                                    if (p.startsWith('/ns/m/__ns_hmr__/'))
-                                        return p;
-                                    return prefix + p.slice('/ns/m'.length);
+                        if (transformed?.code && ACTIVE_STRATEGY?.flavor === 'solid' && (resolvedCandidate || spec || '').includes('@solid-refresh')) {
+                            const PATCH_SENTINEL = '/* __ns_solid_refresh_patched__ */';
+                            const alreadyPatched = transformed.code.includes(PATCH_SENTINEL);
+                            console.log('[hmr-ws][solid] @solid-refresh patch check:', { spec: resolvedCandidate || spec, alreadyPatched, codeLen: transformed.code.length });
+                            if (!alreadyPatched) {
+                                let patchedCode = transformed.code;
+                                // Patch 1: Bypass shouldWarnAndDecline() — the vendor-bundled solid-js
+                                // may not have the 'development' condition active, making DEV empty/undefined.
+                                // In NativeScript HMR mode we are always in dev, so force it to return false.
+                                const declineCheck = 'function shouldWarnAndDecline() {';
+                                if (patchedCode.includes(declineCheck)) {
+                                    patchedCode = patchedCode.replace(declineCheck, `${PATCH_SENTINEL}\nfunction shouldWarnAndDecline() { return false; /* NS HMR: always allow refresh */ }\nfunction __original_shouldWarnAndDecline() {`);
+                                    console.log('[hmr-ws][solid] bypassed shouldWarnAndDecline() for NativeScript HMR');
                                 }
-                                catch {
-                                    return p;
+                                // Patch 2: Force createMemo path in createProxy.
+                                // Without the 'development' condition, $DEVCOMP is not set on components,
+                                // so createProxy falls through to `return s(props)` — a direct call with
+                                // no reactive subscription. When patchComponent fires update() (the signal
+                                // setter), nobody is listening. By forcing the createMemo path, HMRComp
+                                // subscribes to the signal and re-renders when the component changes.
+                                const proxyCondition = 'if (!s || $DEVCOMP in s) {';
+                                if (patchedCode.includes(proxyCondition)) {
+                                    patchedCode = patchedCode.replace(proxyCondition, 'if (true) { /* NS HMR: always use createMemo for reactive HMR updates */');
+                                    console.log('[hmr-ws][solid] forced createMemo path in createProxy for NativeScript HMR');
                                 }
-                            };
-                            // 1) Static imports: import ... from "/ns/m/..."
-                            code = code.replace(/(from\s*["'])(\/ns\/m\/[^"'?]+)(["'])/g, (_m, a, p, b) => `${a}${rewrite(p)}${b}`);
-                            // 2) Side-effect imports: import "/ns/m/..."
-                            code = code.replace(/(import\s*(?!\()\s*["'])(\/ns\/m\/[^"'?]+)(["'])/g, (_m, a, p, b) => `${a}${rewrite(p)}${b}`);
-                            // 3) Dynamic imports: import("/ns/m/...")
-                            code = code.replace(/(import\(\s*["'])(\/ns\/m\/[^"'?]+)(["']\s*\))/g, (_m, a, p, b) => `${a}${rewrite(p)}${b}`);
-                            // 4) new URL("/ns/m/...", import.meta.url)
-                            code = code.replace(/(new\s+URL\(\s*["'])(\/ns\/m\/[^"'?]+)(["']\s*,\s*import\.meta\.url\s*\))/g, (_m, a, p, b) => `${a}${rewrite(p)}${b}`);
-                            // 5) __ns_import(new URL('/ns/m/...', import.meta.url).href)
-                            code = code.replace(/(new\s+URL\(\s*["'])(\/ns\/m\/[^"'?]+)(["']\s*,\s*import\.meta\.url\s*\)\.href)/g, (_m, a, p, b) => `${a}${rewrite(p)}${b}`);
-                            transformed.code = code;
+                                // Patch 3: Inline patchRegistry call so updates apply immediately
+                                // on module re-evaluation (accept callbacks are not invoked by the HMR client).
+                                const marker = 'hot.data[SOLID_REFRESH] = hot.data[SOLID_REFRESH] || registry;';
+                                if (patchedCode.includes(marker)) {
+                                    const patchCode = [
+                                        `console.log('[solid-refresh][$$refreshESM] hot.data keys=', hot.data ? Object.keys(hot.data) : 'no-data', 'has=', !!(hot.data && hot.data[SOLID_REFRESH]));`,
+                                        `if (hot.data[SOLID_REFRESH]) {`,
+                                        `  console.log('[solid-refresh][$$refreshESM] patching: oldComponents=', hot.data[SOLID_REFRESH].components ? hot.data[SOLID_REFRESH].components.size : 0, 'newComponents=', registry.components ? registry.components.size : 0);`,
+                                        `  var _shouldInvalidate = patchRegistry(hot.data[SOLID_REFRESH], registry);`,
+                                        `  console.log('[solid-refresh][$$refreshESM] patchRegistry result: shouldInvalidate=', _shouldInvalidate);`,
+                                        `} else {`,
+                                        `  console.log('[solid-refresh][$$refreshESM] first load — creating registry, components=', registry.components ? registry.components.size : 0);`,
+                                        `}`,
+                                    ].join('\n    ');
+                                    patchedCode = patchedCode.replace(marker, `${patchCode}\n    ${marker}`);
+                                    console.log('[hmr-ws][solid] added inline patchRegistry for NativeScript HMR');
+                                }
+                                // Work on a copy to avoid mutating Vite's cached TransformResult
+                                transformed = { ...transformed, code: patchedCode };
+                            }
+                        }
+                    }
+                    catch { }
+                    // NOTE: Path-based cache busting for /ns/m/* imports is applied in the
+                    // finalize step below (after rewriteImports adds the /ns/m/ prefix).
+                    // The block here only handles TypeScript-specific graph population.
+                    try {
+                        if (transformed?.code) {
+                            const code = transformed.code;
                             // TypeScript-specific graph population: when TS flavor is active
                             // and this is an application module under the virtual app root,
                             // upsert it into the HMR graph so ns:hmr-full-graph is non-empty.
@@ -2843,7 +4198,7 @@ export const piniaSymbol = p.piniaSymbol;
                         if (!transformed?.code) {
                             // Emit a module that throws with context for easier on-device debugging
                             try {
-                                const tried = Array.from(new Set(candidates)).slice(0, 12);
+                                const tried = Array.from(new Set(transformCandidates.length > 0 ? transformCandidates : candidates)).slice(0, 12);
                                 const out = `// [ns:m] transform miss path=${spec} tried=${tried.length}\n` + `throw new Error(${JSON.stringify(`[ns/m] transform failed for ${spec} (tried ${tried.length} candidates).`)});\nexport {};\n`;
                                 res.statusCode = 404;
                                 res.end(out);
@@ -2860,8 +4215,36 @@ export const piniaSymbol = p.piniaSymbol;
                     // Prepend guard to capture any URL-based require attempts
                     code = REQUIRE_GUARD_SNIPPET + code;
                     code = cleanCode(code);
-                    code = processCodeForDevice(code, false);
-                    code = rewriteImports(code, resolvedCandidate || spec, sfcFileMap, depFileMap, server.config?.root || process.cwd(), !!verbose, undefined, getServerOrigin(server));
+                    const isNodeMod = /(?:^|\/)node_modules\//.test(resolvedCandidate || spec || '');
+                    code = processCodeForDevice(code, false, true, isNodeMod, resolvedCandidate || spec);
+                    // Solid HMR: The NativeScript iOS/Android runtime provides import.meta.hot
+                    // natively (via InitializeImportMetaHot in HMRSupport.mm) with C++-backed
+                    // persistent hot.data that survives across module re-evaluations.
+                    // cleanCode() strips Vite's __vite__createHotContext assignment, which is
+                    // correct — the runtime's native hot context is better.
+                    // We inject a diagnostic log to trace hot.data state during development.
+                    try {
+                        if (ACTIVE_STRATEGY?.flavor === 'solid' && /\.(tsx|jsx)$/i.test(resolvedCandidate || spec)) {
+                            const moduleId = (resolvedCandidate || spec).replace(/[?#].*$/, '');
+                            // Diagnostic: log import.meta.hot state on device to trace solid-refresh flow
+                            code = `try{if(typeof import.meta!=='undefined'&&import.meta.hot){var _hd=import.meta.hot.data;var _sr=_hd&&_hd['solid-refresh'];console.log('[solid-hmr][native-hot]',${JSON.stringify(moduleId)},'hasHot=true','hasData=',!!_hd,'hasSolidRefresh=',!!_sr,'dataKeys=',_hd?Object.keys(_hd):[]);}else{console.log('[solid-hmr][native-hot]',${JSON.stringify(moduleId)},'hasHot=',!!(typeof import.meta!=='undefined'&&import.meta.hot));}}catch(e){console.log('[solid-hmr][native-hot] error',e);}\n` + code;
+                            console.log('[hmr-ws][solid] diagnostic injected for', moduleId, '(using runtime native import.meta.hot)');
+                        }
+                    }
+                    catch { }
+                    code = rewriteImports(code, resolvedCandidate || spec, sfcFileMap, depFileMap, server.config?.root || process.cwd(), !!verbose, undefined, getServerOrigin(server), true);
+                    // Expand `export * from "url"` into explicit named re-exports.
+                    // NativeScript's HTTP ESM loader may not propagate star-re-exports across
+                    // HTTP module boundaries (the namespace object gets direct exports but
+                    // misses re-exported names). By expanding to `export { a, b } from "url"`,
+                    // the engine sees explicit named exports and resolves them correctly.
+                    try {
+                        code = await expandStarExports(code, server, server.config?.root || process.cwd(), verbose);
+                    }
+                    catch (e) {
+                        if (verbose)
+                            console.warn('[ns/m] export* expansion failed:', e?.message);
+                    }
                     // Dedupe any /ns/rt named imports that duplicate destructured bindings off default /ns/rt
                     try {
                         code = dedupeRtNamedImportsAgainstDestructures(code);
@@ -2888,6 +4271,28 @@ export const piniaSymbol = p.piniaSymbol;
                         }
                     }
                     catch { }
+                    // Final pass: deduplicate/resolve any bare-specifier imports that slipped
+                    // through the pipeline (e.g., extracted from JSDoc comments by import-splitting
+                    // regexes, or injected by the Angular linker on already-resolved code).
+                    try {
+                        code = deduplicateLinkerImports(code);
+                    }
+                    catch { }
+                    // CJS/UMD wrapping: if a module uses module.exports but has no ESM export default,
+                    // wrap it with CJS shims so the device HTTP ESM loader can consume it.
+                    // This handles npm packages that use CommonJS but aren't pre-bundled by Vite.
+                    //
+                    // Key constraints this must handle:
+                    //  - CJS modules often declare local vars with the same names as their exports
+                    //    (e.g. `function createLTTB() {...}; exports.createLTTB = createLTTB;`)
+                    //    so `export var { createLTTB }` would cause a duplicate declaration.
+                    //  - UMD modules reference `this` at top level (undefined in ESM) but
+                    //    typically fall back to `self` or `globalThis`.
+                    //  - `module`, `exports` must be shims since they don't exist in ESM.
+                    try {
+                        code = wrapCommonJsModuleForDevice(code);
+                    }
+                    catch { }
                     try {
                         assertNoOptimizedArtifacts(code, `NS M ${resolvedCandidate || spec}`);
                     }
@@ -2914,23 +4319,37 @@ export const piniaSymbol = p.piniaSymbol;
                         code = ensureVersionedCoreImports(code, getServerOrigin(server), verNum);
                     }
                     catch { }
-                    // Finalize: also stamp all internal /ns/m imports with ?v=<ver> after all rewrites
+                    // Finalize: stamp all internal /ns/m imports with PATH-based cache busting.
+                    // IMPORTANT: use path prefix (not ?v= query) because the iOS HTTP ESM loader
+                    // strips query params when computing module cache keys, so ?v= doesn't bust the V8 cache.
                     try {
                         const ver = String(forcedVer || graphVersion || 0);
                         const origin = getServerOrigin(server);
+                        const hmrPrefix = `/ns/m/__ns_hmr__/v${ver}`;
+                        const bootHmrPrefix = `/ns/m/__ns_boot__/b1/__ns_hmr__/v${ver}`;
+                        const rewritePath = (p) => {
+                            if (!p || !p.startsWith('/ns/m/'))
+                                return p;
+                            if (p.startsWith('/ns/m/__ns_boot__/'))
+                                return p;
+                            if (p.startsWith('/ns/m/__ns_hmr__/')) {
+                                return bootTaggedRequest ? `/ns/m/__ns_boot__/b1${p.slice('/ns/m'.length)}` : p;
+                            }
+                            return (bootTaggedRequest ? bootHmrPrefix : hmrPrefix) + p.slice('/ns/m'.length);
+                        };
                         // 1) Static imports: import ... from "/ns/m/..."
-                        code = code.replace(/(from\s*["'])(\/ns\/m\/[^"'?]+)(["'])/g, `$1$2?v=${ver}$3`);
+                        code = code.replace(/(from\s*["'])(\/ns\/m\/[^"'?]+)(["'])/g, (_m, a, p, b) => `${a}${rewritePath(p)}${b}`);
                         // 2) Side-effect imports: import "/ns/m/..."
-                        code = code.replace(/(import\s*(?!\()\s*["'])(\/ns\/m\/[^"'?]+)(["'])/g, `$1$2?v=${ver}$3`);
+                        code = code.replace(/(import\s*(?!\()\s*["'])(\/ns\/m\/[^"'?]+)(["'])/g, (_m, a, p, b) => `${a}${rewritePath(p)}${b}`);
                         // 3) Dynamic imports: import("/ns/m/...")
-                        code = code.replace(/(import\(\s*["'])(\/ns\/m\/[^"'?]+)(["']\s*\))/g, `$1$2?v=${ver}$3`);
+                        code = code.replace(/(import\(\s*["'])(\/ns\/m\/[^"'?]+)(["']\s*\))/g, (_m, a, p, b) => `${a}${rewritePath(p)}${b}`);
                         // 4) new URL("/ns/m/...", import.meta.url)
-                        code = code.replace(/(new\s+URL\(\s*["'])(\/ns\/m\/[^"'?]+)(["']\s*,\s*import\.meta\.url\s*\))/g, `$1$2?v=${ver}$3`);
+                        code = code.replace(/(new\s+URL\(\s*["'])(\/ns\/m\/[^"'?]+)(["']\s*,\s*import\.meta\.url\s*\))/g, (_m, a, p, b) => `${a}${rewritePath(p)}${b}`);
                         // 5) __ns_import(new URL('/ns/m/...', import.meta.url).href)
-                        code = code.replace(/(new\s+URL\(\s*["'])(\/ns\/m\/[^"'?]+)(["']\s*,\s*import\.meta\.url\s*\)\.href)/g, `$1$2?v=${ver}$3`);
-                        // 6) Force absolute HTTP for new URL('/ns/m/...', import.meta.url).href → "${origin}/ns/m/..."
+                        code = code.replace(/(new\s+URL\(\s*["'])(\/ns\/m\/[^"'?]+)(["']\s*,\s*import\.meta\.url\s*\)\.href)/g, (_m, a, p, b) => `${a}${rewritePath(p)}${b}`);
+                        // 6) Force absolute HTTP for new URL('/ns/m/...', import.meta.url).href → "${origin}/ns/m/__ns_hmr__/..."
                         try {
-                            code = code.replace(/new\s+URL\(\s*["'](\/ns\/m\/[^"'?]+)(?:\?[^"']*)?["']\s*,\s*import\.meta\.url\s*\)\.href/g, (_m, p1) => `${JSON.stringify(`${origin}${p1}?v=${ver}`)}`);
+                            code = code.replace(/new\s+URL\(\s*["'](\/ns\/m\/[^"'?]+)(?:\?[^"']*)?["']\s*,\s*import\.meta\.url\s*\)\.href/g, (_m, p1) => `${JSON.stringify(`${origin}${rewritePath(p1)}`)}`);
                         }
                         catch { }
                         // 7) Also fix SFC new URL('/ns/sfc/...', import.meta.url).href → "${origin}/ns/sfc/<ver>/..."
@@ -2946,13 +4365,25 @@ export const piniaSymbol = p.piniaSymbol;
                         code = ensureDestructureCoreImports(code);
                     }
                     catch { }
+                    // Boot-time module graph progress: while the app is still replacing the
+                    // placeholder, emit lightweight progress updates as /ns/m modules begin
+                    // evaluating. This keeps the overlay moving during large initial graphs.
+                    try {
+                        if (bootTaggedRequest) {
+                            const bootModuleLabel = String(spec || '').replace(/\\/g, '/');
+                            const bootProgressSnippet = buildBootProgressSnippet(bootModuleLabel);
+                            code = bootProgressSnippet + code;
+                            code = hoistTopLevelStaticImports(code);
+                        }
+                    }
+                    catch { }
                     // Dev-only: link-check static imports to surface missing bindings early
                     try {
                         const devCheck = process.env.NODE_ENV !== 'production';
                         if (devCheck) {
                             const ast = babelParse(code, {
                                 sourceType: 'module',
-                                plugins: ['typescript', 'importMeta'],
+                                plugins: MODULE_IMPORT_ANALYSIS_PLUGINS,
                             });
                             const imports = [];
                             babelTraverse(ast, {
@@ -3036,6 +4467,16 @@ export const piniaSymbol = p.piniaSymbol;
                                         continue;
                                     const hasDefault = /\bexport\s+default\b/.test(targetCode) || /export\s*\{\s*default\s*(?:as\s*default)?\s*\}/.test(targetCode);
                                     if (!hasDefault) {
+                                        // CJS/UMD modules won't have `export default` — they get CJS-wrapped
+                                        // by the serving pipeline. Only warn, don't fatally block the importer.
+                                        const hasCjsPattern = /\bmodule\s*\.\s*exports\b/.test(targetCode) || /\bexports\s*\.\s*\w/.test(targetCode);
+                                        if (hasCjsPattern) {
+                                            try {
+                                                console.warn(`[ns:m][link-check] CJS module without export default: ${u.pathname} (will be CJS-wrapped at serve time)`);
+                                            }
+                                            catch { }
+                                            continue;
+                                        }
                                         const msg = `[link-check] Missing default export in ${u.pathname}${u.search} (imported by ${resolvedCandidate || spec})`;
                                         // Emit a module that throws to surface the exact offender
                                         res.statusCode = 200;
@@ -3052,6 +4493,16 @@ export const piniaSymbol = p.piniaSymbol;
                         }
                         catch { }
                     }
+                    // Diagnostic: dump served code to terminal when ?__diag=1 is in the original URL
+                    try {
+                        if (urlObj?.searchParams?.get('__diag') === '1') {
+                            const specId = resolvedCandidate || spec;
+                            console.log(`\n${'='.repeat(80)}\n[ns:m][DIAG] ${specId}\n${'='.repeat(80)}`);
+                            console.log(code);
+                            console.log(`${'='.repeat(80)}\n[ns:m][DIAG] END ${specId}\n${'='.repeat(80)}\n`);
+                        }
+                    }
+                    catch { }
                     res.statusCode = 200;
                     res.end(code);
                 }
@@ -3251,17 +4702,59 @@ export const piniaSymbol = p.piniaSymbol;
             server.middlewares.use(async (req, res, next) => {
                 try {
                     const urlObj = new URL(req.url || '', 'http://localhost');
-                    if (!(urlObj.pathname === '/ns/core' || /^\/ns\/core\/[\d]+$/.test(urlObj.pathname)))
+                    // Match /ns/core, /ns/core/<ver>, and /ns/core/<subpath> (path-based deep imports)
+                    if (!urlObj.pathname.startsWith('/ns/core'))
                         return next();
                     res.setHeader('Access-Control-Allow-Origin', '*');
                     res.setHeader('Content-Type', 'application/javascript; charset=utf-8');
                     res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0');
                     res.setHeader('Pragma', 'no-cache');
                     res.setHeader('Expires', '0');
-                    const verSeg = urlObj.pathname.replace(/^\/ns\/core\/?/, '');
-                    const ver = /^[0-9]+$/.test(verSeg) ? verSeg : String(graphVersion || 0);
-                    const sub = urlObj.searchParams.get('p') || '';
+                    const afterCore = urlObj.pathname.replace(/^\/ns\/core\/?/, '');
+                    const hasExplicitVersion = /^[0-9]+$/.test(afterCore);
+                    const ver = /^[0-9]+$/.test(afterCore) ? afterCore : String(graphVersion || 0);
+                    // Support both query-based (?p=data/observable/index.js) and
+                    // path-based (/ns/core/data/observable/index.js) subpath formats.
+                    // The device's HTTP ESM loader may use either depending on the import map.
+                    const sub = urlObj.searchParams.get('p') || (afterCore && !/^[0-9]+$/.test(afterCore) ? afterCore : '');
                     const key = sub ? `@nativescript/core/${sub}` : `@nativescript/core`;
+                    // Any @nativescript/core subpath import (including shallow ones like
+                    // `utils`) may expose exports that are not available from the root
+                    // vendor bundle namespace. Serve the actual transformed module content
+                    // instead of the lightweight proxy bridge.
+                    if (sub) {
+                        try {
+                            const normalizedSub = sub.replace(/^\/+/, '');
+                            if (!hasExplicitVersion) {
+                                res.statusCode = 200;
+                                res.end(buildVersionedCoreSubpathAliasModule(normalizedSub, ver));
+                                return;
+                            }
+                            const coreSpecifier = `@nativescript/core/${normalizedSub}`;
+                            const resolved = await server.pluginContainer?.resolveId?.(coreSpecifier, undefined);
+                            const resolvedId = typeof resolved === 'string' ? resolved : resolved?.id || null;
+                            const modulePath = resolvedId || `/node_modules/@nativescript/core/${normalizedSub}`;
+                            const transformed = await sharedTransformRequest(modulePath);
+                            if (transformed?.code) {
+                                // Minimal pipeline: Vite already produces correct ESM.
+                                // ONLY rewrite specifier strings to device-fetchable URLs.
+                                // Do NOT run processCodeForDevice, rewriteImports, or any
+                                // other heavy transform — those mangle newlines, eat exports,
+                                // and cause cascading "does not provide an export" failures.
+                                const moduleCode = rewriteSpecifiersForDevice(transformed.code, getServerOrigin(server), Number(ver));
+                                res.statusCode = 200;
+                                res.end(moduleCode);
+                                return;
+                            }
+                        }
+                        catch (e) {
+                            try {
+                                console.warn('[ns-core-bridge] deep subpath serve failed:', sub, e?.message);
+                            }
+                            catch { }
+                        }
+                    }
+                    // Main entry or shallow subpath: use proxy bridge
                     // HTTP-only core bridge: do NOT use require/createRequire. Export a proxy that maps
                     // property access to globalThis first, then to any available vendor registry module.
                     let code = REQUIRE_GUARD_SNIPPET +
@@ -3269,7 +4762,7 @@ export const piniaSymbol = p.piniaSymbol;
                         `const g = globalThis;\n` +
                         `const reg = (g.__nsVendorRegistry ||= new Map());\n` +
                         `const __getVendorCore = () => { try { const m = reg && reg.get ? (reg.get(${JSON.stringify(key)}) || reg.get('@nativescript/core')) : null; return (m && (m.__esModule && m.default ? m.default : (m.default || m))) || m || null; } catch { return null; } };\n` +
-                        `const __core = new Proxy({}, { get(_t, p){ if (p === 'default') return __core; if (p === Symbol.toStringTag) return 'Module'; try { const v = g[p]; if (v !== undefined) return v; } catch {} try { const vc = __getVendorCore(); return vc ? vc[p] : undefined; } catch {} return undefined; } });\n` +
+                        `const __core = new Proxy({}, { get(_t, p){ if (p === 'default') return __core; if (p === Symbol.toStringTag) return 'Module'; try { const vc = __getVendorCore(); if (vc) { const vv = vc[p]; if (vv !== undefined) return vv; } } catch {} try { const v = g[p]; if (v !== undefined) return v; } catch {} return undefined; } });\n` +
                         `// Default export: namespace-like proxy\n` +
                         `export default __core;\n`;
                     res.statusCode = 200;
@@ -3300,18 +4793,40 @@ export const piniaSymbol = p.piniaSymbol;
                     res.setHeader('Expires', '0');
                     let content = '';
                     try {
-                        const req = createRequire(import.meta.url);
-                        const entryRtPath = req.resolve('@nativescript/vite/hmr/entry-runtime.js');
-                        const fs = req('fs');
-                        content = fs.readFileSync(entryRtPath, 'utf-8');
+                        const _req = createRequire(import.meta.url);
+                        const entryRtPath = _req.resolve('@nativescript/vite/hmr/entry-runtime.js');
+                        content = readFileSync(entryRtPath, 'utf-8');
                     }
                     catch (e) {
-                        content = 'export default async function start(){ console.error("[/ns/entry-rt] not found"); }\n';
+                        // .js not found (source tree without build) — transform .ts on the fly
+                        try {
+                            const tsPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', 'entry-runtime.ts');
+                            if (existsSync(tsPath)) {
+                                const tsSource = readFileSync(tsPath, 'utf-8');
+                                const result = babelCore.transformSync(tsSource, {
+                                    filename: tsPath,
+                                    plugins: [[pluginTransformTypescript, { isTSX: false, allowDeclareFields: true }]],
+                                    sourceType: 'module',
+                                });
+                                if (result?.code) {
+                                    content = result.code;
+                                }
+                            }
+                        }
+                        catch (e2) {
+                            if (verbose)
+                                console.warn('[hmr-http] entry-runtime.ts transform failed', e2);
+                        }
+                        if (!content) {
+                            content = 'export default async function start(){ console.error("[/ns/entry-rt] not found"); }\n';
+                        }
                     }
+                    console.log('[hmr-http] /ns/entry-rt serving', content.length, 'bytes');
                     res.statusCode = 200;
                     res.end(content);
                 }
                 catch (e) {
+                    console.warn('[hmr-http] /ns/entry-rt error', e);
                     next();
                 }
             });
@@ -3741,7 +5256,7 @@ export const piniaSymbol = p.piniaSymbol;
                             code = outCode;
                         }
                         catch { }
-                        code = processCodeForDevice(code, false);
+                        code = processCodeForDevice(code, false, true, /(?:^|\/)node_modules\//.test(fullSpec), fullSpec);
                         // Transform static .vue imports into static imports from the assembler (no TLA) via AST
                         try {
                             const importerPath = fullSpec.replace(/[?#].*$/, '');
@@ -4297,7 +5812,7 @@ export const piniaSymbol = p.piniaSymbol;
                             parts.push(`export function render(){ const f = (typeof __ns_getRender==='function' ? __ns_getRender() : (__ns_sfc__ && __ns_sfc__.render)); return typeof f==='function' ? f.apply(this, arguments) : undefined; }`);
                             parts.push(`export default __ns_sfc__`);
                             let inlineCode = parts.filter(Boolean).join('\n');
-                            inlineCode = processCodeForDevice(inlineCode, false);
+                            inlineCode = processCodeForDevice(inlineCode, false, true);
                             try {
                                 inlineCode = ensureVersionedCoreImports(inlineCode, getServerOrigin(server), Number(ver));
                             }
@@ -4377,7 +5892,7 @@ export const piniaSymbol = p.piniaSymbol;
                                 outParts.push('export function render(){ const f = (typeof __ns_getRender==="function" ? __ns_getRender() : (typeof __ns_render==="function" ? __ns_render : (__ns_sfc__ && __ns_sfc__.render))); return typeof f === "function" ? f.apply(this, arguments) : undefined; }');
                                 outParts.push('export default __ns_sfc__');
                                 let inlineCode2 = outParts.filter(Boolean).join('\n');
-                                inlineCode2 = processCodeForDevice(inlineCode2, false);
+                                inlineCode2 = processCodeForDevice(inlineCode2, false, true);
                                 try {
                                     inlineCode2 = ensureVersionedCoreImports(inlineCode2, getServerOrigin(server), Number(ver));
                                 }
@@ -4689,7 +6204,7 @@ export const piniaSymbol = p.piniaSymbol;
                     }
                     // Run full device processing so helper aliasing and globals are consistent in this path too
                     let code = REQUIRE_GUARD_SNIPPET + asm;
-                    code = processCodeForDevice(code, false);
+                    code = processCodeForDevice(code, false, true, /(?:^|\/)node_modules\//.test(base), base);
                     try {
                         code = ensureVersionedCoreImports(code, getServerOrigin(server), Number(ver));
                     }
@@ -4862,7 +6377,7 @@ export const piniaSymbol = p.piniaSymbol;
                                     let code = transformed.code;
                                     // Reuse existing sanitation chain (lightweight)
                                     code = cleanCode(code);
-                                    code = processCodeForDevice(code, false);
+                                    code = processCodeForDevice(code, false, true, /(?:^|\/)node_modules\//.test(resolvedCandidate || spec), resolvedCandidate || spec);
                                     try {
                                         code = ensureVersionedCoreImports(code, getServerOrigin(server), graphVersion);
                                     }
@@ -4917,7 +6432,7 @@ export const piniaSymbol = p.piniaSymbol;
                                             if (depTrans?.code && depResolved) {
                                                 let depCode = depTrans.code;
                                                 depCode = cleanCode(depCode);
-                                                depCode = processCodeForDevice(depCode, false);
+                                                depCode = processCodeForDevice(depCode, false, true, /(?:^|\/)node_modules\//.test(depResolved), depResolved);
                                                 try {
                                                     depCode = ensureVersionedCoreImports(depCode, getServerOrigin(server), graphVersion);
                                                 }
@@ -4990,32 +6505,33 @@ export const piniaSymbol = p.piniaSymbol;
                     if (verbose)
                         console.warn('[hmr-ws][graph] initial population failed', e);
                 }
-                // Send SFC registry on first connection
-                if (!registrySent) {
-                    try {
-                        await ACTIVE_STRATEGY.buildRegistry({
-                            server,
-                            sfcFileMap,
-                            depFileMap,
-                            wss: wss,
-                            verbose,
-                            helpers: {
-                                cleanCode,
-                                collectImportDependencies,
-                                isCoreGlobalsReference,
-                                isNativeScriptCoreModule,
-                                isNativeScriptPluginModule,
-                                resolveVendorFromCandidate,
-                                createHash: (value) => createHash('md5').update(value).digest('hex'),
-                                rewriteImports,
-                                processSfcCode,
-                            },
-                        });
-                        registrySent = true;
-                    }
-                    catch (error) {
-                        console.warn('[hmr-ws] Failed to send registry:', error);
-                    }
+                // Send SFC registry on every connection (not just the first).
+                // When the NativeScript app restarts (e.g. CLI auto-reload), the new
+                // JS context has an empty sfcArtifactMap. Without the registry the
+                // rescue-mount cannot find the root .vue component.
+                try {
+                    await ACTIVE_STRATEGY.buildRegistry({
+                        server,
+                        sfcFileMap,
+                        depFileMap,
+                        wss: wss,
+                        verbose,
+                        helpers: {
+                            cleanCode,
+                            collectImportDependencies,
+                            isCoreGlobalsReference,
+                            isNativeScriptCoreModule,
+                            isNativeScriptPluginModule,
+                            resolveVendorFromCandidate,
+                            createHash: (value) => createHash('md5').update(value).digest('hex'),
+                            rewriteImports,
+                            processSfcCode,
+                        },
+                    });
+                    registrySent = true;
+                }
+                catch (error) {
+                    console.warn('[hmr-ws] Failed to send registry:', error);
                 }
                 emitFullGraph(ws);
                 // After sending registry & graph also send current module manifest if any
@@ -5040,14 +6556,30 @@ export const piniaSymbol = p.piniaSymbol;
             }
             // Graph update for this file change (wrapped to avoid aborting rest of handler)
             try {
-                const mod = server.moduleGraph.getModuleById(file) || server.moduleGraph.getModuleById(file + '?vue');
-                if (mod) {
-                    const deps = Array.from(mod.importedModules)
-                        .map((m) => (m.id || '').replace(/\?.*$/, ''))
-                        .filter(Boolean);
-                    const transformed = await server.transformRequest(mod.id);
-                    const code = transformed?.code || '';
-                    upsertGraphModule((mod.id || '').replace(/\?.*$/, ''), code, deps);
+                const skipAngularHtmlGraphUpdate = ACTIVE_STRATEGY.flavor === 'angular' && /\.(html|htm)$/i.test(file);
+                if (!skipAngularHtmlGraphUpdate) {
+                    const graphTargets = collectGraphUpdateModulesForHotUpdate({
+                        file,
+                        flavor: ACTIVE_STRATEGY.flavor,
+                        modules: ctx.modules,
+                        getModuleById: (id) => server.moduleGraph.getModuleById(id),
+                    });
+                    for (const mod of graphTargets) {
+                        if (!mod?.id)
+                            continue;
+                        try {
+                            const deps = Array.from(mod.importedModules || [])
+                                .map((m) => (m.id || '').replace(/\?.*$/, ''))
+                                .filter(Boolean);
+                            const transformed = await server.transformRequest(mod.id);
+                            const code = transformed?.code || '';
+                            upsertGraphModule((mod.id || '').replace(/\?.*$/, ''), code, deps);
+                        }
+                        catch (error) {
+                            if (verbose)
+                                console.warn('[hmr-ws][v2] failed graph update target', mod.id, error);
+                        }
+                    }
                 }
             }
             catch (e) {
@@ -5099,11 +6631,93 @@ export const piniaSymbol = p.piniaSymbol;
                 // For Angular, react to component TS or external template HTML changes under /src
                 const isHtml = file.endsWith('.html');
                 const isTs = file.endsWith('.ts');
+                const angularHotUpdateRoots = collectAngularHotUpdateRoots({
+                    file,
+                    modules: ctx.modules,
+                    getModuleById: (id) => server.moduleGraph.getModuleById(id),
+                    getModulesByFile: (targetFile) => server.moduleGraph.getModulesByFile?.(targetFile),
+                });
                 if (!(isHtml || isTs))
                     return;
+                if (angularHotUpdateRoots.length) {
+                    for (const mod of angularHotUpdateRoots) {
+                        try {
+                            server.moduleGraph.invalidateModule(mod);
+                        }
+                        catch (invalidationError) {
+                            if (verbose) {
+                                console.warn('[hmr-ws][angular] hot-update root invalidation failed', mod?.id, invalidationError);
+                            }
+                        }
+                    }
+                    if (verbose) {
+                        console.log('[hmr-ws][angular] invalidated hot-update root modules:', angularHotUpdateRoots.length);
+                    }
+                }
+                const angularTransitiveInvalidationRoots = (angularHotUpdateRoots.length ? angularHotUpdateRoots : ctx.modules);
+                if (shouldInvalidateAngularTransitiveImporters({ flavor: ACTIVE_STRATEGY.flavor, file })) {
+                    try {
+                        const transitiveImporters = collectAngularTransitiveImportersForInvalidation({
+                            modules: angularTransitiveInvalidationRoots,
+                            isExcluded: (id) => id.includes('/node_modules/'),
+                            maxDepth: 16,
+                        });
+                        for (const mod of transitiveImporters) {
+                            try {
+                                server.moduleGraph.invalidateModule(mod);
+                            }
+                            catch (invalidationError) {
+                                if (verbose) {
+                                    console.warn('[hmr-ws][angular] transitive importer invalidation failed', mod?.id, invalidationError);
+                                }
+                            }
+                        }
+                        if (verbose && transitiveImporters.length) {
+                            console.log('[hmr-ws][angular] invalidated transitive importers:', transitiveImporters.length);
+                        }
+                    }
+                    catch (error) {
+                        if (verbose)
+                            console.warn('[hmr-ws][angular] transitive importer collection failed', error);
+                    }
+                }
+                try {
+                    const transformCacheInvalidationUrls = new Set();
+                    if (isTs) {
+                        transformCacheInvalidationUrls.add(file);
+                    }
+                    for (const mod of angularHotUpdateRoots) {
+                        if (mod?.id) {
+                            transformCacheInvalidationUrls.add(mod.id);
+                        }
+                    }
+                    if (shouldInvalidateAngularTransitiveImporters({ flavor: ACTIVE_STRATEGY.flavor, file })) {
+                        const transitiveImporters = collectAngularTransitiveImportersForInvalidation({
+                            modules: angularTransitiveInvalidationRoots,
+                            isExcluded: (id) => id.includes('/node_modules/'),
+                            maxDepth: 16,
+                        });
+                        for (const mod of transitiveImporters) {
+                            if (mod?.id) {
+                                transformCacheInvalidationUrls.add(mod.id);
+                            }
+                        }
+                    }
+                    if (transformCacheInvalidationUrls.size) {
+                        sharedTransformRequest.invalidateMany(transformCacheInvalidationUrls);
+                        if (verbose) {
+                            console.log('[hmr-ws][angular] purged shared transform cache entries:', transformCacheInvalidationUrls.size);
+                        }
+                    }
+                }
+                catch (error) {
+                    if (verbose)
+                        console.warn('[hmr-ws][angular] shared transform cache purge failed', error);
+                }
                 try {
                     const root = server.config.root || process.cwd();
                     const rel = '/' + path.posix.normalize(path.relative(root, file)).split(path.sep).join('/');
+                    rememberAngularReloadSuppression(root, file);
                     const origin = getServerOrigin(server);
                     const msg = {
                         type: 'ns:angular-update',
@@ -5120,6 +6734,9 @@ export const piniaSymbol = p.piniaSymbol;
                 catch (error) {
                     console.warn('[hmr-ws][angular] update failed:', error);
                 }
+                if (shouldSuppressDefaultViteHotUpdate({ flavor: ACTIVE_STRATEGY.flavor, file })) {
+                    return [];
+                }
                 return;
             }
             // TypeScript flavor: emit generic graph delta for app XML/TS/style changes
@@ -5142,6 +6759,43 @@ export const piniaSymbol = p.piniaSymbol;
                 }
                 return;
             }
+            // Solid flavor: emit graph delta for app TSX/TS/JSX file changes.
+            // The common graph-update block above (moduleGraph lookup) may have
+            // already emitted a delta if the file was in Vite's module graph.
+            // This handler ensures a delta is emitted even if the module wasn't
+            // found (e.g. new file, or moduleGraph mismatch), and provides
+            // Solid-specific logging. The client-side processQueue handles
+            // propagation from non-component .ts files to .tsx component boundaries.
+            if (ACTIVE_STRATEGY.flavor === 'solid') {
+                const isSolidFile = /\.(tsx?|jsx?)$/i.test(file);
+                if (!isSolidFile)
+                    return;
+                try {
+                    const rel = '/' + path.posix.normalize(path.relative(root, file)).split(path.sep).join('/');
+                    if (verbose)
+                        console.log('[hmr-ws][solid] app file hot update', { file, rel });
+                    // If the common block already upserted (hash changed), this will
+                    // detect unchanged hash and no-op. If the common block missed it
+                    // (module not in Vite's graph), this forces the delta emission.
+                    const normalizedId = normalizeGraphId(rel);
+                    const existing = graph.get(normalizedId);
+                    if (!existing) {
+                        // Module not in graph yet — force upsert with timestamp-based
+                        // hash so the client sees a change.
+                        upsertGraphModule(rel, `/* solid-hmr ${Date.now()} */`, []);
+                    }
+                    // Log what we're sending so devs can trace the flow on the server side.
+                    if (verbose) {
+                        const gm = graph.get(normalizedId);
+                        console.log('[hmr-ws][solid] delta module', { id: gm?.id, hash: gm?.hash });
+                    }
+                }
+                catch (e) {
+                    if (verbose)
+                        console.warn('[hmr-ws][solid] failed to handle hot update for', file, e);
+                }
+                return;
+            }
             // Handle .vue file updates
             if (!file.endsWith('.vue')) {
                 if (verbose)
@@ -5249,6 +6903,7 @@ export const piniaSymbol = p.piniaSymbol;
                 // Rewrite ONLY .vue imports (everything else is now inlined)
                 const projectRoot = server.config.root || process.cwd();
                 code = rewriteImports(code, rel, sfcFileMap, depFileMap, projectRoot, opts.verbose, undefined);
+                upsertGraphModule(rel, code, [...deps, ...vueDeps]);
                 // Add HMR runtime prelude (CRITICAL for runtime)
                 const hmrPrelude = `
 // Embedded HMR Runtime for NativeScript runtime