@nativescript/vite 8.0.0-alpha.5 → 8.0.0-alpha.7

package/hmr/server/websocket.js

@@ -35,17 +35,25 @@ import { getCliFlags } from '../../helpers/cli-flags.js';
 import { normalizeCoreSub as normalizeCoreSubCanonical } from '../../helpers/ns-core-url.js';
 import { isRuntimeGraphExcludedPath, matchesRuntimeGraphModuleId, normalizeRuntimeGraphPath, shouldIncludeRuntimeGraphFile, shouldSkipRuntimeGraphDirectoryName } from './runtime-graph-filter.js';
 import { resolveAngularCoreHmrImportSource, rewriteAngularEntryRegisterOnly } from './websocket-angular-entry.js';
-import { canonicalizeTransformRequestCacheKey, collectAngularHotUpdateRoots, collectAngularTransformCacheInvalidationUrls, collectAngularTransitiveImportersForInvalidation, collectGraphUpdateModulesForHotUpdate, normalizeHotReloadMatchPath, shouldInvalidateAngularTransitiveImporters, shouldSuppressDefaultViteHotUpdate, shouldSuppressViteFullReloadPayload } from './websocket-angular-hot-update.js';
-import { classifyGraphUpsert, shouldBroadcastGraphUpsertDelta } from './websocket-graph-upsert.js';
+import { angularSourceHasSemanticDecorator, canonicalizeTransformRequestCacheKey, collectAngularEvictionUrls, collectAngularHotUpdateRoots, collectAngularTransformCacheInvalidationUrls, collectAngularTransitiveImportersForInvalidation, collectGraphUpdateModulesForHotUpdate, normalizeHotReloadMatchPath, shouldInvalidateAngularTransitiveImporters, shouldSuppressDefaultViteHotUpdate, shouldSuppressViteFullReloadPayload } from './websocket-angular-hot-update.js';
+import { classifyGraphUpsert, shouldBroadcastGraphUpsertDelta, shouldBumpGraphVersion } from './websocket-graph-upsert.js';
+import { classifyBootRoute, classifyHmrUpdateKind, createColdBootRequestCounter, formatHmrUpdateSummary, formatPopulateInitialGraphSummary, formatServerStartupBanner } from './perf-instrumentation.js';
+import { createHmrPendingMessage } from './websocket-hmr-pending.js';
 import { extractVitePrebundleId, filterExistingNodeModulesTransformCandidates, getBlockedDeviceNodeModulesReason, getFlattenedManifestMap, isCoreGlobalsReference, isEsmFrameworkPackageSpecifier, isLikelyNativeScriptPluginSpecifier, isLikelyNativeScriptRuntimePluginSpecifier, isNativeScriptCoreModule, isNativeScriptPluginModule, normalizeNativeScriptCoreSpecifier, normalizeNodeModulesSpecifier, resolveCandidateFilePath, resolveInternalRuntimePluginBareSpecifier, resolveNodeModulesPackageBoundary, resolveVendorFromCandidate, resolveVendorRouting, shouldPreserveBareRuntimePluginSubpathImport, stripDecoratedServePrefixes, tryReadRawExplicitJavaScriptModule, viteDepsPathToBareSpecifier, } from './websocket-module-specifiers.js';
 import { ensureNativeScriptModuleBindings, getProcessCodeResolvedSpecifierOverrides } from './websocket-module-bindings.js';
 import { collectStaticExportNamesFromFile, collectStaticExportOriginsFromFile, ensureVersionedCoreImports, extractDirectExportedNames, normalizeCoreExportOriginsForRuntime, parseCoreBridgeRequest, resolveRuntimeCoreModulePath } from './websocket-core-bridge.js';
 import { createSharedTransformRequestRunner } from './shared-transform-request.js';
+import { formatNsMHmrServeTag, getNumericServeVersionTag, rewriteNsMImportPathForHmr } from './websocket-ns-m-paths.js';
+import { ensureDynamicHmrImportHelper } from './websocket-served-module-helpers.js';
 export { ensureNativeScriptModuleBindings, getProcessCodeResolvedSpecifierOverrides } from './websocket-module-bindings.js';
 export { stripDecoratedServePrefixes, tryReadRawExplicitJavaScriptModule } from './websocket-module-specifiers.js';
 export { collectStaticExportNamesFromFile, collectStaticExportOriginsFromFile, ensureVersionedCoreImports, normalizeCoreExportOriginsForRuntime, parseCoreBridgeRequest } from './websocket-core-bridge.js';
 export { rewriteAngularEntryRegisterOnly } from './websocket-angular-entry.js';
-export { canonicalizeTransformRequestCacheKey, collectAngularHotUpdateRoots, collectAngularTransformCacheInvalidationUrls, collectAngularTransitiveImportersForInvalidation, collectGraphUpdateModulesForHotUpdate, createSharedTransformRequestRunner, normalizeHotReloadMatchPath, shouldInvalidateAngularTransitiveImporters, shouldSuppressDefaultViteHotUpdate, shouldSuppressViteFullReloadPayload, classifyGraphUpsert, shouldBroadcastGraphUpsertDelta };
+// Re-export the canonical URL rewriter from `websocket-ns-m-paths.js` so the
+// existing test suites (which import from `./websocket.js`) keep working
+// without churn while the implementation lives in a focused module.
+export { formatNsMHmrServeTag, rewriteNsMImportPathForHmr } from './websocket-ns-m-paths.js';
+export { angularSourceHasSemanticDecorator, canonicalizeTransformRequestCacheKey, collectAngularEvictionUrls, collectAngularHotUpdateRoots, collectAngularTransformCacheInvalidationUrls, collectAngularTransitiveImportersForInvalidation, collectGraphUpdateModulesForHotUpdate, createSharedTransformRequestRunner, normalizeHotReloadMatchPath, shouldInvalidateAngularTransitiveImporters, shouldSuppressDefaultViteHotUpdate, shouldSuppressViteFullReloadPayload, classifyGraphUpsert, shouldBroadcastGraphUpsertDelta, shouldBumpGraphVersion };
 const pluginTransformTypescript = (() => {
     const requireFromHere = createRequire(import.meta.url);
     const loaded = requireFromHere('@babel/plugin-transform-typescript');
@@ -72,6 +80,33 @@ const APP_VIRTUAL_PREFIX = getProjectAppVirtualPath();
 const APP_VIRTUAL_WITH_SLASH = `${APP_VIRTUAL_PREFIX}/`;
 const DEFAULT_MAIN_ENTRY = getProjectAppRelativePath('app.ts');
 const DEFAULT_MAIN_ENTRY_VIRTUAL = getProjectAppVirtualPath('app.ts');
+// Memoized resolver for the project bootstrap entry as a posix
+// project-relative path (e.g. `/src/main.ts`). This mirrors the
+// resolution the cold-boot wrapper performs (`getPackageJson().main` →
+// project-relative under `/<APP_ROOT_DIR>/`) so the eviction set for
+// HMR always lines up with the URL the runtime actually re-imports.
+// Resolved at first call and cached: `package.json` is read at startup
+// and never changes during a dev session, so it's safe to memoize.
+let __ns_bootstrap_entry_rel_cached = null;
+function getBootstrapEntryRelPath() {
+    if (__ns_bootstrap_entry_rel_cached)
+        return __ns_bootstrap_entry_rel_cached;
+    let entry = DEFAULT_MAIN_ENTRY_VIRTUAL;
+    try {
+        const pkg = getPackageJson();
+        const main = (pkg && pkg.main) || DEFAULT_MAIN_ENTRY;
+        const abs = getProjectFilePath(main).replace(/\\/g, '/');
+        const marker = `/${APP_ROOT_DIR}/`;
+        const idx = abs.indexOf(marker);
+        entry = idx >= 0 ? abs.substring(idx) : DEFAULT_MAIN_ENTRY_VIRTUAL;
+    }
+    catch { }
+    if (!entry.startsWith('/')) {
+        entry = '/' + entry;
+    }
+    __ns_bootstrap_entry_rel_cached = entry;
+    return entry;
+}
 const STRATEGY_REGISTRY = new Map([
     ['vue', vueServerStrategy],
     ['angular', angularServerStrategy],
@@ -318,44 +353,10 @@ function ensureGuardPlainDynamicImports(code, origin) {
         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" +
-            "  const __nsBootPrefix = typeof import.meta !== 'undefined' && import.meta && typeof import.meta.url === 'string' && import.meta.url.includes('/__ns_boot__/b1/') ? '/__ns_boot__/b1' : '';\n" +
-            "  const __nsImporterTagMatch = typeof import.meta !== 'undefined' && import.meta && typeof import.meta.url === 'string' ? import.meta.url.match(/\\/__ns_hmr__\\/([^/]+)\\//) : null;\n" +
-            "  const __nsImporterTag = __nsImporterTagMatch && __nsImporterTagMatch[1] ? decodeURIComponent(__nsImporterTagMatch[1]) : '';\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" +
-            '      const g = globalThis;\n' +
-            "      const graphVersion = typeof g.__NS_HMR_GRAPH_VERSION__ === 'number' ? g.__NS_HMR_GRAPH_VERSION__ : 0;\n" +
-            "      const nonce = typeof g.__NS_HMR_IMPORT_NONCE__ === 'number' ? g.__NS_HMR_IMPORT_NONCE__ : 0;\n" +
-            "      const __nsActiveBootPrefix = graphVersion || nonce ? '' : __nsBootPrefix;\n" +
-            "      if (spec.includes('/__ns_hmr__/')) {\n" +
-            "        const __preservedSpec = !nonce && __nsBootPrefix && spec.startsWith(__nsm + '/__ns_hmr__/') && !spec.includes('/node_modules/') ? __nsm + __nsBootPrefix + spec.slice(__nsm.length) : spec;\n" +
-            '        return import(new URL(__preservedSpec, import.meta.url).href);\n' +
-            '      }\n' +
-            "      if (spec.startsWith(__nsm + '/node_modules/')) { return import(new URL(spec, import.meta.url).href); }\n" +
-            "      const tag = nonce ? `n${nonce}` : (graphVersion ? `v${graphVersion}` : (__nsImporterTag || 'live'));\n" +
-            "      const nextPath = __nsm + __nsActiveBootPrefix + '/__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;
-    }
-}
-async function expandStarExports(code, server, projectRoot, verbose) {
+// `ensureDynamicHmrImportHelper` lives in
+// `./websocket-served-module-helpers.js`. See that file for the
+// architectural rationale and the current helper implementation.
+async function expandStarExports(code, server, projectRoot, verbose, sharedTransformer) {
     const STAR_RE = /^[ \t]*(export\s+\*\s+from\s+["'])([^"']+)(["'];?)[ \t]*$/gm;
     let match;
     const replacements = [];
@@ -367,25 +368,41 @@ async function expandStarExports(code, server, projectRoot, verbose) {
     }
     if (!replacements.length)
         return code;
-    for (const rep of replacements) {
+    // Pull target URLs through the shared runner when it's available so each
+    // node_modules path shares the 60s TTL cache with the main /ns/m pipeline
+    // and respects the global concurrency gate. Fan them out in parallel —
+    // this block used to be a serial `for await` loop, which dominated cold
+    // boot on apps with dozens of star-re-exports.
+    const transformer = sharedTransformer ?? ((url) => server.transformRequest(url));
+    const resolved = await Promise.all(replacements.map(async (rep) => {
         try {
             let vitePath = rep.url.replace(/^https?:\/\/[^/]+/, '');
             vitePath = vitePath.replace(/^\/ns\/m\//, '/');
             vitePath = vitePath.replace(/^\/__ns_boot__\/[^/]+/, '');
             vitePath = vitePath.replace(/\/__ns_hmr__\/[^/]+/, '');
-            const result = await server.transformRequest(vitePath);
+            const result = await transformer(vitePath);
             if (!result?.code)
-                continue;
+                return null;
             const names = extractExportedNames(result.code);
             if (!names.length)
-                continue;
-            const explicit = `export { ${names.join(', ')} } from ${JSON.stringify(rep.url)};`;
-            code = code.replace(rep.full, explicit);
+                return null;
             if (verbose) {
-                console.log(`[ns/m] expanded export* -> ${names.length} names from ${vitePath}`);
+                try {
+                    console.log(`[ns/m] expanded export* -> ${names.length} names from ${vitePath}`);
+                }
+                catch { }
             }
+            return { rep, names };
         }
-        catch { }
+        catch {
+            return null;
+        }
+    }));
+    for (const entry of resolved) {
+        if (!entry)
+            continue;
+        const explicit = `export { ${entry.names.join(', ')} } from ${JSON.stringify(entry.rep.url)};`;
+        code = code.replace(entry.rep.full, explicit);
     }
     return code;
 }
@@ -894,52 +911,13 @@ function toNodeModulesHttpModuleId(importPath) {
     }
     return `/ns/m/node_modules/${nodeModulesSpecifier}`;
 }
-export function rewriteNsMImportPathForHmr(p, ver, bootTaggedRequest) {
-    const toHmrServeTag = (value) => {
-        const raw = String(value ?? '').trim();
-        if (!raw) {
-            return 'v0';
-        }
-        if (raw === 'live' || /^n\d+$/i.test(raw) || /^v[^/]+$/i.test(raw)) {
-            return raw;
-        }
-        if (/^\d+$/.test(raw)) {
-            return `v${raw}`;
-        }
-        return raw;
-    };
-    if (!p || !p.startsWith('/ns/m/')) {
-        return p;
-    }
-    const canonicalNodeModulesPath = p.replace(/^\/ns\/m\/__ns_boot__\/b1\/__ns_hmr__\/[^/]+\/node_modules\//, '/ns/m/node_modules/').replace(/^\/ns\/m\/__ns_hmr__\/[^/]+\/node_modules\//, '/ns/m/node_modules/');
-    if (canonicalNodeModulesPath.startsWith('/ns/m/node_modules/')) {
-        return canonicalNodeModulesPath;
-    }
-    if (canonicalNodeModulesPath.startsWith('/ns/m/__ns_boot__/')) {
-        return canonicalNodeModulesPath;
-    }
-    if (canonicalNodeModulesPath.startsWith('/ns/m/__ns_hmr__/')) {
-        return bootTaggedRequest ? `/ns/m/__ns_boot__/b1${canonicalNodeModulesPath.slice('/ns/m'.length)}` : canonicalNodeModulesPath;
-    }
-    const tag = toHmrServeTag(ver);
-    const hmrPrefix = `/ns/m/__ns_hmr__/${tag}`;
-    const bootHmrPrefix = `/ns/m/__ns_boot__/b1/__ns_hmr__/${tag}`;
-    return (bootTaggedRequest ? bootHmrPrefix : hmrPrefix) + canonicalNodeModulesPath.slice('/ns/m'.length);
-}
-function getNumericServeVersionTag(tag, fallback) {
-    const raw = String(tag || '').trim();
-    if (!raw) {
-        return fallback;
-    }
-    const versionMatch = raw.match(/^v(\d+)$/);
-    if (versionMatch?.[1]) {
-        return Number(versionMatch[1]);
-    }
-    if (/^\d+$/.test(raw)) {
-        return Number(raw);
-    }
-    return fallback;
-}
+// `rewriteNsMImportPathForHmr` and `getNumericServeVersionTag` live in
+// `./websocket-ns-m-paths.js`. The path rewriter is part of the
+// "Stable URL + Explicit Invalidation" architecture and must be a
+// single source of truth so the canonicalization rules can't drift
+// between modules. They are imported above and re-exported below for
+// tests / external callers that historically reached them through this
+// module.
 function normalizeAbsoluteFilesystemImport(spec, importerPath, projectRoot) {
     if (!spec || typeof spec !== 'string') {
         return null;
@@ -2331,10 +2309,21 @@ function createHmrWebSocketPlugin(opts) {
     let registrySent = false;
     let vendorBootstrapDone = false;
     let pluginRoot;
-    let graphVersion = 0;
+    // graphVersion starts at 1 so the very first /ns/m response uses a stable
+    // `v1` URL tag (see dynamic-import helper at lines 398-432). Keeping it
+    // stable during cold boot prevents double-loads when the graph fills up
+    // lazily as modules are served.
+    let graphVersion = 1;
     // Transactional HMR batches: map graphVersion -> ordered list of changed ids for that version
     const txnBatches = new Map();
     const graph = new Map();
+    // Tracks the background initial-graph population so handleHotUpdate can
+    // await completion before computing delta roots for the first HMR event.
+    let graphInitialPopulationPromise = null;
+    // Cold-boot /ns/m request counter — populated the first time a /ns/m
+    // request arrives, finalized when the request window goes idle.
+    // See Shared across requests so a single counter spans the whole cold boot.
+    let coldBootCounter = null;
     function rememberAngularReloadSuppression(root, file, ttlMs = 3000) {
         const absPath = normalizeHotReloadMatchPath(file);
         const relPath = normalizeHotReloadMatchPath(file, root);
@@ -2506,12 +2495,17 @@ function createHmrWebSocketPlugin(opts) {
         const classification = classifyGraphUpsert(existing, hash, normDeps);
         if (classification === 'unchanged')
             return existing;
-        graphVersion++;
+        // Version bumps are only meaningful for live edits — serve-time graph
+        // warm-ups and the initial bulk walk should leave graphVersion stable.
+        const bumpVersion = shouldBumpGraphVersion(classification, options?.bumpVersion !== false);
+        if (bumpVersion) {
+            graphVersion++;
+        }
         const gm = { id, deps: normDeps, hash };
         graph.set(id, gm);
         if (verbose) {
             try {
-                console.log('[hmr-ws][graph] upsert', { id, deps: normDeps, hash, graphVersion, classification });
+                console.log('[hmr-ws][graph] upsert', { id, deps: normDeps, hash, graphVersion, classification, bumpVersion });
                 console.log('[hmr-ws][graph] size', graph.size);
             }
             catch { }
@@ -2539,6 +2533,8 @@ function createHmrWebSocketPlugin(opts) {
     async function populateInitialGraph(server) {
         if (graph.size)
             return; // already populated
+        const tStart = Date.now();
+        const versionAtStart = graphVersion;
         const root = server.config.root || process.cwd();
         // Avoid direct require in ESM build: lazily obtain fs & path via createRequire or dynamic import
         let fs;
@@ -2554,6 +2550,18 @@ function createHmrWebSocketPlugin(opts) {
             fs = await import('fs');
             pathMod = await import('path');
         }
+        // Route every bulk transform through `sharedTransformRequest` when it's
+        // already been wired up — this way the background walk shares the 60s
+        // TTL cache with live /ns/m requests, so the device sees cached results
+        // for any file the walker already visited. The fallback keeps the
+        // walker working during server tests where the shared runner isn't
+        // constructed yet.
+        const bulkTransform = (rel) => {
+            if (sharedTransformRequest) {
+                return sharedTransformRequest(rel);
+            }
+            return server.transformRequest(rel);
+        };
         async function walk(dir) {
             for (const name of fs.readdirSync(dir)) {
                 if (name === 'node_modules' || name.startsWith('.') || shouldSkipRuntimeGraphDirectoryName(name))
@@ -2568,7 +2576,7 @@ function createHmrWebSocketPlugin(opts) {
                             const rel = '/' + pathMod.relative(root, full).split(pathMod.sep).join('/');
                             // Transform via Vite to gather deps (ignore failures)
                             try {
-                                const transformed = await server.transformRequest(rel);
+                                const transformed = await bulkTransform(rel);
                                 const code = transformed?.code || '';
                                 const deps = [];
                                 // fallback to import relationships via moduleGraph
@@ -2579,7 +2587,10 @@ function createHmrWebSocketPlugin(opts) {
                                             deps.push(m.id.split('?')[0]);
                                     }
                                 }
-                                upsertGraphModule(rel, code, deps);
+                                // bumpVersion: false — the initial walk is a bulk load, not a live
+                                // edit. Keeping graphVersion stable during cold boot avoids double
+                                // cache-key drift.
+                                upsertGraphModule(rel, code, deps, { bumpVersion: false });
                             }
                             catch { }
                         }
@@ -2592,6 +2603,40 @@ function createHmrWebSocketPlugin(opts) {
             await walk(pathMod.join(root, 'src'));
         }
         catch { }
+        // Diagnostic summary. Gated behind the verbose flag so the
+        // dev console stays quiet on a normal save. Flip
+        // NS_VITE_VERBOSE=1 to surface slow cold-boot walks; a
+        // `bumpedVersion=no` result is the happy path, `yes`
+        // indicates a regression.
+        if (verbose) {
+            try {
+                console.info(formatPopulateInitialGraphSummary({
+                    moduleCount: graph.size,
+                    durationMs: Date.now() - tStart,
+                    graphVersion,
+                    bumpedVersion: graphVersion !== versionAtStart,
+                }));
+            }
+            catch { }
+        }
+    }
+    // Kick off `populateInitialGraph` in the background (non-awaited) so /ns/m
+    // responses are never blocked on a full tree walk. Returns the shared
+    // promise so hot-update code paths can await completion before computing
+    // delta roots for the first HMR event.
+    function ensureInitialGraphPopulationStarted(server) {
+        if (graphInitialPopulationPromise) {
+            return graphInitialPopulationPromise;
+        }
+        if (graph.size) {
+            graphInitialPopulationPromise = Promise.resolve();
+            return graphInitialPopulationPromise;
+        }
+        graphInitialPopulationPromise = populateInitialGraph(server).catch((error) => {
+            if (verbose)
+                console.warn('[hmr-ws][graph] background initial population failed', error);
+        });
+        return graphInitialPopulationPromise;
     }
     return {
         name: 'nativescript-hmr-websocket',
@@ -2620,12 +2665,22 @@ function createHmrWebSocketPlugin(opts) {
                     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;
+            // Transform concurrency. Historically we defaulted to 1 to avoid
+            // race conditions during HTTP HMR startup, but the shared runner
+            // already has per-URL coalescing and an async-cached result map,
+            // so higher fan-out is safe and dramatically reduces cold-boot
+            // time. We cap at 8 by default to match typical dev machines and
+            // respect Vite's internal worker pool limits. Override via the
+            // `NS_VITE_HMR_TRANSFORM_CONCURRENCY` env var when needed.
+            const configuredTransformConcurrency = Number.parseInt(process.env.NS_VITE_HMR_TRANSFORM_CONCURRENCY || '', 10);
+            const transformConcurrency = Number.isFinite(configuredTransformConcurrency) && configuredTransformConcurrency > 0 ? configuredTransformConcurrency : 8;
+            // Keep transformed code cached for longer across HMR updates so
+            // that unchanged neighbours of an edited file don't re-run
+            // through the Angular/TypeScript/Vite transform pipeline. The
+            // HMR flow explicitly invalidates affected URLs, so a longer TTL
+            // is safe. Override with `NS_VITE_HMR_TRANSFORM_CACHE_MS`.
+            const configuredTransformCacheMs = Number.parseInt(process.env.NS_VITE_HMR_TRANSFORM_CACHE_MS || '', 10);
+            const transformCacheMs = Number.isFinite(configuredTransformCacheMs) && configuredTransformCacheMs >= 0 ? configuredTransformCacheMs : 60000;
             sharedTransformRequest = createSharedTransformRequestRunner((url) => server.transformRequest(url), (url, timeoutMs) => {
                 try {
                     console.warn('[ns:m] slow transformRequest for', url, '(>' + timeoutMs + 'ms)');
@@ -2636,6 +2691,124 @@ function createHmrWebSocketPlugin(opts) {
                 resultCacheTtlMs: transformCacheMs,
                 getResultCacheKey: (url) => canonicalizeTransformRequestCacheKey(url, pluginRoot || process.cwd()),
             });
+            // Always-on startup banner — prints once per dev server process
+            // so anyone investigating perf can immediately see which build
+            // is live and what knobs are active.
+            try {
+                let pkgVersion = 'unknown';
+                try {
+                    const req = createRequire(import.meta.url);
+                    const pkg = req('@nativescript/vite/package.json');
+                    if (pkg && typeof pkg.version === 'string')
+                        pkgVersion = pkg.version;
+                }
+                catch {
+                    // `@nativescript/vite/package.json` is not always exported; fall
+                    // back to reading the file from disk next to this module.
+                    try {
+                        const here = new URL(import.meta.url).pathname;
+                        const pkgPath = path.resolve(path.dirname(here), '..', '..', 'package.json');
+                        if (existsSync(pkgPath)) {
+                            const parsed = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+                            if (parsed && typeof parsed.version === 'string')
+                                pkgVersion = parsed.version;
+                        }
+                    }
+                    catch { }
+                }
+                if (verbose) {
+                    console.info(formatServerStartupBanner({
+                        version: pkgVersion,
+                        transformConcurrency,
+                        transformCacheMs,
+                        lazyInitialGraph: true,
+                        graphVersion,
+                    }));
+                }
+            }
+            catch { }
+            // Always-on cold-boot request trace. Runs in front of every
+            // other middleware so it catches all NS dev routes (/ns/m/*,
+            // /ns/rt/*, /ns/core/*, /__ns_boot__/*, etc.) with a single
+            // hook. Closes itself after an idle window so HMR edits don't
+            // get rolled into the cold-boot numbers. The idle window is
+            // generous by default (5s) because V8's HTTP ESM resolver
+            // pauses between dep levels while parsing — a too-tight window
+            // was closing after the first wave and under-reporting boot by
+            // 100x. Override via `NS_VITE_HMR_BOOT_TRACE_IDLE_MS` when
+            // profiling something tricky.
+            try {
+                const configuredIdleMs = Number.parseInt(process.env.NS_VITE_HMR_BOOT_TRACE_IDLE_MS || '', 10);
+                const idleWindowMs = Number.isFinite(configuredIdleMs) && configuredIdleMs > 0 ? configuredIdleMs : 5000;
+                const configuredSummaryEvery = Number.parseInt(process.env.NS_VITE_HMR_BOOT_TRACE_PROGRESS_EVERY || '', 10);
+                const summaryEvery = Number.isFinite(configuredSummaryEvery) && configuredSummaryEvery >= 0 ? configuredSummaryEvery : 25;
+                if (!coldBootCounter) {
+                    coldBootCounter = createColdBootRequestCounter({
+                        summaryEvery,
+                        idleWindowMs,
+                        // Gated on the verbose flag so cold-boot progress and
+                        // the final window-closed summary stay quiet by
+                        // default. Flip NS_VITE_VERBOSE=1 to surface them.
+                        log: (line) => {
+                            if (!verbose)
+                                return;
+                            try {
+                                console.info(line);
+                            }
+                            catch { }
+                        },
+                    });
+                }
+            }
+            catch { }
+            server.middlewares.use((req, res, next) => {
+                try {
+                    const urlObj = new URL(req.url || '', 'http://localhost');
+                    const route = classifyBootRoute(urlObj.pathname);
+                    if (route === 'other')
+                        return next();
+                    if (!coldBootCounter)
+                        return next();
+                    const handle = coldBootCounter.record(urlObj.pathname);
+                    const finishOnce = () => {
+                        try {
+                            handle.finish();
+                        }
+                        catch { }
+                    };
+                    try {
+                        res.once('finish', finishOnce);
+                        res.once('close', finishOnce);
+                    }
+                    catch { }
+                }
+                catch { }
+                next();
+            });
+            // Give `populateInitialGraph` a head start. Previously this only
+            // kicked off on the first /ns/m hit, which meant populate was
+            // competing with the device for the same 8 transform slots
+            // throughout the first 4-5 seconds of cold boot. Starting at
+            // `configureServer` time gives populate the full app
+            // build/launch window (typically 2-3s on simulator) as a head
+            // start, so more of its work lands before the device even
+            // connects. Disable via `NS_VITE_HMR_DISABLE_POPULATE=1` when
+            // profiling whether populate is helping or hurting a specific
+            // app.
+            try {
+                const disablePopulate = process.env.NS_VITE_HMR_DISABLE_POPULATE === '1' || process.env.NS_VITE_HMR_DISABLE_POPULATE === 'true';
+                if (disablePopulate) {
+                    if (verbose)
+                        console.info('[hmr-ws][populate] disabled via NS_VITE_HMR_DISABLE_POPULATE');
+                    // Short-circuit: mark as resolved so /ns/m never schedules it and
+                    // HMR still works (handleHotUpdate just has no pre-warmed graph).
+                    graphInitialPopulationPromise = Promise.resolve();
+                }
+                else {
+                    ensureInitialGraphPopulationStarted(server);
+                }
+            }
+            catch { }
             // Attempt early vendor manifest bootstrap once per server.
             if (!vendorBootstrapDone) {
                 vendorBootstrapDone = true;
@@ -2910,25 +3083,23 @@ function createHmrWebSocketPlugin(opts) {
                     const urlObj = new URL(req.url || '', 'http://localhost');
                     if (!urlObj.pathname.startsWith('/ns/m'))
                         return next();
-                    // Populate the initial graph on first /ns/m request so graphVersion is
-                    // non-zero and stable before we rewrite any child import paths. Without
-                    // this the first dyn-imports (e.g. main.ts → routed tab components) are
-                    // served with graphVersion=0, which makes the 'live' → v{N} substitution
-                    // below no-op; later dyn-imports (after the HMR websocket client connects
-                    // and populateInitialGraph runs inside 'connection') arrive when
-                    // graphVersion has jumped to some N>0, so their child URLs land at /v{N}/
-                    // while the early tree still references /live/ — two distinct iOS HTTP
-                    // ESM cache entries for the same file, two Angular class identities,
-                    // NG0912 selector collisions.
-                    if (graph.size === 0) {
-                        try {
-                            await populateInitialGraph(server);
-                        }
-                        catch (e) {
-                            if (verbose)
-                                console.warn('[hmr-ws][graph] lazy initial population failed', e);
-                        }
-                    }
+                    // Previously we awaited `populateInitialGraph(server)` here so
+                    // graphVersion would be non-zero for the first /ns/m request.
+                    // That gave deterministic URL tags but blocked the cold boot on a
+                    // full src/ tree walk (hundreds of transformRequest calls, 3-6s).
+                    //
+                    // graphVersion now starts at 1 and stays stable during cold boot
+                    // (see `upsertGraphModule`'s bumpVersion option and the inline
+                    // comment at the graphVersion declaration). We kick off the
+                    // initial population in the background so it doesn't block the
+                    // first response. `handleHotUpdate` awaits the same promise so
+                    // the first HMR event still sees a fully populated graph.
+                    ensureInitialGraphPopulationStarted(server);
+                    // Cold-boot counter is now hooked via the leading boot-trace
+                    // middleware (see `configureServer` — it records the request
+                    // and tracks finish() via res.on('close'/'finish')). This
+                    // handler used to record here but that missed the
+                    // round-trip timing and didn't track per-route breakdowns.
                     res.setHeader('Access-Control-Allow-Origin', '*');
                     res.setHeader('Content-Type', 'application/javascript; charset=utf-8');
                     // Disable caching for dev ESM endpoints to avoid device-side stale module reuse
@@ -3140,7 +3311,9 @@ function createHmrWebSocketPlugin(opts) {
                         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 (verbose) {
+                                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
@@ -3149,7 +3322,9 @@ function createHmrWebSocketPlugin(opts) {
                                 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');
+                                    if (verbose) {
+                                        console.log('[hmr-ws][solid] bypassed shouldWarnAndDecline() for NativeScript HMR');
+                                    }
                                 }
                                 // Patch 2: Force createMemo path in createProxy.
                                 // Without the 'development' condition, $DEVCOMP is not set on components,
@@ -3160,10 +3335,17 @@ function createHmrWebSocketPlugin(opts) {
                                 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');
+                                    if (verbose) {
+                                        console.log('[hmr-ws][solid] forced createMemo path in createProxy for NativeScript HMR');
+                                    }
                                 }
                                 // Patch 3: Inline patchRegistry call so updates apply immediately
                                 // on module re-evaluation (accept callbacks are not invoked by the HMR client).
+                                // The injected `console.log` helpers run inside the user's runtime
+                                // when @solid-refresh re-evaluates a module, so they are a runtime
+                                // concern (stripped if the user disables the patch). Keeping them
+                                // behind the patch sentinel rather than the dev-server `verbose`
+                                // flag is intentional — the patch only runs when Solid HMR fires.
                                 const marker = 'hot.data[SOLID_REFRESH] = hot.data[SOLID_REFRESH] || registry;';
                                 if (patchedCode.includes(marker)) {
                                     const patchCode = [
@@ -3177,7 +3359,9 @@ function createHmrWebSocketPlugin(opts) {
                                         `}`,
                                     ].join('\n    ');
                                     patchedCode = patchedCode.replace(marker, `${patchCode}\n    ${marker}`);
-                                    console.log('[hmr-ws][solid] added inline patchRegistry for NativeScript HMR');
+                                    if (verbose) {
+                                        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 };
@@ -3207,7 +3391,9 @@ function createHmrWebSocketPlugin(opts) {
                                             }
                                             catch { }
                                         }
-                                        upsertGraphModule(id, code, deps);
+                                        // Serve-time warm-up: no live edit happened, so don't bump
+                                        // graphVersion.
+                                        upsertGraphModule(id, code, deps, { bumpVersion: false });
                                     }
                                 }
                             }
@@ -3357,7 +3543,7 @@ export const piniaSymbol = p.piniaSymbol;
                     // 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);
+                        code = await expandStarExports(code, server, server.config?.root || process.cwd(), verbose, sharedTransformRequest);
                     }
                     catch (e) {
                         if (verbose)
@@ -3430,45 +3616,63 @@ export const piniaSymbol = p.piniaSymbol;
                         }
                     }
                     catch { }
+                    // `/ns/rt` and `/ns/core` URL versioning.
+                    //
+                    // Older versions of the server emitted `/ns/rt/<ver>` and
+                    // `/ns/core/<ver>` so V8's HTTP module cache would see a
+                    // fresh URL on every save. The runtime canonicalizer
+                    // (`CanonicalizeHttpUrlKey` in HMRSupport.mm) collapses
+                    // these version segments to the bare `/ns/rt` and
+                    // `/ns/core` keys before lookup, so V8 actually saw a
+                    // single cache entry — but the server was doing extra
+                    // work to inject a version segment that the runtime then
+                    // immediately stripped. Now that the runtime supports
+                    // explicit eviction (and these bridge endpoints don't
+                    // change at HMR time anyway), the version segment is
+                    // purely vestigial.
+                    //
+                    // Rather than rip the helpers out (which would touch
+                    // every ensureVersionedImports caller and risk bumping
+                    // older runtimes), we keep them but pass `verNum=0`. The
+                    // helpers still normalize URL shape (strip the absolute
+                    // origin prefix when present) but emit a stable
+                    // `/ns/rt/0` / `/ns/core/0` URL — which collapses to
+                    // `/ns/rt` / `/ns/core` in the runtime.
                     try {
-                        const verNum = getNumericServeVersionTag(forcedVer, Number(graphVersion || 0));
+                        const verNum = 0;
                         code = ensureVersionedRtImports(code, getServerOrigin(server), verNum);
                         code = ACTIVE_STRATEGY.ensureVersionedImports(code, getServerOrigin(server), verNum);
                         code = ensureVersionedCoreImports(code, getServerOrigin(server), verNum);
                     }
                     catch { }
-                    // 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.
+                    // `/ns/m` URL finalize step.
+                    //
+                    // `rewriteNsMImportPathForHmr` is a canonicalizer: it
+                    // strips legacy `__ns_hmr__/<tag>/` segments and adds
+                    // `__ns_boot__/b1/` only for boot-tagged requests. The
+                    // `ver` parameter is preserved on the signature for API
+                    // compatibility but is ignored for app modules (cache
+                    // busting is driven by `__nsInvalidateModules`, not URL
+                    // versioning). We pass `'v0'` as a stable placeholder —
+                    // the canonicalizer emits the same URL regardless of
+                    // this value, but a constant placeholder makes the
+                    // contract explicit.
+                    //
+                    // SFC URLs (line below, `/ns/sfc/${verTag}/...`) still
+                    // embed a version because the Vue SFC pathway does not
+                    // yet have an eviction protocol. The runtime
+                    // canonicalizer does NOT strip `/ns/sfc/<ver>/`, so Vue
+                    // users still see per-save SFC re-fetches — that's a
+                    // known follow-up.
                     try {
-                        const ver = (() => {
-                            const raw = String(forcedVer || '').trim();
-                            const gv = Number(graphVersion || 0);
-                            // 'live' is the client dynamic-import helper's fallback when
-                            // globalThis.__NS_HMR_GRAPH_VERSION__ has not yet been set (i.e. before the
-                            // full HMR client takes over). If we propagate 'live' into child import
-                            // URLs, a file loaded through a 'live'-tagged parent ends up at
-                            // /ns/m/__ns_hmr__/live/... in the iOS V8 module cache while a later
-                            // dyn-import at v${N} loads the same file at /ns/m/__ns_hmr__/v${N}/...
-                            // — two distinct cache entries, two module realms, two Angular class
-                            // identities per @Component, and NG0912 selector collisions. Replace
-                            // 'live' with the current graph version so every child resolves to one
-                            // canonical URL regardless of the parent's request tag.
-                            if (raw === 'live' && gv > 0) {
-                                return `v${gv}`;
-                            }
-                            if (raw) {
-                                if (raw === 'live' || /^n\d+$/i.test(raw) || /^v[^/]+$/i.test(raw)) {
-                                    return raw;
-                                }
-                                if (/^\d+$/.test(raw)) {
-                                    return `v${raw}`;
-                                }
-                            }
-                            return `v${String(graphVersion || 0)}`;
+                        const verTag = (() => {
+                            const numeric = getNumericServeVersionTag(forcedVer, Number(graphVersion || 0));
+                            return numeric > 0 ? `v${numeric}` : 'v0';
                         })();
                         const origin = getServerOrigin(server);
-                        const rewritePath = (p) => rewriteNsMImportPathForHmr(p, ver, bootTaggedRequest);
+                        const rewritePath = (p) => rewriteNsMImportPathForHmr(p, 'v0', bootTaggedRequest);
+                        // /ns/m URL forms — all collapse to canonical stable
+                        // URLs via the Phase 3a rewriter.
                         // 1) Static imports: import ... from "/ns/m/..."
                         code = code.replace(/(from\s*["'])(\/ns\/m\/[^"'?]+)(["'])/g, (_m, a, p, b) => `${a}${rewritePath(p)}${b}`);
                         // 2) Side-effect imports: import "/ns/m/..."
@@ -3479,14 +3683,14 @@ export const piniaSymbol = p.piniaSymbol;
                         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, (_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__/..."
+                        // 6) Force absolute HTTP for new URL('/ns/m/...', import.meta.url).href → canonical stable URL.
                         try {
                             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>/..."
+                        // 7) SFC URLs (Vue) — still versioned. See header comment.
                         try {
-                            code = code.replace(/new\s+URL\(\s*["']\/ns\/sfc(\/[^"'?]+)(?:\?[^"']*)?["']\s*,\s*import\.meta\.url\s*\)\.href/g, (_m, p1) => `${JSON.stringify(`${origin}/ns/sfc/${ver}${p1}`)}`);
+                            code = code.replace(/new\s+URL\(\s*["']\/ns\/sfc(\/[^"'?]+)(?:\?[^"']*)?["']\s*,\s*import\.meta\.url\s*\)\.href/g, (_m, p1) => `${JSON.stringify(`${origin}/ns/sfc/${verTag}${p1}`)}`);
                         }
                         catch { }
                     }
@@ -3603,10 +3807,12 @@ export const piniaSymbol = p.piniaSymbol;
                                         // 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)`);
+                                            if (verbose) {
+                                                try {
+                                                    console.warn(`[ns:m][link-check] CJS module without export default: ${u.pathname} (will be CJS-wrapped at serve time)`);
+                                                }
+                                                catch { }
                                             }
-                                            catch { }
                                             continue;
                                         }
                                         const msg = `[link-check] Missing default export in ${u.pathname}${u.search} (imported by ${resolvedCandidate || spec})`;
@@ -3620,10 +3826,12 @@ export const piniaSymbol = p.piniaSymbol;
                         }
                     }
                     catch (eLC) {
-                        try {
-                            console.warn('[ns:m][link-check] failed', eLC?.message || eLC);
+                        if (verbose) {
+                            try {
+                                console.warn('[ns:m][link-check] failed', eLC?.message || eLC);
+                            }
+                            catch { }
                         }
-                        catch { }
                     }
                     res.statusCode = 200;
                     res.end(code);
@@ -3665,8 +3873,10 @@ export const piniaSymbol = p.piniaSymbol;
                         `let __cached_rt = null;\n` +
                         `let __cached_vm = null;\n` +
                         `const __RT_REALM_TAG = (globalThis.__NS_RT_REALM__ ||= Math.random().toString(36).slice(2));\n` +
-                        // Unconditional one-shot evaluation marker to confirm bridge is executed on device
-                        `try { if (!(globalThis.__NS_RT_ONCE__ && globalThis.__NS_RT_ONCE__.eval)) { (globalThis.__NS_RT_ONCE__ ||= {}).eval = true; console.log('[ns-rt] evaluated', { rtRealm: __RT_REALM_TAG }); } } catch {}\n` +
+                        // One-shot evaluation marker to confirm the bridge is executed on
+                        // device. Gated on __NS_ENV_VERBOSE__ so it stays silent unless
+                        // the developer opts in via NS_VITE_VERBOSE / VITE_DEBUG_LOGS.
+                        `try { if (!(globalThis.__NS_RT_ONCE__ && globalThis.__NS_RT_ONCE__.eval)) { (globalThis.__NS_RT_ONCE__ ||= {}).eval = true; if (globalThis.__NS_ENV_VERBOSE__) console.log('[ns-rt] evaluated', { rtRealm: __RT_REALM_TAG }); } } catch {}\n` +
                         `function __ensure(){\n` +
                         `  if (__cached_rt) return __cached_rt;\n` +
                         `  let vm = null;\n` +
@@ -3846,15 +4056,15 @@ export const piniaSymbol = p.piniaSymbol;
             });
             // 2.6) ESM bridge for @nativescript/core: GET /ns/core[/<ver>][?p=sub/path]
             //
-            // Since bundle.mjs no longer bundles @nativescript/core (see
-            // HMR_CORE_REALM_DETERMINISTIC_PLAN.md — external in the rolldown
-            // config under HMR), this endpoint is the ONE place core is
-            // evaluated. Every consumer — bundle.mjs's own `@nativescript/core*`
-            // imports (resolved to full HTTP URLs in the entry virtual module),
-            // externalized vendor packages, HTTP-served app modules — all end
-            // up here. No more proxy bridge, no enumeration, no namespace
-            // detection, no prototype-polluted maps. We just serve Vite's
-            // authoritative transformed module content.
+            // Since bundle.mjs no longer bundles @nativescript/core (it is
+            // declared external in the rolldown config under HMR), this
+            // endpoint is the ONE place core is evaluated. Every consumer —
+            // bundle.mjs's own `@nativescript/core*` imports (resolved to
+            // full HTTP URLs in the entry virtual module), externalized
+            // vendor packages, HTTP-served app modules — all end up here.
+            // No more proxy bridge, no enumeration, no namespace detection,
+            // no prototype-polluted maps. We just serve Vite's authoritative
+            // transformed module content.
             //
             // iOS caches by URL path, so each unique URL is evaluated exactly
             // once per app lifetime. Every class identity is shared, every
@@ -3961,16 +4171,15 @@ export const piniaSymbol = p.piniaSymbol;
                         `const __TEST__ = false;`,
                     ].join('\n');
                     // Boot-time instrumentation + module self-registration.
-                    // See HMR_CORE_REALM_DETERMINISTIC_PLAN.md:
-                    //   - Invariant A (URL canonicalization): the same
-                    //     logical module must always resolve to byte-
-                    //     identical URLs across every emitter. The /ns/core
-                    //     handler records the first URL seen for each
-                    //     canonical sub (or '' for main) in
-                    //     `globalThis.__NS_CORE_FIRST_URL__` and fails hard
-                    //     on mismatch so drift in any emitter surfaces
+                    //
+                    //   - URL canonicalization: the same logical module must
+                    //     always resolve to byte-identical URLs across every
+                    //     emitter. The /ns/core handler records the first URL
+                    //     seen for each canonical sub (or '' for main) in
+                    //     `globalThis.__NS_CORE_FIRST_URL__` and fails hard on
+                    //     mismatch so drift in any emitter surfaces
                     //     immediately, before the realm splits.
-                    //   - Invariant C (boot-order): CommonJS
+                    //   - CJS/ESM boot order: CommonJS
                     //     `require('@nativescript/core/...')` calls from
                     //     vendor install() hooks must resolve to the SAME
                     //     ESM namespace that ran this side-effect preamble.
@@ -3999,13 +4208,13 @@ export const piniaSymbol = p.piniaSymbol;
                         `  const __nsUrl = ${JSON.stringify(canonicalUrl)};`,
                         `  __nsSeen.push(__nsUrl);`,
                         `  if (typeof __nsFirst[__nsKey] === 'string' && __nsFirst[__nsKey] !== __nsUrl) {`,
-                        `    throw new Error('[ns-core] URL drift for sub=' + __nsKey + ': first=' + __nsFirst[__nsKey] + ' now=' + __nsUrl + ' (see HMR_CORE_REALM_DETERMINISTIC_PLAN.md Invariant A)');`,
+                        `    throw new Error('[ns-core] URL drift for sub=' + __nsKey + ': first=' + __nsFirst[__nsKey] + ' now=' + __nsUrl);`,
                         `  }`,
                         `  if (!__nsFirst[__nsKey]) __nsFirst[__nsKey] = __nsUrl;`,
                         `  globalThis.__NS_CORE_EVAL_COUNT__ = (globalThis.__NS_CORE_EVAL_COUNT__ || 0) + 1;`,
                         `} } catch (e) { try { console.warn('[ns-core] instrumentation failed:', (e && e.message) || e); } catch {} }`,
                     ].join('\n');
-                    // Invariant D (CJS/ESM interop shape) — REGISTRATION side.
+                    // CJS/ESM interop shape — REGISTRATION side.
                     //
                     // The actual shape installer runs earlier in the module
                     // body (between preamble and selfImport; see
@@ -4021,9 +4230,6 @@ export const piniaSymbol = p.piniaSymbol;
                     // registration — the shape function is identity-preserving
                     // via WeakMap — gives a stable, shared, CJS-compatible
                     // view without copying on every require.
-                    //
-                    // See HMR_CORE_REALM_DETERMINISTIC_PLAN.md § "Invariant D"
-                    // for the full rationale.
                     const registrationFooter = [
                         `try { if (typeof globalThis !== 'undefined') {`,
                         `  const __nsReg = globalThis.__NS_CORE_MODULES__ || (globalThis.__NS_CORE_MODULES__ = Object.create(null));`,
@@ -4135,7 +4341,8 @@ export const piniaSymbol = p.piniaSymbol;
                             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');
+                    if (verbose)
+                        console.log('[hmr-http] /ns/entry-rt serving', content.length, 'bytes');
                     res.statusCode = 200;
                     res.end(content);
                 }
@@ -5868,6 +6075,101 @@ export const piniaSymbol = p.piniaSymbol;
             if (isRuntimeGraphExcludedPath(file)) {
                 return;
             }
+            // Always-on update timing. Captures the four phases (await,
+            // framework, broadcast, total) plus invalidated module count
+            // and recipient count. Emitted at the end of this function via
+            // `emitHmrUpdateSummary()`. Single line, always-on so a
+            // 6-second `.ts` save is immediately visible without flipping
+            // verbose.
+            const updateRoot = server.config.root || process.cwd();
+            const updateRel = (() => {
+                try {
+                    return '/' + path.posix.normalize(path.relative(updateRoot, file)).split(path.sep).join('/');
+                }
+                catch {
+                    return file;
+                }
+            })();
+            const updateMetrics = {
+                file: updateRel,
+                kind: classifyHmrUpdateKind(file),
+                t0: Date.now(),
+                tAfterAwait: 0,
+                tAfterFramework: 0,
+                tEnd: 0,
+                invalidated: 0,
+                recipients: 0,
+                // Narrowing diagnostic — populated by the angular branch when
+                // the changed file is `.ts`, otherwise remains undefined and is
+                // omitted from the summary line entirely.
+                narrowed: undefined,
+                emitted: false,
+            };
+            // Broadcast a "pending" notification at the very start of
+            // handleHotUpdate so the client can show the HMR-applying
+            // overlay BEFORE we spend time on graph updates / transforms /
+            // dependency analysis (typically 7–200ms on a warm cache).
+            // Without this, the overlay only appears at `ns:angular-update`
+            // broadcast time and the user perceives a "delayed" reaction
+            // to their save.
+            //
+            // Fire-and-forget: a failed pending broadcast must never
+            // hold up the actual update. The client treats receipt of
+            // `ns:angular-update` (or `ns:css-updates`) as authoritative;
+            // the pending message is purely a UX hint.
+            try {
+                const pendingPayload = JSON.stringify(createHmrPendingMessage({
+                    origin: getServerOrigin(server),
+                    path: updateMetrics.file,
+                    kind: updateMetrics.kind,
+                    timestamp: updateMetrics.t0,
+                }));
+                wss.clients.forEach((client) => {
+                    if (isSocketClientOpen(client)) {
+                        try {
+                            client.send(pendingPayload);
+                        }
+                        catch { }
+                    }
+                });
+            }
+            catch { }
+            const emitHmrUpdateSummary = () => {
+                if (updateMetrics.emitted)
+                    return;
+                updateMetrics.emitted = true;
+                updateMetrics.tEnd = Date.now();
+                try {
+                    const awaitMs = (updateMetrics.tAfterAwait || updateMetrics.t0) - updateMetrics.t0;
+                    const frameworkMs = (updateMetrics.tAfterFramework || updateMetrics.tAfterAwait || updateMetrics.t0) - (updateMetrics.tAfterAwait || updateMetrics.t0);
+                    const broadcastMs = updateMetrics.tEnd - (updateMetrics.tAfterFramework || updateMetrics.tAfterAwait || updateMetrics.t0);
+                    const totalMs = updateMetrics.tEnd - updateMetrics.t0;
+                    console.info(formatHmrUpdateSummary({
+                        file: updateMetrics.file,
+                        kind: updateMetrics.kind,
+                        awaitMs,
+                        frameworkMs,
+                        broadcastMs,
+                        totalMs,
+                        invalidated: updateMetrics.invalidated,
+                        recipients: updateMetrics.recipients,
+                        narrowed: updateMetrics.narrowed,
+                    }));
+                }
+                catch { }
+            };
+            // The first /ns/m request kicks off populateInitialGraph in the
+            // background. If an HMR update races in before that walk
+            // completes, we'd lose transitive-importer data. Await
+            // completion here so the delta computation below always sees a
+            // populated graph.
+            if (graphInitialPopulationPromise) {
+                try {
+                    await graphInitialPopulationPromise;
+                }
+                catch { }
+            }
+            updateMetrics.tAfterAwait = Date.now();
             // Graph update for this file change (wrapped to avoid aborting rest of handler)
             try {
                 const skipAngularHtmlGraphUpdate = ACTIVE_STRATEGY.flavor === 'angular' && /\.(html|htm)$/i.test(file);
@@ -5917,6 +6219,7 @@ export const piniaSymbol = p.piniaSymbol;
                 console.log(`[hmr-ws] Hot update for: ${file}`);
             // Handle CSS updates
             if (file.endsWith('.css')) {
+                updateMetrics.tAfterFramework = Date.now();
                 try {
                     let rel = '/' + path.posix.normalize(path.relative(root, file)).split(path.sep).join('/');
                     const origin = getServerOrigin(server);
@@ -5935,12 +6238,14 @@ export const piniaSymbol = p.piniaSymbol;
                     wss.clients.forEach((client) => {
                         if (isSocketClientOpen(client)) {
                             client.send(JSON.stringify(msg));
+                            updateMetrics.recipients += 1;
                         }
                     });
                 }
                 catch (error) {
                     console.warn('[hmr-ws] CSS update failed:', error);
                 }
+                emitHmrUpdateSummary();
                 return;
             }
             // Framework-specific hot update handling
@@ -5956,6 +6261,7 @@ export const piniaSymbol = p.piniaSymbol;
                 });
                 if (!(isHtml || isTs))
                     return;
+                updateMetrics.invalidated += angularHotUpdateRoots.length;
                 if (angularHotUpdateRoots.length) {
                     for (const mod of angularHotUpdateRoots) {
                         try {
@@ -5972,13 +6278,80 @@ export const piniaSymbol = p.piniaSymbol;
                     }
                 }
                 const angularTransitiveInvalidationRoots = (angularHotUpdateRoots.length ? angularHotUpdateRoots : ctx.modules);
-                if (shouldInvalidateAngularTransitiveImporters({ flavor: ACTIVE_STRATEGY.flavor, file })) {
+                // Read the source for `.ts/.tsx/.js/.jsx` edits so
+                // `shouldInvalidateAngularTransitiveImporters` can
+                // distinguish leaf modules (constants/utils) from real
+                // Angular files. If `ctx.read()` throws (file deleted, race
+                // against the watcher), `angularChangedSource` stays
+                // undefined and we fall back to the conservative "always
+                // invalidate transitively" behavior.
+                let angularChangedSource;
+                if (isTs) {
                     try {
-                        const transitiveImporters = collectAngularTransitiveImportersForInvalidation({
-                            modules: angularTransitiveInvalidationRoots,
-                            isExcluded: (id) => id.includes('/node_modules/'),
-                            maxDepth: 16,
-                        });
+                        angularChangedSource = await ctx.read();
+                    }
+                    catch {
+                        angularChangedSource = undefined;
+                    }
+                }
+                const angularNeedsTransitive = shouldInvalidateAngularTransitiveImporters({
+                    flavor: ACTIVE_STRATEGY.flavor,
+                    file,
+                    source: angularChangedSource,
+                });
+                // Surface the narrowing decision on every `.ts` Angular hot
+                // update (HTML routes always invalidate transitively and
+                // aren't subject to narrowing, so we leave them as
+                // `undefined` — the field is omitted from the summary line).
+                // The boolean is the inverse of `angularNeedsTransitive`
+                // because "needs transitive" is the broad (un-narrowed)
+                // behavior.
+                if (isTs) {
+                    updateMetrics.narrowed = !angularNeedsTransitive;
+                }
+                // Stable URL + Explicit Invalidation:
+                //
+                // Compute the transitive importer closure ONCE here and reuse
+                // it for (a) `server.moduleGraph.invalidateModule` (so Vite's
+                // transform pipeline re-runs on next request), (b) the shared
+                // transform-request cache, and (c) the runtime eviction set
+                // we broadcast in `ns:angular-update`. Consolidating this
+                // removes a redundant graph walk and guarantees the three
+                // consumers see the exact same set of importers (otherwise a
+                // late module-graph mutation between calls could leave an
+                // asymmetric narrowed/broad mix).
+                //
+                // We separate Vite-transform narrowing from runtime eviction:
+                // `angularNeedsTransitive` answers the question "does the
+                // changed file's symbol shape change such that importers
+                // must be re-transformed by Vite?". The runtime, however,
+                // has a stricter requirement: ESM live bindings only refresh
+                // if the importing module re-evaluates inside V8. A
+                // constants file with no Angular decorator does NOT need a
+                // Vite re-transform of its importers (their compiled JS is
+                // identical), but its importers still hold stale bindings to
+                // the OLD constants Module record. After eviction + re-import
+                // of `main.ts`, V8 sees the cached importers, returns them
+                // unchanged, and they continue to read the OLD values. The
+                // user-visible symptom: HMR completes successfully, logs are
+                // clean, but the simulator does not reflect the change.
+                //
+                // The fix: ALWAYS compute the transitive importer closure
+                // for runtime eviction. Only skip Vite's
+                // `moduleGraph.invalidate` + transform-cache purge when
+                // `angularNeedsTransitive` is false — those are the genuine
+                // narrowing wins (saves re-transform work on the server).
+                // The eviction set always includes importers so V8 re-fetches
+                // and re-binds them.
+                let transitiveImporters = [];
+                try {
+                    transitiveImporters = collectAngularTransitiveImportersForInvalidation({
+                        modules: angularTransitiveInvalidationRoots,
+                        isExcluded: (id) => id.includes('/node_modules/'),
+                        maxDepth: 16,
+                    });
+                    if (angularNeedsTransitive) {
+                        updateMetrics.invalidated += transitiveImporters.length;
                         for (const mod of transitiveImporters) {
                             try {
                                 server.moduleGraph.invalidateModule(mod);
@@ -5993,24 +6366,39 @@ export const piniaSymbol = p.piniaSymbol;
                             console.log('[hmr-ws][angular] invalidated transitive importers:', transitiveImporters.length);
                         }
                     }
-                    catch (error) {
-                        if (verbose)
-                            console.warn('[hmr-ws][angular] transitive importer collection failed', error);
+                    else if (isTs && typeof angularChangedSource === 'string') {
+                        // Surfacing this log unconditionally lets the user
+                        // immediately confirm whether narrowing fired for a
+                        // given `.ts` edit (the summary line below still
+                        // emits `narrowed=yes`/`no`, but having both makes
+                        // the decision easier to spot in noisy logs and lets
+                        // the user diff scenarios without flipping
+                        // `NS_HMR_VERBOSE=true`).
+                        //
+                        // Narrowing means "skip Vite re-transform" (the
+                        // importers still get evicted from the V8 module
+                        // registry so live bindings refresh). The importer
+                        // count is appended so the distinction is visible.
+                        console.log(`[hmr-ws][angular] narrowed transitive invalidation (no @Component/@Directive/@Pipe/@Injectable/@NgModule): ${updateRel} — Vite transform skipped, runtime eviction includes ${transitiveImporters.length} importer(s)`);
                     }
                 }
+                catch (error) {
+                    if (verbose)
+                        console.warn('[hmr-ws][angular] transitive importer collection failed', error);
+                }
                 try {
-                    const transitiveImporters = shouldInvalidateAngularTransitiveImporters({ flavor: ACTIVE_STRATEGY.flavor, file })
-                        ? collectAngularTransitiveImportersForInvalidation({
-                            modules: angularTransitiveInvalidationRoots,
-                            isExcluded: (id) => id.includes('/node_modules/'),
-                            maxDepth: 16,
-                        })
-                        : [];
+                    // Purge shared transform cache for the changed file +
+                    // hot-update roots unconditionally (their transform
+                    // output IS different now). Transitive importers are
+                    // only purged when narrowing decides their output may
+                    // have changed; otherwise their cached transforms are
+                    // still valid (compiled JS is identical even though the
+                    // runtime must re-evaluate them to refresh ESM bindings).
                     const transformCacheInvalidationUrls = new Set(collectAngularTransformCacheInvalidationUrls({
                         file,
                         isTs,
                         hotUpdateRoots: angularHotUpdateRoots,
-                        transitiveImporters,
+                        transitiveImporters: angularNeedsTransitive ? transitiveImporters : [],
                         projectRoot: server.config.root || process.cwd(),
                     }));
                     if (transformCacheInvalidationUrls.size) {
@@ -6024,17 +6412,74 @@ export const piniaSymbol = p.piniaSymbol;
                     if (verbose)
                         console.warn('[hmr-ws][angular] shared transform cache purge failed', error);
                 }
+                updateMetrics.tAfterFramework = Date.now();
                 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 bootstrapEntryRel = getBootstrapEntryRelPath();
+                    // Stable URL + Explicit Invalidation:
+                    //
+                    // `evictPaths` is the canonical list of `/ns/m/<rel>` URLs
+                    // the runtime must drop from `g_moduleRegistry` before
+                    // re-importing `importerEntry`. Older versions of the
+                    // server signaled invalidation by bumping a global
+                    // `graphVersion` counter and embedding it in every URL —
+                    // but V8 keys the module registry by full URL, so a v1 →
+                    // v2 bump effectively flushed the entire dependency
+                    // graph from the cache and forced the runtime to
+                    // re-fetch + re-eval every transitively-imported module
+                    // on each save (~3s HMR cycles, dominated by Vite's
+                    // single-threaded transform pipeline). The new model:
+                    //
+                    //   1. URLs are stable: `/ns/m/<rel>` everywhere, no `vN`.
+                    //   2. The server walks the inverse-dependency closure and
+                    //      sends only the modules that actually need to be
+                    //      re-evaluated (typically O(1) for component edits,
+                    //      or the changed file + entry for narrowed edits).
+                    //   3. The client calls `__nsInvalidateModules(evictPaths)`
+                    //      and re-imports `importerEntry`, which causes V8 to
+                    //      refetch ONLY those modules. Everything else stays
+                    //      hot in the registry.
+                    //
+                    // Invariants enforced by `collectAngularEvictionUrls`:
+                    //   - Always includes the changed file (so the new source
+                    //     is fetched).
+                    //   - Always includes `importerEntry` (so re-import
+                    //     re-evaluates).
+                    //   - Excludes node_modules (vendor packages are stable).
+                    //   - Excludes virtual / runtime-graph-excluded ids.
+                    //   - Origin-prefixed: `http://host:port/ns/m/<rel>`.
+                    let evictPaths = [];
+                    try {
+                        evictPaths = collectAngularEvictionUrls({
+                            file,
+                            hotUpdateRoots: angularHotUpdateRoots,
+                            transitiveImporters,
+                            projectRoot: root,
+                            origin,
+                            bootstrapEntry: bootstrapEntryRel,
+                        });
+                    }
+                    catch (error) {
+                        if (verbose)
+                            console.warn('[hmr-ws][angular] eviction set computation failed', error);
+                    }
+                    if (verbose) {
+                        console.log('[hmr-ws][angular] eviction set', {
+                            count: evictPaths.length,
+                            importerEntry: bootstrapEntryRel,
+                        });
+                    }
                     const msg = {
                         type: 'ns:angular-update',
                         origin,
                         path: rel,
                         version: graphVersion,
                         timestamp: Date.now(),
+                        evictPaths,
+                        importerEntry: bootstrapEntryRel,
                     };
                     if (verbose) {
                         console.log('[hmr-ws][angular] broadcasting update', Array.from(wss.clients || []).map((client) => ({
@@ -6046,12 +6491,14 @@ export const piniaSymbol = p.piniaSymbol;
                     wss.clients.forEach((client) => {
                         if (isSocketClientOpen(client)) {
                             client.send(JSON.stringify(msg));
+                            updateMetrics.recipients += 1;
                         }
                     });
                 }
                 catch (error) {
                     console.warn('[hmr-ws][angular] update failed:', error);
                 }
+                emitHmrUpdateSummary();
                 if (shouldSuppressDefaultViteHotUpdate({ flavor: ACTIVE_STRATEGY.flavor, file })) {
                     return [];
                 }
@@ -6059,6 +6506,7 @@ export const piniaSymbol = p.piniaSymbol;
             }
             // TypeScript flavor: emit generic graph delta for app XML/TS/style changes
             if (ACTIVE_STRATEGY.flavor === 'typescript') {
+                updateMetrics.tAfterFramework = Date.now();
                 try {
                     const rel = '/' + path.posix.normalize(path.relative(root, file)).split(path.sep).join('/');
                     if (verbose)
@@ -6072,6 +6520,7 @@ export const piniaSymbol = p.piniaSymbol;
                     if (verbose)
                         console.warn('[hmr-ws][ts] failed to emit delta for', file, e);
                 }
+                emitHmrUpdateSummary();
                 return;
             }
             // Solid flavor: emit graph delta for app TSX/TS/JSX file changes.
@@ -6085,6 +6534,7 @@ export const piniaSymbol = p.piniaSymbol;
                 const isSolidFile = /\.(tsx?|jsx?)$/i.test(file);
                 if (!isSolidFile)
                     return;
+                updateMetrics.tAfterFramework = Date.now();
                 try {
                     const rel = '/' + path.posix.normalize(path.relative(root, file)).split(path.sep).join('/');
                     if (verbose)
@@ -6109,6 +6559,7 @@ export const piniaSymbol = p.piniaSymbol;
                     if (verbose)
                         console.warn('[hmr-ws][solid] failed to handle hot update for', file, e);
                 }
+                emitHmrUpdateSummary();
                 return;
             }
             // Handle .vue file updates
@@ -6117,7 +6568,8 @@ export const piniaSymbol = p.piniaSymbol;
                     console.log('[hmr-ws] Not a .vue file, skipping');
                 return;
             }
-            console.log('[hmr-ws] Processing .vue file update...');
+            if (verbose)
+                console.log('[hmr-ws] Processing .vue file update...');
             try {
                 const root = server.config.root || process.cwd();
                 let rel = '/' + path.posix.normalize(path.relative(root, file)).split(path.sep).join('/');
@@ -6394,6 +6846,10 @@ if (typeof __VUE_HMR_RUNTIME__ === 'undefined') {
                 console.warn('[hmr-ws] HMR update failed:', error);
                 console.error(error);
             }
+            // Vue path emits update summary at the end of the function so
+            // every framework branch gets exactly one log line. Idempotent
+            // — if any branch already emitted, this is a no-op.
+            emitHmrUpdateSummary();
             // CRITICAL: Return empty array to prevent Vite's default HMR
             return [];
         },