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

package/hmr/server/websocket.js

@@ -1,53 +1,64 @@
 import { createRequire } from 'node:module';
 import { normalizeStrayCoreStringLiterals, fixDanglingCoreFrom, normalizeAnyCoreSpecToBridge, isDeepCoreSubpath, rewriteSpecifiersForDevice } from './core-sanitize.js';
+import { buildDefaultExportFooter, buildShapeInstallHeader, hasNamespaceReExport, rewriteNamespaceReExportsForShape } from './ns-core-cjs-shape.js';
 // AST tooling for robust transformations
 import { parse as babelParse } from '@babel/parser';
 import { genCode } from '../helpers/babel.js';
+import babelCore from '@babel/core';
 import traverse from '@babel/traverse';
 // Ensure traverse callable across CJS/ESM builds
 const babelTraverse = traverse?.default || traverse;
 import * as t from '@babel/types';
 import { existsSync, readFileSync, statSync } from 'fs';
 import { astNormalizeModuleImportsAndHelpers, astVerifyAndAnnotateDuplicates } from '../helpers/ast-normalizer.js';
-import { stripDanglingViteCjsImports } from '../helpers/sanitize.js';
+import { stripRtCoreSentinel, stripDanglingViteCjsImports } from '../helpers/sanitize.js';
 import { WebSocketServer } from 'ws';
 import * as path from 'path';
 import { createHash } from 'crypto';
 import * as PAT from './constants.js';
 import { getVendorManifest, resolveVendorSpecifier } from '../shared/vendor/registry.js';
-import { getProjectRootPath } from '../../helpers/project.js';
+import { getPackageJson, getProjectFilePath, getProjectRootPath } from '../../helpers/project.js';
 import { loadPrebuiltVendorManifest } from '../shared/vendor/manifest-loader.js';
 import '../vendor-bootstrap.js';
+import { NS_NATIVE_TAGS } from './compiler.js';
+import { vueSfcCompiler } from '../frameworks/vue/server/compiler.js';
 import { linkAngularPartialsIfNeeded } from '../frameworks/angular/server/linker.js';
 import { vueServerStrategy } from '../frameworks/vue/server/strategy.js';
 import { angularServerStrategy } from '../frameworks/angular/server/strategy.js';
 import { solidServerStrategy } from '../frameworks/solid/server/strategy.js';
 import { typescriptServerStrategy } from '../frameworks/typescript/server/strategy.js';
-import { createProcessSfcCode } from '../frameworks/vue/server/sfc-transforms.js';
+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';
+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 { buildVersionedCoreMainBridgeModule, buildVersionedCoreSubpathAliasModule, collectStaticExportNamesFromFile, collectStaticExportOriginsFromFile, ensureVersionedCoreImports, extractDirectExportedNames, hasModuleDefaultExport, normalizeCoreExportOriginsForRuntime, parseCoreBridgeRequest, resolveRuntimeCoreModulePath } from './websocket-core-bridge.js';
-import { finalizeNsMServedModule } from './websocket-ns-m-finalize.js';
-import { createNsMRequestContext, resolveNsMTransformedModule } from './websocket-ns-m-request.js';
-import { getNumericServeVersionTag, rewriteNsMImportPathForHmr } from './websocket-ns-m-paths.js';
-import { registerRuntimeCompatHandlers } from './websocket-runtime-compat.js';
-import { registerTxnHandler } from './websocket-txn.js';
-import { registerVendorUnifierHandler } from './websocket-vendor-unifier.js';
-import { registerVueSfcHandlers } from './websocket-vue-sfc.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 { buildVersionedCoreMainBridgeModule, buildVersionedCoreSubpathAliasModule, collectStaticExportNamesFromFile, collectStaticExportOriginsFromFile, ensureVersionedCoreImports, normalizeCoreExportOriginsForRuntime, parseCoreBridgeRequest } from './websocket-core-bridge.js';
-export { rewriteNsMImportPathForHmr } from './websocket-ns-m-paths.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');
+    return loaded?.default || loaded;
+})();
 // 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.
@@ -63,11 +74,40 @@ try {
 }
 catch { }
 const __processEnvJson = JSON.stringify(__processEnvEntries);
+const { parse, compileTemplate, compileScript } = vueSfcCompiler;
 const APP_ROOT_DIR = getProjectAppPath();
 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');
+// alpha.59 — Stable URL + Explicit Invalidation:
+// 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],
@@ -314,44 +354,12 @@ 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) {
+// alpha.59 — `ensureDynamicHmrImportHelper` was previously duplicated
+// here. Single source of truth now lives in
+// `./websocket-served-module-helpers.js`. See that file for the
+// architectural rationale and the current (much smaller) 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 = [];
@@ -363,25 +371,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;
 }
@@ -890,6 +914,14 @@ function toNodeModulesHttpModuleId(importPath) {
     }
     return `/ns/m/node_modules/${nodeModulesSpecifier}`;
 }
+// alpha.59 — `rewriteNsMImportPathForHmr` and `getNumericServeVersionTag`
+// previously lived here as duplicates of the implementations in
+// `./websocket-ns-m-paths.js`. The path rewriter is part of the
+// "Stable URL + Explicit Invalidation" architecture (see
+// HMR_STABLE_URL_INVALIDATION_PLAN.md) and must be a single source of
+// truth so the canonicalization rules can't drift between the two files.
+// 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;
@@ -1049,8 +1081,31 @@ export function wrapCommonJsModuleForDevice(code) {
             `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` +
+            // Resolve relative specifiers against the HTTP-served module's URL
+            // before delegating to NS's runtime require. Without this step,
+            // \`require('./base64-vlq')\` inside a CJS module served from
+            // \`http://.../ns/m/node_modules/source-map-js/lib/source-map-generator.js\`
+            // would pass a literal '"./base64-vlq"' to the native require, which
+            // has no notion of the current HTTP-module's location and either
+            // throws "Module not found" or fetches an arbitrary filesystem path
+            // that happens to parse as code (producing misleading syntax errors
+            // like "missing ) after argument list" from unrelated modules).
+            `  var __nsResolvedSpec = spec;\n` +
+            `  try {\n` +
+            `    if (typeof spec === 'string' && (spec.indexOf('./') === 0 || spec.indexOf('../') === 0)) {\n` +
+            `      var __nsParentUrl = (typeof import.meta !== 'undefined' && import.meta && typeof import.meta.url === 'string') ? import.meta.url : null;\n` +
+            `      if (__nsParentUrl) {\n` +
+            `        var __nsResolvedUrl = new URL(spec, __nsParentUrl);\n` +
+            `        // Common Node-style bare extensions: prefer .js if the resolved URL lacks an extension in its last path segment.\n` +
+            `        if (!/\\.[A-Za-z0-9]+$/.test(__nsResolvedUrl.pathname.split('/').pop() || '')) {\n` +
+            `          __nsResolvedUrl.pathname = __nsResolvedUrl.pathname.replace(/\\/+$/, '') + '.js';\n` +
+            `        }\n` +
+            `        __nsResolvedSpec = __nsResolvedUrl.href;\n` +
+            `      }\n` +
+            `    }\n` +
+            `  } catch (e) {}\n` +
+            `  try { var __nsRecord = globalThis.__NS_RECORD_MODULE_PROVENANCE__; if (typeof __nsRecord === 'function') { __nsRecord(String(__nsResolvedSpec), { kind: __ns_cjs_require_kind, specifier: String(spec), url: __nsResolvedSpec !== spec ? __nsResolvedSpec : undefined, 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(__nsResolvedSpec);\n` +
             `  try {\n` +
             `    if (mod && (typeof mod === 'object' || typeof mod === 'function') && mod.default !== undefined) {\n` +
             `      var keys = [];\n` +
@@ -2096,6 +2151,27 @@ export function rewriteImports(code, importerPath, sfcFileMap, depFileMap, proje
                 return `${prefix}./${depFile}${suffix}`;
             }
         }
+        // Bare npm package specifier fallback — route to /ns/m/node_modules/.
+        // This catches specifiers like `source-map-js/lib/source-map-generator.js`
+        // emitted by helpers such as the CommonJS compat transform, which Vite
+        // would normally resolve to an absolute path but which pass through the
+        // rewriter as bare strings here. Under HMR (core external) bundle.mjs
+        // depends on these resolving over HTTP rather than via a filesystem
+        // bare-specifier lookup, which iOS can't satisfy and which crashes with
+        // "Module not found".
+        if (spec && !spec.startsWith('/') && !spec.startsWith('./') && !spec.startsWith('../') && !/^https?:\/\//i.test(spec) && !spec.startsWith('ns-vendor:') && !spec.startsWith('@nativescript/core')) {
+            // Only treat as a package spec if it looks like one — disallow
+            // plain identifiers like `moment` unresolved (those are left alone
+            // for existing vendor-routing paths to handle).
+            const bareNpmRe = /^(?:@[A-Za-z0-9][\w.-]*\/)?[A-Za-z0-9][\w.-]*(?:\/[\w.\-/]+)?$/;
+            if (bareNpmRe.test(spec)) {
+                const httpSpec = `/ns/m/node_modules/${spec}`;
+                if (httpOriginSafe) {
+                    return `${prefix}${httpOriginSafe}${httpSpec}${suffix}`;
+                }
+                return `${prefix}${httpSpec}${suffix}`;
+            }
+        }
         // Leave everything else unchanged (vendor imports, etc.)
         return `${prefix}${spec}${suffix}`;
     };
@@ -2237,10 +2313,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);
@@ -2412,12 +2499,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 { }
@@ -2445,6 +2537,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;
@@ -2460,6 +2554,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))
@@ -2474,7 +2580,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
@@ -2485,7 +2591,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 described in Track 1.3 of the HMR plan.
+                                upsertGraphModule(rel, code, deps, { bumpVersion: false });
                             }
                             catch { }
                         }
@@ -2498,6 +2607,36 @@ function createHmrWebSocketPlugin(opts) {
             await walk(pathMod.join(root, 'src'));
         }
         catch { }
+        // Diagnostic summary: Always-on so slow
+        // cold-boot walks surface even when verbose is off. A `bumpedVersion=no`
+        // result is the happy path (Track 1.3); `yes` indicates a regression.
+        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',
@@ -2526,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 (Track 1.4 in HMR_CORE_REALM_DETERMINISTIC_PLAN.md). We cap
+            // at 8 by default to match typical dev machines and respect Vite's
+            // internal worker pool limits. Override via the 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.
+            // See Track 2.2 in HMR_CORE_REALM_DETERMINISTIC_PLAN.md.
+            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)');
@@ -2542,6 +2691,120 @@ 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. See HMR_CORE_REALM_DETERMINISTIC_PLAN.md
+            // ("Track 1 + 2 — diagnostic instrumentation").
+            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 { }
+                }
+                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.
+            // See HMR_CORE_REALM_DETERMINISTIC_PLAN.md ("Track 1 + 2 — round
+            // three, 2026-04").
+            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,
+                        log: (line) => {
+                            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. See
+            // HMR_CORE_REALM_DETERMINISTIC_PLAN.md ("Track 1 + 2 — round
+            // three").
+            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;
@@ -2816,27 +3079,137 @@ function createHmrWebSocketPlugin(opts) {
                     const urlObj = new URL(req.url || '', 'http://localhost');
                     if (!urlObj.pathname.startsWith('/ns/m'))
                         return next();
+                    // 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).
+                    //
+                    // Track 1.3: 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
                     res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0');
                     res.setHeader('Pragma', 'no-cache');
                     res.setHeader('Expires', '0');
-                    const serverRoot = (server.config?.root || process.cwd());
-                    const requestContextResult = createNsMRequestContext(req.url || '', serverRoot, APP_VIRTUAL_WITH_SLASH);
-                    if (requestContextResult.kind === 'next')
-                        return next();
-                    if (requestContextResult.kind === 'response') {
-                        res.statusCode = requestContextResult.statusCode;
-                        res.end(requestContextResult.code);
+                    // Support both query (?path=/abs) and path-style (/ns/m/abs)
+                    let spec = urlObj.searchParams.get('path') || '';
+                    // Optional graph version pin for deterministic boot
+                    let forcedVer = urlObj.searchParams.get('v');
+                    let bootTaggedRequest = false;
+                    if (!spec) {
+                        const base = '/ns/m';
+                        let rest = urlObj.pathname.slice(base.length);
+                        if (rest && rest !== '/')
+                            spec = rest;
+                    }
+                    // Special-case stub for anomalous '@' imports emitted as '/__invalid_at__.mjs'
+                    if (spec === '/__invalid_at__.mjs' || spec === '__invalid_at__.mjs') {
+                        res.statusCode = 200;
+                        res.end("// invalid '@' import stub\nexport {}\n");
+                        return;
+                    }
+                    if (!spec) {
+                        res.statusCode = 200;
+                        res.end('export {}\n');
                         return;
                     }
-                    let { spec, forcedVer, bootTaggedRequest, transformCandidates, candidates } = requestContextResult.value;
+                    const serverRoot = (server.config?.root || process.cwd());
+                    spec = spec.replace(/[?#].*$/, '');
+                    // 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 decorated = stripDecoratedServePrefixes(spec);
+                        spec = decorated.cleanedSpec;
+                        bootTaggedRequest = decorated.bootTaggedRequest;
+                        forcedVer || (forcedVer = decorated.forcedVer);
+                    }
+                    catch { }
+                    // Normalize absolute filesystem paths back to project-relative ids (e.g. /src/app.ts)
+                    try {
+                        const toPosix = (p) => p.replace(/\\/g, '/');
+                        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
+                        if (isAbsFs) {
+                            let rel = specPosix.startsWith(rootPosix) ? specPosix.slice(rootPosix.length) : require('path').posix.relative(rootPosix, specPosix);
+                            if (!rel.startsWith('..')) {
+                                if (!rel.startsWith('/'))
+                                    rel = '/' + rel;
+                                // Ensure leading '/src' style when path maps into src
+                                spec = rel;
+                            }
+                        }
+                    }
+                    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('./'))
+                        spec = spec.slice(1);
+                    const blockedNodeModulesReason = getBlockedDeviceNodeModulesReason(spec);
+                    if (blockedNodeModulesReason) {
+                        res.statusCode = 404;
+                        res.end(`// [ns:m] blocked device import\nthrow new Error(${JSON.stringify(`[ns/m] ${blockedNodeModulesReason}`)});\nexport {};\n`);
+                        return;
+                    }
+                    if (!spec.startsWith('/'))
+                        spec = '/' + spec;
+                    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;
+                    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
@@ -2844,15 +3217,86 @@ function createHmrWebSocketPlugin(opts) {
                     const transformWithTimeout = (url, timeoutMs = 120000) => {
                         return sharedTransformRequest(url, timeoutMs);
                     };
-                    ({ transformed, resolvedCandidate } = await resolveNsMTransformedModule({
-                        context: requestContextResult.value,
-                        transformRequest: transformWithTimeout,
-                        resolveId: async (id) => {
-                            const resolved = await server.pluginContainer?.resolveId?.(id, undefined);
-                            return typeof resolved === 'string' ? resolved : resolved?.id || null;
-                        },
-                        loadVirtualId: async (id) => await server.pluginContainer.load(id),
-                    }));
+                    if (!transformed?.code) {
+                        for (const cand of transformCandidates) {
+                            try {
+                                const r = await transformWithTimeout(cand);
+                                if (r?.code) {
+                                    transformed = r;
+                                    resolvedCandidate = cand;
+                                    break;
+                                }
+                            }
+                            catch { }
+                        }
+                    }
+                    // Fallback 1: ask Vite to resolve the id, then transform the resolved id (handles aliases and virtual ids)
+                    if (!transformed?.code) {
+                        try {
+                            const rid = await server.pluginContainer?.resolveId?.(spec, undefined);
+                            const ridStr = typeof rid === 'string' ? rid : rid?.id || null;
+                            if (ridStr) {
+                                const r = await transformWithTimeout(ridStr);
+                                if (r?.code) {
+                                    transformed = r;
+                                    resolvedCandidate = ridStr;
+                                }
+                            }
+                        }
+                        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 toPosix = (p) => p.replace(/\\/g, '/');
+                            const rootPosix = toPosix(serverRoot).replace(/\/$/, '');
+                            const absPosix = `${rootPosix}${spec.startsWith('/') ? '' : '/'}${spec}`;
+                            const fsId = `/@fs${absPosix}`;
+                            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 transformCandidates) {
+                            try {
+                                const r = await transformWithTimeout(`${cand}${cand.includes('?') ? '&' : '?'}import`);
+                                if (r?.code) {
+                                    transformed = r;
+                                    resolvedCandidate = `${cand}?import`;
+                                    break;
+                                }
+                            }
+                            catch { }
+                        }
+                    }
                     // 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
@@ -2930,7 +3374,9 @@ function createHmrWebSocketPlugin(opts) {
                                             }
                                             catch { }
                                         }
-                                        upsertGraphModule(id, code, deps);
+                                        // Serve-time warm-up: no live edit happened, so don't bump
+                                        // graphVersion. See Track 1.3 in HMR_CORE_REALM_DETERMINISTIC_PLAN.md.
+                                        upsertGraphModule(id, code, deps, { bumpVersion: false });
                                     }
                                 }
                             }
@@ -3055,47 +3501,200 @@ export const piniaSymbol = p.piniaSymbol;
                             }
                         }
                     }
+                    let code = transformed.code;
+                    // Prepend guard to capture any URL-based require attempts
+                    code = REQUIRE_GUARD_SNIPPET + code;
+                    code = cleanCode(code);
+                    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.
                     const projectRoot = server.config?.root || process.cwd();
                     const serverOrigin = getServerOrigin(server);
-                    let code;
+                    if (ACTIVE_STRATEGY?.flavor === 'angular') {
+                        code = prepareAngularEntryForDevice(code, resolvedCandidate || spec, sfcFileMap, depFileMap, projectRoot, !!verbose, undefined, serverOrigin, true);
+                    }
+                    else {
+                        code = rewriteImports(code, resolvedCandidate || spec, sfcFileMap, depFileMap, projectRoot, !!verbose, undefined, serverOrigin, 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 finalizeNsMServedModule({
-                            code: transformed.code,
-                            spec,
-                            resolvedCandidate,
-                            forcedVer,
-                            bootTaggedRequest,
-                            graphVersion: Number(graphVersion || 0),
-                            serverOrigin,
-                            strategy: ACTIVE_STRATEGY,
-                            helpers: {
-                                requireGuardSnippet: REQUIRE_GUARD_SNIPPET,
-                                cleanCode,
-                                processCodeForDevice: (value, sourceId) => processCodeForDevice(value, false, true, /(?:^|\/)node_modules\//.test(sourceId || spec || ''), sourceId || spec),
-                                rewriteImports: (value, importerPath) => rewriteImports(value, importerPath, sfcFileMap, depFileMap, projectRoot, !!verbose, undefined, serverOrigin, true),
-                                rewriteAngularEntry: (value, importerPath) => prepareAngularEntryForDevice(value, importerPath, sfcFileMap, depFileMap, projectRoot, !!verbose, undefined, serverOrigin, true),
-                                expandStarExports: async (value) => expandStarExports(value, server, projectRoot, verbose),
-                                dedupeRtNamedImportsAgainstDestructures,
-                                ensureVariableDynamicImportHelper,
-                                ensureGuardPlainDynamicImports,
-                                deduplicateLinkerImports,
-                                wrapCommonJsModuleForDevice,
-                                assertNoOptimizedArtifacts,
-                                ensureVersionedRtImports,
-                                ensureDestructureCoreImports,
-                                buildBootProgressSnippet,
-                                hoistTopLevelStaticImports,
-                                warn: (message, error) => {
-                                    if (verbose)
-                                        console.warn(`${message}:`, error?.message || error);
-                                },
-                            },
-                        });
+                        code = await expandStarExports(code, server, server.config?.root || process.cwd(), verbose, sharedTransformRequest);
+                    }
+                    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);
+                    }
+                    catch { }
+                    code = ensureVariableDynamicImportHelper(code);
+                    // Final safety: guard any plain dynamic import(...) occurrences to reroute anomalous '@' specs
+                    try {
+                        code = ensureGuardPlainDynamicImports(code, getServerOrigin(server));
+                    }
+                    catch { }
+                    // Extra hardening: normalize any remaining core references to the unified bridge
+                    // - Stray string-literals
+                    // - Dangling `from` merges
+                    // - Any spec (including /node_modules resolves) that still references '@nativescript/core'
+                    // Do this right before the final fast-fail assertion. If a rewrite occurred, add a small marker for diagnostics.
+                    try {
+                        const __before = code;
+                        code = normalizeStrayCoreStringLiterals(code);
+                        code = fixDanglingCoreFrom(code);
+                        code = normalizeAnyCoreSpecToBridge(code);
+                        if (code !== __before) {
+                            code = `// [hmr-sanitize] core-literal->bridge\n` + code;
+                        }
+                    }
+                    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}`);
                     }
                     catch (e) {
                         res.statusCode = 500;
                         return void res.end(`throw new Error(${JSON.stringify(e?.message || String(e))});\nexport {};`);
                     }
+                    // Defensive export normalization: if a module defines `routes` and only exports it named,
+                    // add a default export alias so both `import { routes }` and `import routes` work.
+                    try {
+                        if (!/\bexport\s+default\b/.test(code)) {
+                            const hasNamedRoutes = /\bexport\s*\{\s*routes\s*\}/.test(code);
+                            const hasConstRoutes = /\bconst\s+routes\s*=/.test(code) || /\bvar\s+routes\s*=/.test(code) || /\blet\s+routes\s*=/.test(code);
+                            if (hasNamedRoutes && hasConstRoutes) {
+                                code += `\nexport default routes;\n`;
+                            }
+                        }
+                    }
+                    catch { }
+                    // alpha.59 — `/ns/rt` and `/ns/core` URL versioning.
+                    //
+                    // Pre-alpha.59 these URLs were emitted as `/ns/rt/<ver>`
+                    // and `/ns/core/<ver>` so V8's HTTP module cache would see
+                    // a fresh URL on every save. The runtime canonicalizer
+                    // (HMRSupport.mm `CanonicalizeHttpUrlKey`) 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 alpha.59 has 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 = 0;
+                        code = ensureVersionedRtImports(code, getServerOrigin(server), verNum);
+                        code = ACTIVE_STRATEGY.ensureVersionedImports(code, getServerOrigin(server), verNum);
+                        code = ensureVersionedCoreImports(code, getServerOrigin(server), verNum);
+                    }
+                    catch { }
+                    // alpha.59 — `/ns/m` URL finalize step.
+                    //
+                    // `rewriteNsMImportPathForHmr` (Phase 3a) is now 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
+                    // (HMR_STABLE_URL_INVALIDATION_PLAN.md "Vue Follow-up").
+                    try {
+                        const verTag = (() => {
+                            const numeric = getNumericServeVersionTag(forcedVer, Number(graphVersion || 0));
+                            return numeric > 0 ? `v${numeric}` : 'v0';
+                        })();
+                        const origin = getServerOrigin(server);
+                        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/..."
+                        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, (_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, (_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 → 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) 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/${verTag}${p1}`)}`);
+                        }
+                        catch { }
+                    }
+                    catch { }
+                    // Final guard: eliminate any lingering named imports from /ns/core to avoid
+                    // evaluation-time "does not provide an export named ..." in the device runtime.
+                    try {
+                        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';
@@ -3224,147 +3823,1912 @@ export const piniaSymbol = p.piniaSymbol;
                     res.end('export {}\n');
                 }
             });
-            registerRuntimeCompatHandlers(server, {
-                verbose,
-                requireGuardSnippet: REQUIRE_GUARD_SNIPPET,
-                appRootDir: APP_ROOT_DIR,
-                defaultMainEntry: DEFAULT_MAIN_ENTRY,
-                defaultMainEntryVirtual: DEFAULT_MAIN_ENTRY_VIRTUAL,
-                getGraphVersion: () => Number(graphVersion || 0),
-                getServerOrigin,
+            // 2.5) ESM runtime bridge for NativeScript-Vue: GET /ns/rt
+            // Provides a single authoritative source of Vue helpers bound to the NativeScript renderer.
+            // V2.1: Lazy ensure bridge — does not statically import vue. It lazily resolves helpers from
+            // globalThis or vendor registry/require on first evaluation, then exports references so SFCs
+            // can immediately call them during module evaluation.
+            server.middlewares.use(async (req, res, next) => {
+                try {
+                    const urlObj = new URL(req.url || '', 'http://localhost');
+                    // Accept only /ns/rt and /ns/rt/<ver> for cache-busting semantics
+                    if (!(urlObj.pathname === '/ns/rt' || /^\/ns\/rt\/[\d]+$/.test(urlObj.pathname)))
+                        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 rtVerSeg = urlObj.pathname.replace(/^\/ns\/rt\/?/, '');
+                    const rtVer = /^[0-9]+$/.test(rtVerSeg) ? rtVerSeg : String(graphVersion || 0);
+                    const origin = getServerOrigin(server);
+                    let code = `// [ns-rt][v2.3] NativeScript-Vue runtime bridge (module-scoped cache, no globals)\n` +
+                        `const __origin = ((typeof globalThis !== 'undefined' && globalThis && globalThis.__NS_HTTP_ORIGIN__) || (new URL(import.meta.url)).origin);\n` +
+                        `let __ns_core_bridge = null; try { import(__origin + "/ns/core/${rtVer}").then(m => { __ns_core_bridge = m; }).catch(() => {}); } catch {}\n` +
+                        `const g = globalThis;\n` +
+                        `const reg = (g.__nsVendorRegistry ||= new Map());\n` +
+                        `const req = reg && reg.get ? (g.__nsVendorRequire || g.__nsRequire || g.require) : (g.__nsRequire || g.require);\n` +
+                        `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` +
+                        `function __ensure(){\n` +
+                        `  if (__cached_rt) return __cached_rt;\n` +
+                        `  let vm = null;\n` +
+                        `  try { vm = reg && reg.has && reg.has('nativescript-vue') ? reg.get('nativescript-vue') : (typeof req==='function' ? req('nativescript-vue') : null); } catch {}\n` +
+                        `  if (!vm) { try { vm = reg && reg.has && reg.has('vue') ? reg.get('vue') : (typeof req==='function' ? req('vue') : null); } catch {} }\n` +
+                        `  const rt = (vm && (vm.default ?? vm)) || {};\n` +
+                        `  __cached_vm = vm;\n` +
+                        `  __cached_rt = rt;\n` +
+                        `  return rt;\n` +
+                        `}\n` +
+                        `// Soft-globals for @nativescript/core when missing (dev-only safety)\n` +
+                        `try {\n` +
+                        `  const dev = typeof __DEV__ !== 'undefined' ? __DEV__ : true;\n` +
+                        `  if (dev) {\n` +
+                        `    const ns = (__ns_core_bridge && (__ns_core_bridge.__esModule && __ns_core_bridge.default ? __ns_core_bridge.default : (__ns_core_bridge.default || __ns_core_bridge))) || __ns_core_bridge || {};\n` +
+                        `    if (ns) {\n` +
+                        `      if (!g.Frame && ns.Frame) g.Frame = ns.Frame;\n` +
+                        `      if (!g.Page && ns.Page) g.Page = ns.Page;\n` +
+                        `      if (!g.Application && (ns.Application||ns.app||ns.application)) g.Application = (ns.Application||ns.app||ns.application);\n` +
+                        `    }\n` +
+                        `  }\n` +
+                        `} catch {}\n` +
+                        `const __get = (k) => { const rt = __ensure(); const v = rt && rt[k]; if (typeof v !== 'function' && v === undefined) { throw new Error('[ns-rt] missing export '+k); } return v; };\n` +
+                        `export const __realm = __RT_REALM_TAG;\n` +
+                        `export const defineComponent = (...a) => (__get('defineComponent'))(...a);\n` +
+                        `export const resolveComponent = (...a) => (__ensure().resolveComponent)(...a);\n` +
+                        `export const createVNode = (...a) => (__ensure().createVNode)(...a);\n` +
+                        `export const createTextVNode = (...a) => (__ensure().createTextVNode)(...a);\n` +
+                        `export const createCommentVNode = (...a) => (__ensure().createCommentVNode)(...a);\n` +
+                        `export const Fragment = (__ensure().Fragment);\n` +
+                        `export const Teleport = (__ensure().Teleport);\n` +
+                        `export const Transition = (__ensure().Transition);\n` +
+                        `export const TransitionGroup = (__ensure().TransitionGroup);\n` +
+                        `export const KeepAlive = (__ensure().KeepAlive);\n` +
+                        `export const Suspense = (__ensure().Suspense);\n` +
+                        `export const withCtx = (...a) => (__ensure().withCtx)(...a);\n` +
+                        `export const openBlock = (...a) => (__ensure().openBlock)(...a);\n` +
+                        `export const createBlock = (...a) => (__ensure().createBlock)(...a);\n` +
+                        `export const createElementVNode = (...a) => (__ensure().createElementVNode)(...a);\n` +
+                        `export const createElementBlock = (...a) => (__ensure().createElementBlock)(...a);\n` +
+                        `export const renderSlot = (...a) => (__ensure().renderSlot)(...a);\n` +
+                        `export const mergeProps = (...a) => (__ensure().mergeProps)(...a);\n` +
+                        `export const toHandlers = (...a) => (__ensure().toHandlers)(...a);\n` +
+                        `export const renderList = (...a) => (__ensure().renderList)(...a);\n` +
+                        `export const normalizeProps = (...a) => (__ensure().normalizeProps)(...a);\n` +
+                        `export const guardReactiveProps = (...a) => (__ensure().guardReactiveProps)(...a);\n` +
+                        `export const normalizeClass = (...a) => (__ensure().normalizeClass)(...a);\n` +
+                        `export const normalizeStyle = (...a) => (__ensure().normalizeStyle)(...a);\n` +
+                        `export const toDisplayString = (...a) => (__ensure().toDisplayString)(...a);\n` +
+                        `export const withDirectives = (...a) => (__ensure().withDirectives)(...a);\n` +
+                        `export const resolveDirective = (...a) => (__ensure().resolveDirective)(...a);\n` +
+                        `export const withModifiers = (...a) => (__ensure().withModifiers)(...a);\n` +
+                        `export const withKeys = (...a) => (__ensure().withKeys)(...a);\n` +
+                        `export const resolveDynamicComponent = (...a) => (__ensure().resolveDynamicComponent)(...a);\n` +
+                        `export const isVNode = (...a) => (__ensure().isVNode)(...a);\n` +
+                        `export const cloneVNode = (...a) => (__ensure().cloneVNode)(...a);\n` +
+                        `export const isRef = (...a) => (__ensure().isRef)(...a);\n` +
+                        `export const ref = (...a) => (__ensure().ref)(...a);\n` +
+                        `export const shallowRef = (...a) => (__ensure().shallowRef)(...a);\n` +
+                        `export const unref = (...a) => (__ensure().unref)(...a);\n` +
+                        `export const computed = (...a) => (__ensure().computed)(...a);\n` +
+                        `export const reactive = (...a) => (__ensure().reactive)(...a);\n` +
+                        `export const readonly = (...a) => (__ensure().readonly)(...a);\n` +
+                        `export const isReactive = (...a) => (__ensure().isReactive)(...a);\n` +
+                        `export const isReadonly = (...a) => (__ensure().isReadonly)(...a);\n` +
+                        `export const toRaw = (...a) => (__ensure().toRaw)(...a);\n` +
+                        `export const markRaw = (...a) => (__ensure().markRaw)(...a);\n` +
+                        `export const shallowReactive = (...a) => (__ensure().shallowReactive)(...a);\n` +
+                        `export const shallowReadonly = (...a) => (__ensure().shallowReadonly)(...a);\n` +
+                        `export const watch = (...a) => (__ensure().watch)(...a);\n` +
+                        `export const watchEffect = (...a) => (__ensure().watchEffect)(...a);\n` +
+                        `export const watchPostEffect = (...a) => (__ensure().watchPostEffect)(...a);\n` +
+                        `export const watchSyncEffect = (...a) => (__ensure().watchSyncEffect)(...a);\n` +
+                        `export const onBeforeMount = (...a) => (__ensure().onBeforeMount)(...a);\n` +
+                        `export const onMounted = (...a) => (__ensure().onMounted)(...a);\n` +
+                        `export const onBeforeUpdate = (...a) => (__ensure().onBeforeUpdate)(...a);\n` +
+                        `export const onUpdated = (...a) => (__ensure().onUpdated)(...a);\n` +
+                        `export const onBeforeUnmount = (...a) => (__ensure().onBeforeUnmount)(...a);\n` +
+                        `export const onUnmounted = (...a) => (__ensure().onUnmounted)(...a);\n` +
+                        `export const onActivated = (...a) => (__ensure().onActivated)(...a);\n` +
+                        `export const onDeactivated = (...a) => (__ensure().onDeactivated)(...a);\n` +
+                        `export const onErrorCaptured = (...a) => (__ensure().onErrorCaptured)(...a);\n` +
+                        `export const onRenderTracked = (...a) => (__ensure().onRenderTracked)(...a);\n` +
+                        `export const onRenderTriggered = (...a) => (__ensure().onRenderTriggered)(...a);\n` +
+                        `export const nextTick = (...a) => (__ensure().nextTick)(...a);\n` +
+                        `export const h = (...a) => (__ensure().h)(...a);\n` +
+                        `export const provide = (...a) => (__ensure().provide)(...a);\n` +
+                        `export const inject = (...a) => (__ensure().inject)(...a);\n` +
+                        `export const vShow = (__ensure().vShow);\n` +
+                        `export const createApp = (...a) => (__ensure().createApp)(...a);\n` +
+                        `export const registerElement = (...a) => (__ensure().registerElement)(...a);\n` +
+                        `export const $navigateTo = (...a) => { const vm = (__cached_vm || (void __ensure(), __cached_vm)); const rt = __ensure(); try { if (!(g && g.Frame)) { const ns = (__ns_core_bridge && (__ns_core_bridge.__esModule && __ns_core_bridge.default ? __ns_core_bridge.default : (__ns_core_bridge.default || __ns_core_bridge))) || __ns_core_bridge || {}; if (ns) { if (!g.Frame && ns.Frame) g.Frame = ns.Frame; if (!g.Page && ns.Page) g.Page = ns.Page; if (!g.Application && (ns.Application||ns.app||ns.application)) g.Application = (ns.Application||ns.app||ns.application); } } } catch {} try { const hmrRealm = (g && g.__NS_HMR_REALM__) || 'unknown'; const hasTop = !!(g && g.Frame && g.Frame.topmost && g.Frame.topmost()); const top = hasTop ? g.Frame.topmost() : null; const ctor = top && top.constructor && top.constructor.name; } catch {} if (g && typeof g.__nsNavigateUsingApp === 'function') { try { return g.__nsNavigateUsingApp(...a); } catch (e) { try { console.error('[ns-rt] $navigateTo app navigator error', e); } catch {} throw e; } } try { console.error('[ns-rt] $navigateTo unavailable: app navigator missing'); } catch {} throw new Error('$navigateTo unavailable: app navigator missing'); } ;\n` +
+                        `export const $navigateBack = (...a) => { const vm = (__cached_vm || (void __ensure(), __cached_vm)); const rt = __ensure(); const impl = (vm && (vm.$navigateBack || (vm.default && vm.default.$navigateBack))) || (rt && (rt.$navigateBack || (rt.runtimeHelpers && rt.runtimeHelpers.navigateBack))); let res; try { const via = (impl && (impl === (vm && vm.$navigateBack) || impl === (vm && vm.default && vm.default.$navigateBack))) ? 'vm' : (impl ? 'rt' : 'none'); } catch {} try { if (typeof impl === 'function') res = impl(...a); } catch {} try { const top = (g && g.Frame && g.Frame.topmost && g.Frame.topmost()); if (!res && top && top.canGoBack && top.canGoBack()) { res = top.goBack(); } } catch {} try { const hook = g && (g.__NS_HMR_ON_NAVIGATE_BACK || g.__NS_HMR_ON_BACK || g.__nsAttemptBackRemount); if (typeof hook === 'function') hook(); } catch {} return res; }\n` +
+                        `export const $showModal = (...a) => { const vm = (__cached_vm || (void __ensure(), __cached_vm)); const rt = __ensure(); const impl = (vm && (vm.$showModal || (vm.default && vm.default.$showModal))) || (rt && (rt.$showModal || (rt.runtimeHelpers && rt.runtimeHelpers.showModal))); try { if (typeof impl === 'function') return impl(...a); } catch (e) { } return undefined; }\n` +
+                        `export default {\n` +
+                        `  defineComponent, resolveComponent, createVNode, createTextVNode, createCommentVNode,\n` +
+                        `  Fragment, Teleport, Transition, TransitionGroup, KeepAlive, Suspense, withCtx, openBlock,\n` +
+                        `  createBlock, createElementVNode, createElementBlock, renderSlot, mergeProps, toHandlers,\n` +
+                        `  renderList, normalizeProps, guardReactiveProps, normalizeClass, normalizeStyle, toDisplayString,\n` +
+                        `  withDirectives, resolveDirective, withModifiers, withKeys, resolveDynamicComponent,\n` +
+                        `  isVNode, cloneVNode, isRef, ref, shallowRef, unref, computed, reactive, readonly, isReactive, isReadonly, toRaw, markRaw, shallowReactive, shallowReadonly,\n` +
+                        `  watch, watchEffect, watchPostEffect, watchSyncEffect, onBeforeMount, onMounted, onBeforeUpdate, onUpdated,\n` +
+                        `  onBeforeUnmount, onUnmounted, onActivated, onDeactivated, onErrorCaptured, onRenderTracked, onRenderTriggered, nextTick, h, provide, inject, vShow, createApp, registerElement,\n` +
+                        `  $navigateTo, $navigateBack, $showModal\n` +
+                        `};\n`;
+                    // Prepend guard and ship (harmless, keeps diagnostics consistent)
+                    code = REQUIRE_GUARD_SNIPPET + code;
+                    res.statusCode = 200;
+                    res.end(code);
+                }
+                catch (e) {
+                    res.statusCode = 500;
+                    res.end('export {}\n');
+                }
             });
             // 2.55) Dev-only vendor import unifier: rewrite 'vue'/'nativescript-vue' to /ns/rt/<ver>
             // This ensures plugins and app share a single Vue/NativeScript-Vue instance/realm.
-            registerVendorUnifierHandler(server, {
-                getGraphVersion: () => Number(graphVersion || 0),
-                getServerOrigin,
-                getStrategy: () => ACTIVE_STRATEGY,
-            });
-            // 2.6) ESM bridge for @nativescript/core: GET /ns/core[/<ver>][?p=sub/path]
             server.middlewares.use(async (req, res, next) => {
                 try {
                     const urlObj = new URL(req.url || '', 'http://localhost');
-                    const coreRequest = parseCoreBridgeRequest(urlObj.pathname, urlObj.searchParams, Number(graphVersion || 0));
-                    if (!coreRequest)
+                    const p = urlObj.pathname || '';
+                    // Ignore our own core/rt bridge endpoints and non-JS assets, but DO allow /ns/m/* through
+                    if (/^\/ns\/(?:rt|core)(?:\/|$)/.test(p))
+                        return next();
+                    if (!/(\.m?js$|\.ts$|\/node_modules\/|\/\.vite\/deps\/|^\/@id\/|^\/@fs\/)/.test(p))
+                        return next();
+                    if (/\.css($|\?)/.test(p))
+                        return next();
+                    const reqUrl = req.url || '';
+                    const transformed = await server.transformRequest(reqUrl);
+                    if (!transformed?.code)
+                        return next();
+                    const origin = getServerOrigin(server);
+                    const ver = Number(graphVersion || 0);
+                    const rewrite = ACTIVE_STRATEGY.rewriteVendorSpec;
+                    if (!rewrite)
+                        return next();
+                    const before = transformed.code;
+                    const code = rewrite(before, origin, ver);
+                    if (code === before)
                         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 { hasExplicitVersion, key, normalizedSub, sub, ver } = coreRequest;
-                    // 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 resolvedSubpath = normalizedSub || sub;
-                            const projectRoot = server.config?.root || process.cwd();
-                            const resolveModuleId = async (moduleId) => {
-                                const resolved = await server.pluginContainer?.resolveId?.(moduleId, undefined);
-                                return typeof resolved === 'string' ? resolved : resolved?.id || null;
-                            };
-                            const resolvedId = await resolveRuntimeCoreModulePath(resolvedSubpath, resolveModuleId);
-                            const modulePath = resolvedId || `/node_modules/@nativescript/core/${resolvedSubpath}`;
-                            const transformed = await sharedTransformRequest(modulePath);
-                            if (!hasExplicitVersion) {
-                                if (transformed?.code) {
-                                    const expandedModuleCode = await expandStarExports(transformed.code, server, projectRoot, verbose);
-                                    res.statusCode = 200;
-                                    res.end(buildVersionedCoreSubpathAliasModule(resolvedSubpath, ver, extractExportedNames(expandedModuleCode), hasModuleDefaultExport(expandedModuleCode)));
-                                    return;
+                    res.statusCode = 200;
+                    res.end(code);
+                }
+                catch {
+                    return next();
+                }
+            });
+            // 2.5.1) Catch-all redirect for stray /node_modules/@nativescript/core/*
+            // requests — route them to the /ns/core bridge so they get the same
+            // __DEV__/__IOS__ preamble and specifier rewriting. Without this,
+            // Vite's default /node_modules/ handler serves the raw file, which
+            // references bare __DEV__ and crashes at module eval.
+            server.middlewares.use((req, _res, next) => {
+                try {
+                    const urlObj = new URL(req.url || '', 'http://localhost');
+                    const coreNmPrefix = '/node_modules/@nativescript/core';
+                    if (!urlObj.pathname.startsWith(coreNmPrefix))
+                        return next();
+                    const sub = urlObj.pathname.slice(coreNmPrefix.length).replace(/^\/+/, '');
+                    if (sub === '' || sub === 'index.js' || sub === 'index') {
+                        req.url = `/ns/core`;
+                    }
+                    else {
+                        req.url = `/ns/core/${sub}`;
+                    }
+                    return next();
+                }
+                catch {
+                    return next();
+                }
+            });
+            // 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.
+            //
+            // iOS caches by URL path, so each unique URL is evaluated exactly
+            // once per app lifetime. Every class identity is shared, every
+            // `register()` side effect runs once, every `Application` reference
+            // is the same iosApp singleton. The entire class of "does not
+            // provide an export named X" and "Cannot redefine property" errors
+            // is eliminated by construction.
+            server.middlewares.use(async (req, res, next) => {
+                try {
+                    const urlObj = new URL(req.url || '', 'http://localhost');
+                    const coreRequest = parseCoreBridgeRequest(urlObj.pathname, urlObj.searchParams, Number(graphVersion || 0));
+                    if (!coreRequest)
+                        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 { normalizedSub, sub, ver } = coreRequest;
+                    const resolveModuleId = async (moduleId) => {
+                        const resolved = await server.pluginContainer?.resolveId?.(moduleId, undefined);
+                        return typeof resolved === 'string' ? resolved : resolved?.id || null;
+                    };
+                    let modulePath = null;
+                    if (sub) {
+                        const resolvedSubpath = normalizedSub || sub;
+                        modulePath = await resolveRuntimeCoreModulePath(resolvedSubpath, resolveModuleId);
+                        if (!modulePath) {
+                            modulePath = `/node_modules/@nativescript/core/${resolvedSubpath}`;
+                        }
+                    }
+                    else {
+                        modulePath = (await resolveModuleId('@nativescript/core')) || '/node_modules/@nativescript/core/index.js';
+                    }
+                    const transformed = await sharedTransformRequest(modulePath);
+                    if (!transformed?.code) {
+                        res.statusCode = 500;
+                        res.setHeader('Content-Type', 'application/json');
+                        res.end(JSON.stringify({ error: 'core-transform-failed', modulePath, sub: sub || null }));
+                        return;
+                    }
+                    // Vite's transform output references module IDs with /@fs,
+                    // relative specifiers, or absolute project paths. Rewrite
+                    // those to URLs iOS can fetch over HTTP.
+                    let rewritten = rewriteSpecifiersForDevice(transformed.code, getServerOrigin(server), Number(ver));
+                    // Invariant D (CJS/ESM interop shape) — EXPORT-SIDE fix.
+                    //
+                    // `@nativescript/core/index.js` declares namespace
+                    // re-exports like:
+                    //     export * as Utils from './utils';
+                    // The ES spec says these produce Module Namespace Objects
+                    // with [[Prototype]] = null. Consumers that reach them
+                    // via direct ESM import — `import { Utils } from
+                    // '@nativescript/core'` — get the raw null-proto value,
+                    // bypassing any CJS `require` shim we install. Most
+                    // consumers tolerate this, but CJS-style interop (most
+                    // notably zone.js's `patchMethod`) calls
+                    // `hasOwnProperty` on the target and crashes on
+                    // null-proto.
+                    //
+                    // We rewrite the re-export to a shape-wrapped const:
+                    //     import * as __ns_re_Utils__ from './utils';
+                    //     export const Utils = __NS_CJS_SHAPE__(__ns_re_Utils__);
+                    // so the EXPORT itself is a plain object — visible to
+                    // both ESM and CJS consumers consistently.
+                    //
+                    // We only pay the rewrite cost when the module actually
+                    // contains namespace re-exports (i.e., the main
+                    // `index.js`). Subpaths (`/utils`, `/http`, …) don't
+                    // re-export via `export * as`; they expose named
+                    // exports directly, so the rewrite is a no-op on them.
+                    if (hasNamespaceReExport(rewritten)) {
+                        rewritten = rewriteNamespaceReExportsForShape(rewritten);
+                    }
+                    // Prepend the build-time defines (__DEV__, __IOS__, __ANDROID__,
+                    // __APPLE__, …) that @nativescript/core source references directly.
+                    // Vite's `define` config substitutes these in user-code transforms but
+                    // skips node_modules by default; since core is now external and served
+                    // over HTTP from this endpoint, the served transformed code still has
+                    // bare identifiers like `if (__DEV__) …`. Without these consts, V8
+                    // hits `ReferenceError: __DEV__ is not defined` at module eval because
+                    // globalThis.__DEV__ is set by bundle.mjs's body AFTER all static
+                    // imports (including these core modules) have resolved.
+                    //
+                    // We inject LITERAL boolean values based on CLI flags + dev-server
+                    // mode rather than reading from globalThis, so the defines are
+                    // resolved even before bundle.mjs's body runs.
+                    const __cliFlags = getCliFlags() || {};
+                    const __platformIsAndroid = !!__cliFlags.android;
+                    const __platformIsVisionOS = !!__cliFlags.visionos;
+                    const __platformIsIOS = !__platformIsAndroid && !__platformIsVisionOS;
+                    const preamble = [
+                        `const __ANDROID__ = ${__platformIsAndroid ? 'true' : 'false'};`,
+                        `const __IOS__ = ${__platformIsIOS ? 'true' : 'false'};`,
+                        `const __VISIONOS__ = ${__platformIsVisionOS ? 'true' : 'false'};`,
+                        `const __APPLE__ = __IOS__ || __VISIONOS__;`,
+                        `const __DEV__ = ${server.config?.mode === 'development' ? 'true' : 'false'};`,
+                        `const __COMMONJS__ = false;`,
+                        `const __NS_WEBPACK__ = false;`,
+                        `const __NS_ENV_VERBOSE__ = globalThis.__NS_ENV_VERBOSE__ !== undefined ? !!globalThis.__NS_ENV_VERBOSE__ : false;`,
+                        `const __CSS_PARSER__ = 'css-tree';`,
+                        `const __UI_USE_XML_PARSER__ = true;`,
+                        `const __UI_USE_EXTERNAL_RENDERER__ = false;`,
+                        `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
+                    //     immediately, before the realm splits.
+                    //   - Invariant C (boot-order): CommonJS
+                    //     `require('@nativescript/core/...')` calls from
+                    //     vendor install() hooks must resolve to the SAME
+                    //     ESM namespace that ran this side-effect preamble.
+                    //     The registration below keys the namespace object
+                    //     under BOTH the bare specifier and the canonical
+                    //     subpath (and raw subpath for back-compat) so the
+                    //     vendor shim's `createRequire` and the main-entry
+                    //     `_nsReq` hit on any lookup form.
+                    const rawSub = normalizedSub || sub || '';
+                    const canonicalSub = normalizeCoreSubCanonical(rawSub);
+                    const registrationKeySet = new Set();
+                    registrationKeySet.add(canonicalSub ? `@nativescript/core/${canonicalSub}` : '@nativescript/core');
+                    registrationKeySet.add(canonicalSub);
+                    if (rawSub && rawSub !== canonicalSub) {
+                        registrationKeySet.add(`@nativescript/core/${rawSub}`);
+                        registrationKeySet.add(rawSub);
+                    }
+                    const registrationKeys = Array.from(registrationKeySet).map((k) => JSON.stringify(k));
+                    const canonicalUrl = `${getServerOrigin(server)}` + (canonicalSub ? `/ns/core/${canonicalSub}` : '/ns/core');
+                    const instrumentationHeader = [
+                        `/* @nativescript/core bridge — canonical URL: ${canonicalUrl} */`,
+                        `try { if (typeof globalThis !== 'undefined') {`,
+                        `  const __nsFirst = globalThis.__NS_CORE_FIRST_URL__ || (globalThis.__NS_CORE_FIRST_URL__ = Object.create(null));`,
+                        `  const __nsSeen = globalThis.__NS_CORE_FETCHED_URLS__ || (globalThis.__NS_CORE_FETCHED_URLS__ = []);`,
+                        `  const __nsKey = ${JSON.stringify(canonicalSub)};`,
+                        `  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)');`,
+                        `  }`,
+                        `  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.
+                    //
+                    // The actual shape installer runs earlier in the module
+                    // body (between preamble and selfImport; see
+                    // buildShapeInstallHeader). At this point we just read
+                    // globalThis.__NS_CJS_SHAPE__ and apply it to the self
+                    // namespace before registering under the CJS key space.
+                    //
+                    // Why shape self at registration: consumers that reach
+                    // `@nativescript/core` via `require()` (legacy vendors,
+                    // `globalThis.require` shim) look up the registry. They
+                    // expect a plain object (Object.prototype in chain) so
+                    // `.hasOwnProperty` / `.toString` work. Shaping once on
+                    // 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));`,
+                        `  const __nsShapeFn = typeof globalThis.__NS_CJS_SHAPE__ === 'function' ? globalThis.__NS_CJS_SHAPE__ : function (x) { return x; };`,
+                        `  const __nsSelfRaw = (typeof __ns_core_self_ns__ !== 'undefined') ? __ns_core_self_ns__ : { default: undefined };`,
+                        `  const __nsSelf = __nsShapeFn(__nsSelfRaw);`,
+                        ...registrationKeys.map((k) => `  __nsReg[${k}] = __nsSelf;`),
+                        `} } catch (e) { try { console.warn('[ns-core] self-register failed:', (e && e.message) || e); } catch {} }`,
+                    ].join('\n');
+                    // Bind `import * as __ns_core_self_ns__` to the module's
+                    // own export namespace so the footer can stash it into
+                    // the registry. Self-import is a no-op at eval time —
+                    // V8 resolves it to the module record we're already
+                    // evaluating and the final namespace is the same object
+                    // the registry receives. We use the CANONICAL URL here
+                    // so the self-import participates in Invariant A along
+                    // with every other @nativescript/core URL.
+                    const canonicalUrlForSelf = canonicalSub ? `/ns/core/${canonicalSub}` : '/ns/core';
+                    const selfImport = `import * as __ns_core_self_ns__ from ${JSON.stringify(canonicalUrlForSelf)};`;
+                    // Invariant D — SHAPE INSTALLER.
+                    //
+                    // Emits idempotent body-code that installs
+                    // globalThis.__NS_CJS_SHAPE__ BEFORE `rewritten`'s body
+                    // runs. This matters because the rewrite step above may
+                    // have produced statements like
+                    // `export const Utils = (typeof globalThis.__NS_CJS_SHAPE__ ...)(__ns_re_Utils__);`
+                    // that execute during module evaluation. Without the
+                    // installer running first, the ternary falls back to
+                    // identity — still safe, but the null-proto namespace
+                    // leaks through and consumers that expect a plain
+                    // object would still crash.
+                    //
+                    // Placement is important: BEFORE selfImport in the
+                    // concatenation. ESM imports are hoisted regardless of
+                    // textual position, but body code executes in source
+                    // order. Placing the installer first guarantees it
+                    // runs before any body statement in `rewritten`.
+                    //
+                    // Install is idempotent: `|| (globalThis.X = ...)` so
+                    // whichever /ns/core module evaluates first wins and
+                    // every subsequent module becomes a no-op.
+                    const shapeInstallHeader = buildShapeInstallHeader();
+                    // Invariant D — DEFAULT EXPORT BRIDGE.
+                    //
+                    // See `buildDefaultExportFooter` in ns-core-cjs-shape.ts
+                    // for the full rationale (consumer matrix, skip conditions,
+                    // why the default isn't shaped). The short version:
+                    // upstream rewrites turn `import { X } from '@nativescript/core'`
+                    // into a DEFAULT import, and the bridge has to provide one.
+                    const defaultExportFooter = buildDefaultExportFooter(rewritten);
+                    const moduleCode = [instrumentationHeader, preamble, shapeInstallHeader, selfImport, rewritten, defaultExportFooter, registrationFooter].join('\n');
+                    res.statusCode = 200;
+                    res.end(moduleCode);
+                }
+                catch (e) {
+                    try {
+                        console.warn('[ns-core-bridge] serve failed:', e?.message);
+                    }
+                    catch { }
+                    next();
+                }
+            });
+            // 2.6a) Serve compiled entry runtime module: GET /ns/entry-rt[?v=<ver>]
+            server.middlewares.use(async (req, res, next) => {
+                try {
+                    const urlObj = new URL(req.url || '', 'http://localhost');
+                    if (!(urlObj.pathname === '/ns/entry-rt'))
+                        return next();
+                    try {
+                        if (verbose) {
+                            const ra = req.socket?.remoteAddress;
+                            const rp = req.socket?.remotePort;
+                            console.log('[hmr-http] GET /ns/entry-rt from', ra + (rp ? ':' + rp : ''));
+                        }
+                    }
+                    catch { }
+                    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');
+                    let content = '';
+                    try {
+                        const _req = createRequire(import.meta.url);
+                        const entryRtPath = _req.resolve('@nativescript/vite/hmr/entry-runtime.js');
+                        content = readFileSync(entryRtPath, 'utf-8');
+                    }
+                    catch (e) {
+                        // .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();
+                }
+            });
+            // 2.6b) HTTP-only app entry endpoint: GET /ns/entry[/<ver>]
+            // Thin wrapper that imports the compiled entry runtime and starts it with parameters.
+            server.middlewares.use(async (req, res, next) => {
+                try {
+                    const urlObj = new URL(req.url || '', 'http://localhost');
+                    if (!(urlObj.pathname === '/ns/entry' || /^\/ns\/entry\/[\d]+$/.test(urlObj.pathname)))
+                        return next();
+                    try {
+                        if (verbose) {
+                            const ra = req.socket?.remoteAddress;
+                            const rp = req.socket?.remotePort;
+                            console.log('[hmr-http] GET /ns/entry from', ra + (rp ? ':' + rp : ''));
+                        }
+                    }
+                    catch { }
+                    const verSeg = urlObj.pathname.replace(/^\/ns\/entry\/?/, '');
+                    // Resolve app main entry to an absolute path-like key used by /ns/m
+                    res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0');
+                    res.setHeader('Pragma', 'no-cache');
+                    res.setHeader('Expires', '0');
+                    const ver = /^[0-9]+$/.test(verSeg) ? verSeg : String(graphVersion || 0);
+                    const origin = getServerOrigin(server) || `${urlObj.protocol}//${urlObj.host}`;
+                    // Resolve app main entry to an absolute path-like key used by /ns/m
+                    let mainEntry = '/';
+                    try {
+                        const pkg = getPackageJson();
+                        const main = pkg?.main || DEFAULT_MAIN_ENTRY;
+                        const abs = getProjectFilePath(main).replace(/\\/g, '/');
+                        // Normalize to '/app/...'
+                        const marker = `/${APP_ROOT_DIR}/`;
+                        const idx = abs.indexOf(marker);
+                        mainEntry = idx >= 0 ? abs.substring(idx) : DEFAULT_MAIN_ENTRY_VIRTUAL;
+                    }
+                    catch { }
+                    // Build a tiny wrapper that imports the compiled entry runtime from the dev server
+                    let code = REQUIRE_GUARD_SNIPPET +
+                        `// [ns-entry][v${ver}] wrapper (script-safe) bytes will follow\n` +
+                        `(async function(){\n` +
+                        `  let origin = ${JSON.stringify(origin)}; const main = ${JSON.stringify(mainEntry)}; const __ns_graph_ver = ${JSON.stringify(ver)};\n` +
+                        `  try { const __b = (globalThis && globalThis.__NS_ENTRY_BASE__) ? String(globalThis.__NS_ENTRY_BASE__) : ''; if (__b) { try { const __o = new URL(__b).origin; if (__o) origin = __o; } catch {} } } catch {}\n` +
+                        `  const __VERBOSE__ = (typeof __NS_ENV_VERBOSE__ !== 'undefined' && __NS_ENV_VERBOSE__) || (globalThis && globalThis.process && globalThis.process.env && globalThis.process.env.verbose) || (globalThis && globalThis.__NS_ENV_VERBOSE__) || ${JSON.stringify(!!verbose)};\n` +
+                        `  if (__VERBOSE__) console.info('[ns-entry][wrapper] start', { origin, main, ver: __ns_graph_ver });\n` +
+                        `  async function __ns_import_entry_rt(u){\n` +
+                        `    // Prefer fetch+eval script transformation to avoid module import limitations on device\n` +
+                        `    try { const r = await fetch(u); const t = await r.text(); if (__VERBOSE__) console.info('[ns-entry][wrapper] entry-rt fetched bytes', (t&&t.length)||0);\n` +
+                        `      // Transform 'export default function' or 'export default async function' into global assignment\n` +
+                        `      let s = t.replace(/export\\s+default\\s+async\\s+function\\s+([A-Za-z0-9_$]+)?/,'globalThis.__NS_START_ENTRY__=async function $1')\n` +
+                        `               .replace(/export\\s+default\\s+function\\s+([A-Za-z0-9_$]+)?/,'globalThis.__NS_START_ENTRY__=function $1');\n` +
+                        `      // Fallback: if function-form replacements didn't run, handle expression default export too\n` +
+                        `      if (String(s).indexOf('__NS_START_ENTRY__') === -1) { s = 'globalThis.__NS_START_ENTRY__=' + s.replace(/export\\s+default\\s*/,''); }\n` +
+                        `      try { (0,eval)(s); } catch (ee) { console.error('[ns-entry][wrapper] eval entry-rt failed', ee && (ee.message||ee)); throw ee; }\n` +
+                        `      const fn = globalThis.__NS_START_ENTRY__; if (!fn) { throw new Error('entry-rt missing __NS_START_ENTRY__'); }\n` +
+                        `      return { default: fn };\n` +
+                        `    } catch(e) { console.error('[ns-entry][wrapper] entry-rt fetch/eval failed', e && (e.message||e)); throw e; }\n` +
+                        `  }\n` +
+                        `  const __entryRtUrl = '/ns/entry-rt?v=' + String(__ns_graph_ver);\n` +
+                        `  let __mod; try { __mod = await __ns_import_entry_rt(__entryRtUrl); if (__VERBOSE__) console.info('[ns-entry][wrapper] entry-rt ready'); } catch (e) { console.error('[ns-entry][wrapper] failed to prepare entry-rt', e && (e.message||e)); throw e; }\n` +
+                        `  const startEntry = (__mod && (__mod.default || __mod));\n` +
+                        `  try { await startEntry({ origin, main, ver: __ns_graph_ver, verbose: !!__VERBOSE__ }); if (__VERBOSE__) console.info('[ns-entry][wrapper] startEntry() resolved'); } catch (e) { console.error('[ns-entry][wrapper] startEntry() failed', e && (e.message||e)); throw e; }\n` +
+                        `})();\n`;
+                    code = code + `\n//# sourceURL=${origin}/ns/entry`;
+                    res.statusCode = 200;
+                    res.end(code);
+                }
+                catch (e) {
+                    next();
+                }
+            });
+            // 2.6) Transactional HMR endpoint: GET /ns/txn/<ver>
+            // Returns a single ESM that sequentially imports all changed modules for the given graphVersion.
+            server.middlewares.use(async (req, res, next) => {
+                try {
+                    const urlObj = new URL(req.url || '', 'http://localhost');
+                    const p = urlObj.pathname || '';
+                    if (!p.startsWith('/ns/txn'))
+                        return next();
+                    let verStr = p.replace('/ns/txn', '').replace(/^\//, '');
+                    const ver = Number(verStr || urlObj.searchParams.get('v') || 0);
+                    let ids = txnBatches.get(ver) || [];
+                    if (!ids.length) {
+                        // Attempt to rebuild from any changed modules at this version if present in graph history is unavailable.
+                        // Fallback heuristic: use all modules with latest hash change equal to this version (we don't store per-module version, so use any changedIds from query 'ids' if provided)
+                        try {
+                            const q = (urlObj.searchParams.get('ids') || '')
+                                .split(',')
+                                .map((s) => s.trim())
+                                .filter(Boolean);
+                            if (q.length)
+                                ids = computeTxnOrderForChanged(q);
+                        }
+                        catch { }
+                    }
+                    const origin = getServerOrigin(server) || `${urlObj.protocol}//${urlObj.host}`;
+                    const lines = [];
+                    lines.push(`// [txn] version=${ver} count=${ids.length}`);
+                    if (!ids.length) {
+                        lines.push(`export default true;`);
+                        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');
+                        res.statusCode = 200;
+                        res.end(lines.join('\n'));
+                        return;
+                    }
+                    for (const id of ids) {
+                        const isVue = /\.vue$/i.test(id);
+                        const safe = id.startsWith('/') ? id : '/' + id;
+                        const abs = isVue ? `/ns/asm/${ver}?path=${encodeURIComponent(safe)}` : `/ns/m${safe}`;
+                        lines.push(`await import(${JSON.stringify(abs)});`);
+                    }
+                    lines.push(`export default true;`);
+                    const code = lines.join('\n');
+                    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');
+                    res.statusCode = 200;
+                    res.end(code);
+                    return;
+                }
+                catch (e) {
+                    /* fallthrough */
+                }
+                return next();
+            });
+            // 3) ESM endpoint for SFC modules: GET /ns/sfc?path=/src/Comp.vue[?vue&type=*] OR /ns/sfc/src/Comp.vue[?vue&type=*]
+            // Also accept alias /ns/sfc
+            // Preserves variant queries (?vue&type=script|template|style) and adds a diagnostic signature comment.
+            server.middlewares.use(async (req, res, next) => {
+                try {
+                    const urlObj = new URL(req.url || '', 'http://localhost');
+                    const p = urlObj.pathname;
+                    // Only match exactly "/ns/sfc" or paths under it.
+                    const isNs = p === '/ns/sfc' || p.startsWith('/ns/sfc/');
+                    if (!isNs)
+                        return next();
+                    if (p.startsWith('/ns/asm') || p.startsWith('/ns/sfc-meta'))
+                        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 base = '/ns/sfc';
+                    // Determine request spec, preserving variant query when present and handling optional version in path
+                    let pathParam = urlObj.searchParams.get('path') || ''; // may include its own query
+                    const rawRemainder = urlObj.pathname.slice(base.length) || '';
+                    let verFromPath = null;
+                    let pathStyle = rawRemainder;
+                    if (rawRemainder && rawRemainder.startsWith('/')) {
+                        const parts = rawRemainder.split('/'); // ["", maybe "<ver>", ...]
+                        if (parts.length > 2 && /^[0-9]+$/.test(parts[1] || '')) {
+                            verFromPath = parts[1];
+                            pathStyle = '/' + parts.slice(2).join('/');
+                        }
+                    }
+                    if (pathStyle && pathStyle !== '/' && !pathParam) {
+                        if (!pathStyle.startsWith('/'))
+                            pathStyle = '/' + pathStyle;
+                        // Include endpoint query for variant-style requests (e.g. /ns/sfc/Comp.vue?vue&type=template)
+                        pathParam = pathStyle + (urlObj.search || '');
+                    }
+                    let fullSpec = pathParam || '';
+                    if (!fullSpec) {
+                        res.statusCode = 200;
+                        res.end('export {}\n');
+                        return;
+                    }
+                    if (fullSpec.startsWith('@/'))
+                        fullSpec = APP_VIRTUAL_WITH_SLASH + fullSpec.slice(2);
+                    if (!fullSpec.startsWith('/'))
+                        fullSpec = '/' + fullSpec;
+                    const isVariant = /[?&]vue&type=/.test(fullSpec);
+                    const variantTypeMatch = /[?&]type=([^&]+)/.exec(fullSpec);
+                    const variantType = variantTypeMatch?.[1] || null;
+                    const isStyleVariant = /[?&]type=style\b/.test(fullSpec);
+                    // Determine candidate for transformRequest
+                    // For full SFCs we prefer a clean base path + '?vue'; if that fails, try base without query as fallback.
+                    let candidate = fullSpec;
+                    let transformed = null;
+                    if (!isVariant) {
+                        const basePath = fullSpec.replace(/[?#].*$/, '');
+                        const candidates = [basePath + (basePath.includes('?') ? '&' : '?') + 'vue', basePath];
+                        for (const c of candidates) {
+                            try {
+                                const r = await server.transformRequest(c);
+                                if (r?.code) {
+                                    transformed = r;
+                                    candidate = c;
+                                    break;
+                                }
+                            }
+                            catch { }
+                        }
+                        if (!transformed?.code) {
+                            if (verbose) {
+                                try {
+                                    console.warn(`[sfc][serve] transform miss for`, fullSpec);
+                                }
+                                catch { }
+                            }
+                            // Emit an erroring module to surface the failure at import site with helpful hints
+                            try {
+                                const tried = candidates.slice(0, 8);
+                                const out = `// [sfc] transform miss kind=full path=${fullSpec.replace(/\n/g, '')} tried=${tried.length}\n` + `throw new Error(${JSON.stringify('[ns/sfc] transform failed for full SFC: ' + fullSpec + ' (tried ' + tried.length + ')')});\nexport {}\n`;
+                                res.statusCode = 404;
+                                res.end(out);
+                                return;
+                            }
+                            catch {
+                                res.statusCode = 404;
+                                res.end('export {}\n');
+                                return;
+                            }
+                        }
+                    }
+                    else {
+                        try {
+                            transformed = await server.transformRequest(candidate);
+                        }
+                        catch { }
+                        if (!transformed?.code) {
+                            try {
+                                const out = `// [sfc] transform miss kind=variant path=${fullSpec.replace(/\n/g, '')}\n` + `throw new Error(${JSON.stringify('[ns/sfc] transform failed for variant: ' + fullSpec)});\nexport {}\n`;
+                                res.statusCode = 404;
+                                res.end(out);
+                                return;
+                            }
+                            catch {
+                                res.statusCode = 404;
+                                res.end('export {}\n');
+                                return;
+                            }
+                        }
+                    }
+                    // For style variants, return an empty module immediately
+                    if (isStyleVariant) {
+                        const sig = `// [sfc] kind=variant:style path=${fullSpec.replace(/\n/g, '')} len=0 default=false\n`;
+                        res.statusCode = 200;
+                        res.end(`${sig}export {}\n`);
+                        return;
+                    }
+                    let code = transformed.code;
+                    // Prepend guard to capture any URL-based require attempts
+                    code = REQUIRE_GUARD_SNIPPET + code;
+                    const projectRoot = server.config?.root || process.cwd();
+                    // IMPORTANT: Do not run cleanCode() on template variant; it can strip required pieces.
+                    // We'll handle script/full SFC below, and treat template minimally right away.
+                    // Full SFCs delegate to deterministic assembler module; variants (script/template) still go through processing
+                    if (!isVariant) {
+                        const importerPath = fullSpec.replace(/[?#].*$/, '');
+                        const origin = getServerOrigin(server);
+                        const ver = verFromPath || '0';
+                        const asmPath = `/ns/asm/${ver}?path=${encodeURIComponent(importerPath)}`;
+                        const delegated = `// [sfc] kind=full (delegated to assembler) path=${importerPath}\nexport * from ${JSON.stringify(asmPath)};\nexport { default } from ${JSON.stringify(asmPath)};\n`;
+                        res.statusCode = 200;
+                        res.end(delegated);
+                        return;
+                    }
+                    else {
+                        // Variants
+                        if (variantType === 'template') {
+                            const preferSelfCompile = !!process.env.NS_HMR_SELF_COMPILE_TEMPLATE;
+                            // Compile the template ourselves to guarantee no Vite HMR code and stable output
+                            if (preferSelfCompile)
+                                try {
+                                    const projectRootT = server.config?.root || process.cwd();
+                                    const basePath = fullSpec.replace(/[?#].*$/, '');
+                                    const abs = path.join(projectRootT, basePath.replace(/^\//, ''));
+                                    let sfcSrc = '';
+                                    try {
+                                        sfcSrc = readFileSync(abs, 'utf-8');
+                                    }
+                                    catch { }
+                                    if (sfcSrc) {
+                                        const { descriptor } = parse(sfcSrc, { filename: abs });
+                                        const id = createHash('md5').update(abs).digest('hex').slice(0, 8);
+                                        let bindingMetadata = undefined;
+                                        try {
+                                            const s = compileScript(descriptor, {
+                                                id,
+                                                inlineTemplate: false,
+                                                reactivityTransform: false,
+                                            });
+                                            bindingMetadata = s?.bindings;
+                                        }
+                                        catch { }
+                                        const tpl = descriptor.template?.content || '';
+                                        const ct = compileTemplate({
+                                            source: tpl,
+                                            id,
+                                            filename: abs,
+                                            isProd: false,
+                                            ssr: false,
+                                            compilerOptions: {
+                                                bindingMetadata,
+                                                isCustomElement: (tag) => NS_NATIVE_TAGS.has(tag),
+                                            },
+                                        });
+                                        let out = (ct && (ct.code || '')) || '';
+                                        // Map Vue helper imports to runtime bridge
+                                        try {
+                                            out = out.replace(/from\s+["'](?:nativescript-vue|vue)[^"']*["']/g, 'from "/ns/rt"');
+                                        }
+                                        catch { }
+                                        // No import.meta.hot present when compiling ourselves, but keep minimal sanitizer just in case
+                                        out = processTemplateVariantMinimal(out);
+                                        code = out;
+                                    }
+                                    else {
+                                        code = 'export {}\n';
+                                    }
+                                }
+                                catch (eTplSelf) {
+                                    if (verbose) {
+                                        try {
+                                            console.warn('[sfc][template][self-compile][fail]', fullSpec, eTplSelf?.message);
+                                        }
+                                        catch { }
+                                    }
+                                    code = transformed.code || 'export {}\n';
+                                    code = processTemplateVariantMinimal(code);
+                                }
+                            else {
+                                // Prefer using Vite's template transform and apply minimal sanitization; avoids compiler mismatches and warnings
+                                code = transformed.code || 'export {}\n';
+                                code = processTemplateVariantMinimal(code);
+                            }
+                            // fall through to shared post-processing (versioning, signature, etc.)
+                        }
+                        // Script variants still need vendor mappings and general device processing (no SFC assembly)
+                        // IMPORTANT: Use a Babel AST transform to remove imports of the template variant and
+                        // neutralize their usage without brittle regex.
+                        try {
+                            const ast = babelParse(code, {
+                                sourceType: 'module',
+                                plugins: ['typescript'],
+                            });
+                            const templateBindings = new Set();
+                            const navToLocals = [];
+                            const navBackLocals = [];
+                            babelTraverse(ast, {
+                                ImportDeclaration(path) {
+                                    const spec = path.node.source.value || '';
+                                    // Remove template variant imports and collect their local identifiers for neutralization
+                                    if (typeof spec === 'string' && /\.vue\?[^\n]*type=template/.test(spec)) {
+                                        const ids = [];
+                                        for (const s of path.node.specifiers) {
+                                            if (t.isImportSpecifier(s)) {
+                                                const imported = t.isIdentifier(s.imported) ? s.imported.name : undefined;
+                                                const local = t.isIdentifier(s.local) ? s.local.name : undefined;
+                                                if ((imported === 'render' || imported === undefined) && local)
+                                                    ids.push(local);
+                                            }
+                                            else if (t.isImportDefaultSpecifier(s) || t.isImportNamespaceSpecifier(s)) {
+                                                if (t.isIdentifier(s.local))
+                                                    ids.push(s.local.name);
+                                            }
+                                        }
+                                        ids.forEach((n) => templateBindings.add(n));
+                                        path.remove();
+                                        return;
+                                    }
+                                    // Rewrite $navigateTo/$navigateBack imports from nativescript-vue (or prebundle) to use globals
+                                    const isNsVue = typeof spec === 'string' && (/nativescript-vue/.test(spec) || /vendor\.mjs$/.test(spec) || /\/node_modules\/\.vite\/deps\/nativescript-vue\.js/.test(spec));
+                                    if (isNsVue) {
+                                        const remain = [];
+                                        for (const s of path.node.specifiers) {
+                                            if (t.isImportSpecifier(s)) {
+                                                const imported = t.isIdentifier(s.imported) ? s.imported.name : undefined;
+                                                const local = t.isIdentifier(s.local) ? s.local.name : undefined;
+                                                if (local && (imported === '$navigateTo' || imported === 'navigateTo')) {
+                                                    navToLocals.push(local);
+                                                    continue;
+                                                }
+                                                if (local && (imported === '$navigateBack' || imported === 'navigateBack')) {
+                                                    navBackLocals.push(local);
+                                                    continue;
+                                                }
+                                            }
+                                            remain.push(s);
+                                        }
+                                        if (remain.length) {
+                                            path.node.specifiers = remain;
+                                        }
+                                        else {
+                                            path.remove();
+                                        }
+                                    }
+                                },
+                            });
+                            if (templateBindings.size) {
+                                babelTraverse(ast, {
+                                    Identifier(path) {
+                                        if (templateBindings.has(path.node.name)) {
+                                            path.replaceWith(t.identifier('undefined'));
+                                        }
+                                    },
+                                    AssignmentExpression(path) {
+                                        // Guard component.render = <alias> to avoid TDZ when alias is undefined
+                                        if (t.isMemberExpression(path.node.left) &&
+                                            t.isIdentifier(path.node.left.property, {
+                                                name: 'render',
+                                            })) {
+                                            const e = t.identifier('__e');
+                                            const guarded = t.tryStatement(t.blockStatement([t.variableDeclaration('const', [t.variableDeclarator(e, path.node.right)]), t.ifStatement(t.logicalExpression('&&', t.binaryExpression('!==', t.unaryExpression('typeof', path.node.left.object, true), t.stringLiteral('undefined')), t.binaryExpression('!==', t.unaryExpression('typeof', e, true), t.stringLiteral('undefined'))), t.blockStatement([t.expressionStatement(t.assignmentExpression('=', path.node.left, e))]))]), t.catchClause(t.identifier('_e'), t.blockStatement([])));
+                                            path.replaceWithMultiple([guarded]);
+                                        }
+                                    },
+                                });
+                            }
+                            let outCode = genCode(ast).code;
+                            if (navToLocals.length || navBackLocals.length) {
+                                const shimLines = [];
+                                for (const n of navToLocals)
+                                    shimLines.push(`import __ns_rt_nav_to_mod from "/ns/rt";\nconst ${n} = (...args) => __ns_rt_nav_to_mod.$navigateTo(...args);`);
+                                for (const n of navBackLocals)
+                                    shimLines.push(`import __ns_rt_nav_back_mod from "/ns/rt";\nconst ${n} = (...args) => __ns_rt_nav_back_mod.$navigateBack(...args);`);
+                                outCode = shimLines.join('\n') + '\n' + outCode;
+                            }
+                            code = outCode;
+                        }
+                        catch { }
+                        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(/[?#].*$/, '');
+                            const origin = getServerOrigin(server);
+                            const ver = verFromPath || '0';
+                            const ast2 = babelParse(code, {
+                                sourceType: 'module',
+                                plugins: ['typescript'],
+                            });
+                            babelTraverse(ast2, {
+                                ImportDeclaration(p) {
+                                    const src = p.node.source.value || '';
+                                    if (typeof src !== 'string')
+                                        return;
+                                    if (/^https?:\/\//.test(src))
+                                        return; // leave absolute URLs
+                                    if (/\.vue(?:$|\?)/.test(src)) {
+                                        let spec = src;
+                                        // Resolve to absolute project path
+                                        if (spec.startsWith('./') || spec.startsWith('../')) {
+                                            spec = path.posix.normalize(path.posix.join(path.posix.dirname(importerPath), spec));
+                                            if (!spec.startsWith('/'))
+                                                spec = '/' + spec;
+                                        }
+                                        else if (!spec.startsWith('/')) {
+                                            // Handle '@/'
+                                            if (spec.startsWith('@@/'))
+                                                spec = '/' + spec.slice(2);
+                                            if (spec.startsWith('@/'))
+                                                spec = APP_VIRTUAL_WITH_SLASH + spec.slice(2);
+                                        }
+                                        // Strip query for plain .vue (keep variant imports intact)
+                                        if (!/\bvue&type=/.test(src)) {
+                                            spec = spec.replace(/[?#].*$/, '');
+                                            const asmUrl = `/ns/asm/${ver}?path=${encodeURIComponent(spec)}&mode=inline`;
+                                            p.node.source = t.stringLiteral(asmUrl);
+                                        }
+                                    }
+                                },
+                            });
+                            code = genCode(ast2).code;
+                        }
+                        catch { }
+                        // After rewrites, strip any TypeScript syntax from the script variant to avoid device-side parse errors
+                        try {
+                            const importerPath = fullSpec.replace(/[?#].*$/, '');
+                            const tsRes = await babelCore.transformAsync(code, {
+                                plugins: [[pluginTransformTypescript, { allowDeclareFields: true }]],
+                                sourceType: 'module',
+                                // Help Babel infer TS parsing even if the virtual filename isn't .ts
+                                filename: importerPath.endsWith('.vue') ? importerPath.replace(/\.vue$/, '.ts') : importerPath + '.ts',
+                                comments: true,
+                                configFile: false,
+                                babelrc: false,
+                            });
+                            if (tsRes?.code) {
+                                code = tsRes.code;
+                            }
+                        }
+                        catch (eTsVar) {
+                            if (verbose) {
+                                try {
+                                    console.warn('[sfc][variant:script][babel-ts][fail]', fullSpec, eTsVar?.message);
+                                }
+                                catch { }
+                            }
+                        }
+                    }
+                    const importerPath = fullSpec.replace(/[?#].*$/, '');
+                    // Only run cleanCode for non-template cases (script/full). Template code must remain intact.
+                    if (!isVariant || variantType !== 'template') {
+                        code = cleanCode(code);
+                    }
+                    code = rewriteImports(code, importerPath, sfcFileMap, depFileMap, projectRoot, !!verbose, undefined, getServerOrigin(server));
+                    code = ensureVariableDynamicImportHelper(code);
+                    try {
+                        // For variant requests under /ns/sfc, prefer the version from the path segment when present
+                        // so that any internal '/ns/rt', '/ns/core', or '/ns/sfc' imports are aligned with the same version.
+                        const verNum = Number(verFromPath || '0');
+                        if (Number.isFinite(verNum) && verNum > 0) {
+                            code = ensureVersionedRtImports(code, getServerOrigin(server), verNum);
+                            code = ACTIVE_STRATEGY.ensureVersionedImports(code, getServerOrigin(server), verNum);
+                            code = ensureVersionedCoreImports(code, getServerOrigin(server), verNum);
+                        }
+                        else {
+                            code = ensureVersionedRtImports(code, getServerOrigin(server), graphVersion);
+                            code = ACTIVE_STRATEGY.ensureVersionedImports(code, getServerOrigin(server), graphVersion);
+                            code = ensureVersionedCoreImports(code, getServerOrigin(server), graphVersion);
+                        }
+                    }
+                    catch { }
+                    // Final guard for SFC variant output as well
+                    try {
+                        code = ensureDestructureCoreImports(code);
+                    }
+                    catch { }
+                    // CRITICAL: As a last step for script/template variants, re-run AST normalization and strip
+                    // any sentinel destructures that could cause duplicate locals, then re-apply core versioning.
+                    try {
+                        code = astNormalizeModuleImportsAndHelpers(code);
+                    }
+                    catch { }
+                    try {
+                        // Remove any rt->core sentinel destructures that slipped in late
+                        code = stripRtCoreSentinel(code);
+                    }
+                    catch { }
+                    try {
+                        const verNum = Number(verFromPath || '0');
+                        if (Number.isFinite(verNum) && verNum > 0) {
+                            code = ensureVersionedRtImports(code, getServerOrigin(server), verNum);
+                            code = ensureVersionedCoreImports(code, getServerOrigin(server), verNum);
+                        }
+                        else {
+                            code = ensureVersionedRtImports(code, getServerOrigin(server), graphVersion);
+                            code = ensureVersionedCoreImports(code, getServerOrigin(server), graphVersion);
+                        }
+                    }
+                    catch { }
+                    // Last-chance sanitizer for dangling Vite CJS import helper usages that may surface after late transforms
+                    try {
+                        code = stripDanglingViteCjsImports(code);
+                    }
+                    catch { }
+                    const hasDefault = /\bexport\s+default\b/.test(code);
+                    const kind = isVariant ? `variant:${variantType || 'unknown'}` : 'full';
+                    const sig = `// [sfc] kind=${kind} path=${importerPath} len=${code.length} default=${hasDefault} wrapped=${false}\n`;
+                    if (verbose) {
+                        try {
+                            console.log(`[sfc][serve] ${fullSpec} kind=${kind} default=${hasDefault} bytes=${code.length}`);
+                        }
+                        catch { }
+                    }
+                    // Ensure script variants always provide a default export if they declare a component
+                    if (!hasDefault) {
+                        // Prefer an explicit identifier if present
+                        const m = code.match(/\b(?:const|let|var)\s+(__ns_sfc__|_sfc_main)\b/);
+                        if (m && m[1]) {
+                            code += `\nexport default ${m[1]};`;
+                        }
+                        else if (/\b_defineComponent\s*\(|\bdefineComponent\s*\(/.test(code)) {
+                            // Fallback: export whichever is defined at runtime without throwing on missing identifiers
+                            code += `\nexport default (typeof __ns_sfc__ !== "undefined" ? __ns_sfc__ : (typeof _sfc_main !== "undefined" ? _sfc_main : undefined));`;
+                        }
+                    }
+                    res.statusCode = 200;
+                    res.end(sig + code);
+                }
+                catch (e) {
+                    res.statusCode = 500;
+                    res.end('export {}\n');
+                }
+            });
+            // 4) JSON metadata endpoint for SFCs: GET /ns/sfc-meta?path=/src/Comp.vue OR /ns/sfc-meta/<ver>?path=/src/Comp.vue
+            server.middlewares.use(async (req, res, next) => {
+                try {
+                    const urlObj = new URL(req.url || '', 'http://localhost');
+                    if (!urlObj.pathname.startsWith('/ns/sfc-meta'))
+                        return next();
+                    res.setHeader('Access-Control-Allow-Origin', '*');
+                    res.setHeader('Content-Type', 'application/json; 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');
+                    // Accept optional version segment similar to /ns/sfc
+                    {
+                        const metaBase = '/ns/sfc-meta';
+                        if (urlObj.pathname.startsWith(metaBase + '/')) {
+                            const rawRemainder = urlObj.pathname.slice(metaBase.length);
+                            const parts = rawRemainder.split('/');
+                            if (parts.length > 2 && /^[0-9]+$/.test(parts[1] || '')) {
+                                // consume version but we don't need it server-side
+                            }
+                        }
+                    }
+                    let spec = urlObj.searchParams.get('path') || '';
+                    if (!spec) {
+                        res.statusCode = 400;
+                        res.end(JSON.stringify({ error: 'missing path' }));
+                        return;
+                    }
+                    if (spec.startsWith('@/'))
+                        spec = APP_VIRTUAL_WITH_SLASH + spec.slice(2);
+                    if (!spec.startsWith('/'))
+                        spec = '/' + spec;
+                    const base = spec.replace(/[?#].*$/, '');
+                    // Transform variants to inspect exports
+                    const [scriptR, templateR] = await Promise.all([server.transformRequest(base + '?vue&type=script'), server.transformRequest(base + '?vue&type=template')]);
+                    const scriptCode = scriptR?.code || '';
+                    const templateCode = templateR?.code || '';
+                    const scriptMeta = extractExportMetadata(scriptCode);
+                    // Robust render detection: Vue compiler may emit several shapes:
+                    // 1) export function render(_ctx, _cache) { ... }
+                    // 2) function render(_ctx,_cache) { ... } (later exported)
+                    // 3) export const render = (_ctx,_cache) => { ... }
+                    // 4) const render = (...) => { ... } (later exported)
+                    // 5) export { render } or export { render as render }
+                    // 6) Object property forms (rare in template output) render: (...) => {}
+                    const hasRender = /export\s+function\s+render\s*\(/.test(templateCode) || /(?:^|\n)\s*function\s+render\s*\(/.test(templateCode) || /export\s+(?:const|let|var)\s+render\s*=/.test(templateCode) || /(?:^|\n)\s*(?:const|let|var)\s+render\s*=/.test(templateCode) || /\brender\s*[:=]\s*/.test(templateCode) || /export\s*\{\s*render\s*(?:as\s*render)?\s*\}/.test(templateCode);
+                    if (hasRender && verbose) {
+                        try {
+                            console.log('[sfc-meta] detected render for', base);
+                        }
+                        catch { }
+                    }
+                    else if (!hasRender && verbose) {
+                        try {
+                            console.warn('[sfc-meta] render NOT detected for', base);
+                        }
+                        catch { }
+                    }
+                    const hash = createHash('md5').update(base).digest('hex').slice(0, 8);
+                    const payload = {
+                        path: base,
+                        hasScript: !!scriptCode,
+                        hasTemplate: !!templateCode,
+                        hasStyle: false,
+                        scriptExports: scriptMeta.named,
+                        scriptHasDefault: scriptMeta.hasDefault,
+                        templateHasRender: hasRender,
+                        hmrId: hash,
+                    };
+                    res.statusCode = 200;
+                    res.end(JSON.stringify(payload));
+                }
+                catch (e) {
+                    res.statusCode = 500;
+                    res.end(JSON.stringify({ error: e?.message || String(e) }));
+                }
+            });
+            // 5) Deterministic SFC assembler: GET /ns/asm?path=/src/Comp.vue
+            // Place BEFORE any broader /ns/sfc* handlers that might accidentally match and delegate.
+            server.middlewares.use(async (req, res, next) => {
+                try {
+                    const urlObj = new URL(req.url || '', 'http://localhost');
+                    if (!urlObj.pathname.startsWith('/ns/asm'))
+                        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');
+                    // Optional version segment as first path component after /ns/asm
+                    const asmBase = '/ns/asm';
+                    const asmRemainder = urlObj.pathname.slice(asmBase.length) || '';
+                    let verFromPath = null;
+                    if (asmRemainder && asmRemainder.startsWith('/')) {
+                        const p = asmRemainder.split('/');
+                        if (p.length > 1 && /^[0-9]+$/.test(p[1] || '')) {
+                            verFromPath = p[1];
+                        }
+                    }
+                    let spec = urlObj.searchParams.get('path') || '';
+                    const diag = urlObj.searchParams.get('diag') === '1';
+                    if (!spec) {
+                        res.statusCode = 400;
+                        res.end('export {}\n');
+                        return;
+                    }
+                    if (spec.startsWith('@/'))
+                        spec = APP_VIRTUAL_WITH_SLASH + spec.slice(2);
+                    if (!spec.startsWith('/'))
+                        spec = '/' + spec;
+                    const base = spec.replace(/[?#].*$/, '');
+                    if (diag) {
+                        const code = `// [sfc-asm] ${base} (diag)\n` + `// vue shim for diag-only instantiation\n` + `var _createElementVNode = globalThis.createElementVNode || globalThis._createElementVNode;\n` + `const __ns_sfc__ = { name: ${JSON.stringify(base.split('/').pop() || 'DiagComp')}, render(){ return _createElementVNode ? _createElementVNode('StackLayout') : (globalThis.createElementVNode ? globalThis.createElementVNode('StackLayout') : {}); } };\nexport default __ns_sfc__;\n`;
+                        res.statusCode = 200;
+                        res.end(code);
+                        return;
+                    }
+                    const projectRoot = server.config?.root || process.cwd();
+                    // Ensure variant transforms exist so imports resolve (avoid Promise.all short-circuit on single failure)
+                    const safeTransform = async (cand) => {
+                        try {
+                            return await server.transformRequest(cand);
+                        }
+                        catch {
+                            return null;
+                        }
+                    };
+                    const scriptR = await safeTransform(base + '?vue&type=script');
+                    const templateR = await safeTransform(base + '?vue&type=template');
+                    const fullR = await safeTransform(base + '?vue');
+                    const hasScript = !!scriptR?.code;
+                    const hasTemplate = !!templateR?.code;
+                    const origin = getServerOrigin(server);
+                    const ver = String(verFromPath || graphVersion || Date.now());
+                    const scriptUrl = `${origin}/ns/sfc/${ver}${base}?vue&type=script`;
+                    const templateCode = templateR?.code || '';
+                    // INLINE-FIRST assembler: compile SFC source into a self-contained ESM module (enhanced diagnostics)
+                    try {
+                        const root = server.config?.root || process.cwd();
+                        const abs = path.join(root, base.replace(/^\//, ''));
+                        let sfcSrc = '';
+                        try {
+                            sfcSrc = readFileSync(abs, 'utf-8');
+                        }
+                        catch { }
+                        if (sfcSrc) {
+                            const { descriptor } = parse(sfcSrc, { filename: abs });
+                            const id = createHash('md5').update(abs).digest('hex').slice(0, 8);
+                            // 1) Compile script (prefer inlineTemplate for a complete module)
+                            let compiledScript = '';
+                            let bindingMetadata = undefined;
+                            let triedInlineTemplate = false;
+                            let hadScriptDefaultPre = false;
+                            let usedInlineScript = false;
+                            try {
+                                // First try inlineTemplate for a holistic, self-contained module with render + hoists
+                                // Use a strict NativeScript native element detector for inlineTemplate that does NOT treat generic PascalCase as native.
+                                // This ensures imported components like PageWrapper remain true components and get referenced via bindings.
+                                const isNSNative = (tag) => NS_NATIVE_TAGS.has(tag);
+                                const sInline = compileScript(descriptor, {
+                                    id,
+                                    inlineTemplate: true,
+                                    reactivityTransform: false,
+                                    // Pass only strict NS native element predicate; avoid broad PascalCase heuristic here.
+                                    templateOptions: {
+                                        compilerOptions: { isCustomElement: isNSNative },
+                                    },
+                                });
+                                triedInlineTemplate = true;
+                                if (/export\s+default/.test(sInline?.content || '')) {
+                                    compiledScript = sInline.content;
+                                    bindingMetadata = sInline?.bindings;
+                                    hadScriptDefaultPre = true;
+                                    usedInlineScript = true;
+                                }
+                                else {
+                                    // Fallback to standard script (no inline) and attempt separate template compile
+                                    const s = compileScript(descriptor, {
+                                        id,
+                                        inlineTemplate: false,
+                                        reactivityTransform: false,
+                                    });
+                                    compiledScript = s?.content || '';
+                                    bindingMetadata = s?.bindings;
+                                    hadScriptDefaultPre = /export\s+default/.test(compiledScript);
+                                    usedInlineScript = false;
+                                }
+                            }
+                            catch (eScript) {
+                                if (verbose) {
+                                    try {
+                                        console.warn('[sfc-asm][compileScript] failed', base, eScript?.message);
+                                    }
+                                    catch { }
+                                }
+                                // Retry without inlineTemplate
+                                try {
+                                    const s = compileScript(descriptor, {
+                                        id,
+                                        inlineTemplate: false,
+                                        reactivityTransform: false,
+                                    });
+                                    compiledScript = s?.content || '';
+                                    bindingMetadata = s?.bindings;
+                                    hadScriptDefaultPre = /export\s+default/.test(compiledScript);
+                                    usedInlineScript = false;
+                                }
+                                catch (eNoInline) {
+                                    if (verbose) {
+                                        try {
+                                            console.warn('[sfc-asm][compileScript][no-inline-fallback] failed', base, eNoInline?.message);
+                                        }
+                                        catch { }
+                                    }
                                 }
-                                res.statusCode = 200;
-                                res.end(buildVersionedCoreSubpathAliasModule(resolvedSubpath, ver));
-                                return;
                             }
-                            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;
+                            // Final fallback: if script compile yielded nothing, use the variant-transformed script
+                            if (!compiledScript && scriptR?.code) {
+                                try {
+                                    compiledScript = scriptR.code;
+                                    hadScriptDefaultPre = /export\s+default/.test(compiledScript);
+                                }
+                                catch { }
                             }
-                        }
-                        catch (e) {
+                            // If inlineTemplate produced a default export AND visibly contains a render, allow early-return.
+                            // Visible render forms we accept:
+                            //  - export function render(...) { ... }
+                            //  - setup(...) { ... return (_ctx, _cache) => { ... } }
+                            const hasInlineRender = /(^|\n)\s*export\s+function\s+render\s*\(/.test(compiledScript || '') || /\breturn\s*\(\s*_ctx\s*,\s*_cache\s*\)\s*=>\s*\{/.test(compiledScript || '');
+                            // Always use canonical assembler path; avoid inlineTemplate early-return which can miss render attachment
+                            // If we reached here, we are going to assemble canonically. Ensure the script we use does NOT include inlineTemplate render.
+                            if (usedInlineScript) {
+                                try {
+                                    const sNoInline = compileScript(descriptor, {
+                                        id,
+                                        inlineTemplate: false,
+                                        reactivityTransform: false,
+                                    });
+                                    compiledScript = sNoInline?.content || compiledScript;
+                                    bindingMetadata = sNoInline?.bindings || bindingMetadata;
+                                }
+                                catch (eNoInline) {
+                                    if (verbose) {
+                                        try {
+                                            console.warn('[sfc-asm][compileScript][no-inline-fallback] failed', base, eNoInline?.message);
+                                        }
+                                        catch { }
+                                    }
+                                }
+                            }
+                            // 2) Compile template
+                            let compiledTplCode = '';
+                            let templateErr = null;
                             try {
-                                console.warn('[ns-core-bridge] deep subpath serve failed:', sub, e?.message);
+                                const tplSrc = descriptor.template?.content || '';
+                                if (tplSrc) {
+                                    const ct = compileTemplate({
+                                        source: tplSrc,
+                                        id,
+                                        filename: abs,
+                                        isProd: false,
+                                        ssr: false,
+                                        compilerOptions: {
+                                            bindingMetadata,
+                                            isCustomElement: (tag) => NS_NATIVE_TAGS.has(tag),
+                                        },
+                                    });
+                                    compiledTplCode = (ct && (ct.code || '')) || '';
+                                    if (ct?.errors?.length && verbose) {
+                                        try {
+                                            console.warn('[sfc-asm][compileTemplate][errors]', base, ct.errors);
+                                        }
+                                        catch { }
+                                    }
+                                }
                             }
-                            catch { }
-                        }
-                    }
-                    // Main entry or shallow subpath: use proxy bridge
-                    let code = buildVersionedCoreMainBridgeModule(key, ver);
-                    if (!sub) {
-                        try {
-                            const projectRoot = server.config?.root || process.cwd();
-                            const coreSpecifier = '@nativescript/core';
-                            const resolved = await server.pluginContainer?.resolveId?.(coreSpecifier, undefined);
-                            const resolvedId = typeof resolved === 'string' ? resolved : resolved?.id || null;
-                            const modulePath = resolvedId || '/node_modules/@nativescript/core/index.js';
-                            const staticExportNames = collectStaticExportNamesFromFile(modulePath);
-                            const staticExportOrigins = await normalizeCoreExportOriginsForRuntime(collectStaticExportOriginsFromFile(modulePath), async (moduleId) => {
-                                const nextResolved = await server.pluginContainer?.resolveId?.(moduleId, undefined);
-                                return typeof nextResolved === 'string' ? nextResolved : nextResolved?.id || null;
-                            }, modulePath);
-                            if (staticExportNames.length) {
-                                code = buildVersionedCoreMainBridgeModule(key, ver, staticExportNames, staticExportOrigins);
+                            catch (eTpl) {
+                                templateErr = eTpl;
+                                if (verbose) {
+                                    try {
+                                        console.warn('[sfc-asm][compileTemplate] failed', base, eTpl?.message);
+                                    }
+                                    catch { }
+                                }
+                                // Fallback: use the variant-transformed template code if available
+                                try {
+                                    if (templateR?.code)
+                                        compiledTplCode = templateR.code;
+                                }
+                                catch { }
+                            }
+                            // If still no template code, synthesize a minimal render stub so the module is valid
+                            if (!compiledTplCode) {
+                                try {
+                                    compiledTplCode = "export function render(){ const _ = (globalThis.createElementVNode||globalThis._createElementVNode); return _? _('StackLayout') : {}; }\n";
+                                }
+                                catch { }
+                            }
+                            // 3) Sanitize script and rewrite .vue imports to inline assembler
+                            let scriptBody = compiledScript || '';
+                            if (scriptBody) {
+                                // Do NOT strip Vue/nativescript-vue imports; retarget them to the runtime bridge so helpers (e.g., onMounted) are bound.
+                                // Preserve the import clause and only rewrite the source to '/ns/rt'.
+                                scriptBody = scriptBody.replace(/(^|\n)\s*import\s+([^;\n]+)\s+from\s+["'](?:vue|nativescript-vue|~\/vendor\.mjs)(?:\/[^"]*)?["'];?/g, (_m, pfx, clause) => `${pfx}import ${clause} from "/ns/rt";`);
+                                try {
+                                    const importerDir = path.posix.dirname(base);
+                                    scriptBody = scriptBody.replace(/(^|\n)\s*import\s+([^;\n]+)\s+from\s+["']([^"'\n]+\.vue)(?:\?[^"'\n]*)?["'];?/g, (_m, pfx, clause, spec) => {
+                                        let absImp = spec;
+                                        if (spec.startsWith('./') || spec.startsWith('../')) {
+                                            absImp = path.posix.normalize(path.posix.join(importerDir, spec));
+                                            if (!absImp.startsWith('/'))
+                                                absImp = '/' + absImp;
+                                        }
+                                        else if (!spec.startsWith('/')) {
+                                            if (absImp.startsWith('@/'))
+                                                absImp = APP_VIRTUAL_WITH_SLASH + absImp.slice(2);
+                                        }
+                                        const asmUrl = `/ns/asm/${ver}?path=${encodeURIComponent(absImp)}&mode=inline`;
+                                        return `${pfx}import ${clause} from ${JSON.stringify(asmUrl)};`;
+                                    });
+                                }
+                                catch { }
+                            }
+                            // 4) Extract render from compiled template and prepare a full inline template block
+                            let helperBindings = '';
+                            let renderDecl = '';
+                            let inlineBlock = undefined;
+                            let renderOk = false;
+                            if (compiledTplCode) {
+                                try {
+                                    // Build a full inline template block to preserve hoists where possible
+                                    inlineBlock = buildInlineTemplateBlock(compiledTplCode) || undefined;
+                                    if (!inlineBlock) {
+                                        const extracted = extractTemplateRender(compiledTplCode);
+                                        helperBindings = extracted.helperBindings;
+                                        renderDecl = extracted.renderDecl;
+                                        inlineBlock = extracted.inlineBlock;
+                                        renderOk = extracted.ok;
+                                    }
+                                    else {
+                                        renderOk = true;
+                                    }
+                                }
+                                catch (eExtract) {
+                                    if (verbose) {
+                                        try {
+                                            console.warn('[sfc-asm][extractTemplateRender] failed', base, eExtract?.message);
+                                        }
+                                        catch { }
+                                    }
+                                }
+                            }
+                            // Final guard: if no inline render extracted, attempt to import template variant or synthesize a no-op render
+                            if (!renderOk && !inlineBlock) {
+                                try {
+                                    const templateUrl = `${origin}/ns/sfc/${ver}${base}?vue&type=template`;
+                                    const importLine = `import * as __template from ${JSON.stringify(templateUrl)};`;
+                                    // Attach only if scriptTransformed produces __ns_sfc__ later
+                                    helperBindings += `\n${importLine}`;
+                                    renderDecl += `\nfunction __ns_getRender(){\n  try {\n    if (__template && __template.render) return __template.render;\n  } catch (_e) {}\n  try {\n    const _ = globalThis.createElementVNode || globalThis._createElementVNode;\n    return _ ? function(){ return _('StackLayout'); } : function(){ return {}; };\n  } catch (_e) { return function(){ return {}; }; }\n}\n`;
+                                    renderOk = true;
+                                }
+                                catch { }
+                            }
+                            // 5) Convert default export to const __ns_sfc__
+                            let scriptTransformed = scriptBody;
+                            if (scriptTransformed) {
+                                scriptTransformed = scriptTransformed.replace(/(^|\n)\s*export\s+default\s+/g, '$1const __ns_sfc__ = ').replace(/(^|\n)\s*export\s*\{[^}]*\}\s*;?\s*/g, '\n/* removed named exports for inline asm */\n');
+                                // Normalize any prior declaration of __ns_sfc__ to a plain assignment to avoid redeclare
+                                // Accept a semicolon before the declaration too
+                                scriptTransformed = scriptTransformed.replace(/(^|[\n;])\s*(?:const|let|var)\s+__ns_sfc__\s*=\s*/g, '$1__ns_sfc__ = ');
+                                // Ensure a single declaration appears once before first assignment
+                                if (!/(^|[\n;])\s*(?:const|let|var)\s+__ns_sfc__\b/.test(scriptTransformed)) {
+                                    scriptTransformed = `let __ns_sfc__;\n` + scriptTransformed;
+                                }
+                                // Remove stray leading braces (artifact defense)
+                                scriptTransformed = scriptTransformed.replace(/^\s*\}+(?=\s*[^}])/, (m) => `/* [asm-fix] removed ${m.length} stray leading braces */\n`);
                             }
                             else {
-                                const transformed = await sharedTransformRequest(modulePath);
-                                if (transformed?.code) {
-                                    const expandedModuleCode = await expandStarExports(transformed.code, server, projectRoot, verbose);
-                                    code = buildVersionedCoreMainBridgeModule(key, ver, extractExportedNames(expandedModuleCode));
+                                try {
+                                    const compName = (base.split('/').pop() || 'Component').replace(/\.vue$/i, '') || 'Component';
+                                    scriptTransformed = `import { defineComponent as _defineComponent } from "/ns/rt";\nlet __ns_sfc__;\n__ns_sfc__ = /*@__PURE__*/_defineComponent({ __name: ${JSON.stringify(compName)} });`;
+                                }
+                                catch {
+                                    scriptTransformed = `import { defineComponent as _defineComponent } from "/ns/rt";\nlet __ns_sfc__;\n__ns_sfc__ = /*@__PURE__*/_defineComponent({});`;
                                 }
                             }
-                        }
-                        catch (e) {
+                            // 6) Emit final inline module with diagnostics comment
+                            const parts = [];
+                            parts.push(`// [sfc-asm] ${base} (inline-compiled)`);
+                            // Deterministic path: always use extracted helperBindings + renderDecl + scriptTransformed (ignore inlineBlock)
+                            // Emit hoisted template bindings first
+                            if (helperBindings)
+                                parts.push(helperBindings);
+                            // IMPORTANT: place script (with its imports) BEFORE renderDecl so imports never appear inside the render function.
+                            parts.push(scriptTransformed);
+                            parts.push(renderDecl);
+                            parts.push(`try { if (!__ns_sfc__.render) Object.defineProperty(__ns_sfc__, 'render', { configurable: true, enumerable: true, get(){ const r = (typeof __ns_getRender==='function' ? __ns_getRender() : undefined); Object.defineProperty(__ns_sfc__, 'render', { value: r, writable: true, configurable: true, enumerable: true }); return r; }, set(v){ Object.defineProperty(__ns_sfc__, 'render', { value: v, writable: true, configurable: true, enumerable: true }); } }); } catch(_e){}`);
+                            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, true);
                             try {
-                                console.warn('[ns-core-bridge] main bridge export discovery failed:', e?.message);
+                                inlineCode = ensureVersionedCoreImports(inlineCode, getServerOrigin(server), Number(ver));
                             }
                             catch { }
+                            try {
+                                inlineCode = ensureDestructureCoreImports(inlineCode);
+                            }
+                            catch { }
+                            // Replace legacy mutation pipeline with canonical assembler for reliability
+                            {
+                                // First: strip TypeScript robustly using Babel transform
+                                try {
+                                    const tsRes = await babelCore.transformAsync(scriptTransformed, {
+                                        plugins: [[pluginTransformTypescript, { allowDeclareFields: true }]],
+                                        ast: false,
+                                        sourceType: 'module',
+                                        configFile: false,
+                                        babelrc: false,
+                                    });
+                                    if (tsRes?.code)
+                                        scriptTransformed = tsRes.code;
+                                }
+                                catch (eTs) {
+                                    if (verbose) {
+                                        try {
+                                            console.warn('[sfc-asm][babel-ts][fail]', base, eTs?.message);
+                                        }
+                                        catch { }
+                                    }
+                                }
+                                // Hoist imports + strip residual TS via AST
+                                let importLines = [];
+                                try {
+                                    const astRes = astExtractImportsAndStripTypes(scriptTransformed);
+                                    importLines = astRes.imports;
+                                    scriptTransformed = astRes.body;
+                                    if (astRes.diagnostics.length && verbose) {
+                                        try {
+                                            console.warn('[sfc-asm][ast]', base, astRes.diagnostics.join('; '));
+                                        }
+                                        catch { }
+                                    }
+                                }
+                                catch (eAst) {
+                                    if (verbose) {
+                                        try {
+                                            console.warn('[sfc-asm][ast][fail]', base, eAst?.message);
+                                        }
+                                        catch { }
+                                    }
+                                }
+                                // Ensure renderDecl ends with closing brace ONLY for function declaration forms
+                                // Avoid appending to const-assignment forms like: const __ns_render = (function(){ ... })();
+                                if (renderDecl && /(^|\n)\s*(?:export\s+)?function\s+__ns_render\s*\(/.test(renderDecl) && !/\}\s*$/.test(renderDecl)) {
+                                    renderDecl = renderDecl.trimEnd() + '\n}';
+                                }
+                                const outParts = [];
+                                outParts.push(`// [sfc-asm] ${base} (inline-compiled)`);
+                                outParts.push('// [sfc-asm][canonical]');
+                                if (importLines.length)
+                                    outParts.push(Array.from(new Set(importLines)).join('\n'));
+                                // Place component script first so the component object exists before we attach render.
+                                outParts.push(scriptTransformed);
+                                // Prefer full template block to guarantee presence of all hoisted constants.
+                                if (inlineBlock) {
+                                    outParts.push(inlineBlock);
+                                }
+                                else {
+                                    if (helperBindings)
+                                        outParts.push(helperBindings);
+                                    if (renderDecl && renderDecl.trim())
+                                        outParts.push(renderDecl);
+                                }
+                                outParts.push(`try { if (!__ns_sfc__.render) Object.defineProperty(__ns_sfc__, 'render', { configurable: true, enumerable: true, get(){ const r = (typeof __ns_getRender==='function' ? __ns_getRender() : (typeof __ns_render==='function' ? __ns_render : undefined)); Object.defineProperty(__ns_sfc__, 'render', { value: r, writable: true, configurable: true, enumerable: true }); return r; }, set(v){ Object.defineProperty(__ns_sfc__, 'render', { value: v, writable: true, configurable: true, enumerable: true }); } }); } catch(_e){}`);
+                                // Export named render as a function that resolves lazily
+                                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, true);
+                                try {
+                                    inlineCode2 = ensureVersionedCoreImports(inlineCode2, getServerOrigin(server), Number(ver));
+                                }
+                                catch { }
+                                try {
+                                    inlineCode2 = ensureDestructureCoreImports(inlineCode2);
+                                }
+                                catch { }
+                                // Hoist any late imports that accidentally landed after render or script assembly
+                                try {
+                                    const lateImportRe = /^(?!\/\/).*^\s*import\s+[^;]+;?$/gm;
+                                    const allImports = [];
+                                    inlineCode2 = inlineCode2.replace(lateImportRe, (imp) => {
+                                        allImports.push(imp);
+                                        return '';
+                                    });
+                                    if (allImports.length) {
+                                        // Place after helperBindings sentinel
+                                        inlineCode2 = inlineCode2.replace(/(\/\/ \[sfc-asm\]\[canonical\]\n)/, `$1${Array.from(new Set(allImports)).join('\n')}\n/* [asm-fix] re-hoisted ${allImports.length} imports */\n`);
+                                    }
+                                }
+                                catch { }
+                                // After hoisting, re-run AST normalization and duplicate-binding verification.
+                                // This guards against freshly hoisted imports reintroducing identifiers that collide
+                                // with earlier destructures (e.g., __ns_core_ns_1), which would otherwise surface at device runtime.
+                                try {
+                                    inlineCode2 = astNormalizeModuleImportsAndHelpers(inlineCode2);
+                                }
+                                catch { }
+                                try {
+                                    inlineCode2 = astVerifyAndAnnotateDuplicates(inlineCode2);
+                                    if (/^\s*\/\/ \[ast-verify\]\[duplicate-bindings\]/m.test(inlineCode2)) {
+                                        const diagnosticLine = (inlineCode2.match(/^\s*\/\/ \[ast-verify\]\[duplicate-bindings\][^\n]*/m) || [])[0] || '// [ast-verify][duplicate-bindings]';
+                                        const brief = diagnosticLine.replace(/^[^:]*:?\s?/, '');
+                                        const escaped = brief.replace(/["\\]/g, '\\$&');
+                                        const thrower = `throw new Error("[nsv-hmr] Duplicate top-level bindings detected post-hoist: ${escaped}");`;
+                                        inlineCode2 = `${thrower}\n` + inlineCode2;
+                                    }
+                                }
+                                catch { }
+                                // Minimal cleanup only (avoid destructive type stripping breaking object literal property defaults)
+                                try {
+                                    // Heal cases where a TS type strip earlier removed initializer: plain 'default' inside props objects
+                                    // becomes 'default: undefined'. We only match when followed by ',' or '}' or newline to avoid 'export default'.
+                                    inlineCode2 = inlineCode2.replace(/\bdefault\b\s*(?=\}|,|\n)/g, 'default: undefined');
+                                    // Remove obvious leftover angle generic markers
+                                    inlineCode2 = inlineCode2.replace(/<unknown>/g, '');
+                                    // Fix accidental '}=> {' sequences
+                                    inlineCode2 = inlineCode2.replace(/}\s*=>\s*\{/g, '');
+                                    // No-op: removed prior broken normalization. Handlers are fixed in the dedicated passes below.
+                                }
+                                catch { }
+                                // Removed redundant render closure heal that could inject an extra '}' before component script.
+                                // Rewrite any remaining imports (e.g., relative app paths) to HTTP ESM endpoints
+                                try {
+                                    inlineCode2 = rewriteImports(inlineCode2, base, sfcFileMap, depFileMap, projectRoot, !!verbose, undefined, getServerOrigin(server));
+                                }
+                                catch { }
+                                // Final TS strip on the whole assembled module (safety net)
+                                try {
+                                    const tsFinal = await babelCore.transformAsync(inlineCode2, {
+                                        plugins: [[pluginTransformTypescript, { allowDeclareFields: true }]],
+                                        ast: false,
+                                        sourceType: 'module',
+                                        configFile: false,
+                                        babelrc: false,
+                                    });
+                                    if (tsFinal?.code)
+                                        inlineCode2 = tsFinal.code;
+                                }
+                                catch { }
+                                // Heal Vue v-model update handlers that lost the ": else" branch during transforms:
+                                // "onUpdate:modelValue": _cache[N] || (_cache[N] = $event => _isRef(name) ? name.value = $event)
+                                // → add else branch to keep syntax valid: : (name = $event)
+                                try {
+                                    // Fix missing else branch on v-model handlers: support dotted expressions (e.g., $setup.acceptTerms)
+                                    const reMissingElse = /\"onUpdate:modelValue\"\s*:\s*_cache\[(\d+)\]\s*\|\|\s*\(_cache\[\1\]\s*=\s*\$event\s*=>\s*_isRef\(\s*([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*\)\s*\?\s*\2\.value\s*=\s*\$event\s*\)/g;
+                                    inlineCode2 = inlineCode2.replace(reMissingElse, (_m, idx, expr) => {
+                                        return `\"onUpdate:modelValue\": _cache[${idx}] || (_cache[${idx}] = $event => (_isRef(${expr}) ? (${expr}.value = $event) : (${expr} = $event)))`;
+                                    });
+                                    // Repair malformed handlers without an arrow (introduced by previous transforms):
+                                    // Convert pattern assigning to $event without an arrow into a proper arrow using the same target expression.
+                                    const reMalformed = /\"onUpdate:modelValue\"\s*:\s*_cache\[(\d+)\]\s*\|\|\s*\(_cache\[\1\]\s*=\s*[^=]*\(\s*([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*\)[^=]*=\s*\$event\s*\)\s*\)/g;
+                                    inlineCode2 = inlineCode2.replace(reMalformed, (_m, idx, expr) => {
+                                        return `\"onUpdate:modelValue\": _cache[${idx}] || (_cache[${idx}] = $event => (_isRef(${expr}) ? (${expr}.value = $event) : (${expr} = $event)))`;
+                                    });
+                                }
+                                catch { }
+                                // Structural heal: ensure balanced braces before the first import statement
+                                try {
+                                    const idx = inlineCode2.search(/^[\t ]*import\b/m);
+                                    if (idx > 0) {
+                                        const prefix = inlineCode2.slice(0, idx);
+                                        let open = 0, close = 0;
+                                        let inS = false, inD = false, inT = false, inLC = false, inBC = false;
+                                        for (let i = 0; i < prefix.length; i++) {
+                                            const ch = prefix[i], nx = prefix[i + 1];
+                                            if (inLC) {
+                                                if (ch === '\n')
+                                                    inLC = false;
+                                                continue;
+                                            }
+                                            if (inBC) {
+                                                if (ch === '*' && nx === '/') {
+                                                    inBC = false;
+                                                    i++;
+                                                }
+                                                continue;
+                                            }
+                                            if (inS) {
+                                                if (ch === '\\') {
+                                                    i++;
+                                                    continue;
+                                                }
+                                                if (ch === "'")
+                                                    inS = false;
+                                                continue;
+                                            }
+                                            if (inD) {
+                                                if (ch === '\\') {
+                                                    i++;
+                                                    continue;
+                                                }
+                                                if (ch === '"')
+                                                    inD = false;
+                                                continue;
+                                            }
+                                            if (inT) {
+                                                if (ch === '\\') {
+                                                    i++;
+                                                    continue;
+                                                }
+                                                if (ch === '`')
+                                                    inT = false;
+                                                continue;
+                                            }
+                                            if (ch === '/' && nx === '/') {
+                                                inLC = true;
+                                                i++;
+                                                continue;
+                                            }
+                                            if (ch === '/' && nx === '*') {
+                                                inBC = true;
+                                                i++;
+                                                continue;
+                                            }
+                                            if (ch === "'") {
+                                                inS = true;
+                                                continue;
+                                            }
+                                            if (ch === '"') {
+                                                inD = true;
+                                                continue;
+                                            }
+                                            if (ch === '`') {
+                                                inT = true;
+                                                continue;
+                                            }
+                                            if (ch === '{')
+                                                open++;
+                                            else if (ch === '}')
+                                                close++;
+                                        }
+                                        const missing = open - close;
+                                        if (missing > 0) {
+                                            inlineCode2 = inlineCode2.slice(0, idx) + '}'.repeat(missing) + '\n' + inlineCode2.slice(idx);
+                                        }
+                                    }
+                                }
+                                catch { }
+                                // Final TS strip on the whole assembled module (safety net)
+                                try {
+                                    const tsFinal = await babelCore.transformAsync(inlineCode2, {
+                                        plugins: [[pluginTransformTypescript, { allowDeclareFields: true }]],
+                                        ast: false,
+                                        sourceType: 'module',
+                                        configFile: false,
+                                        babelrc: false,
+                                    });
+                                    if (tsFinal?.code)
+                                        inlineCode2 = tsFinal.code;
+                                }
+                                catch { }
+                                inlineCode2 = ensureVariableDynamicImportHelper(inlineCode2);
+                                inlineCode2 = ensureGuardPlainDynamicImports(inlineCode2, origin);
+                                inlineCode2 = REQUIRE_GUARD_SNIPPET + inlineCode2;
+                                // If no render materialized, return a clear error module for deterministic failure
+                                try {
+                                    const lacksRender = !/__ns_render\b/.test(inlineCode2) && !/__ns_sfc__\.render\s*=/.test(inlineCode2);
+                                    if (lacksRender) {
+                                        const err = `throw new Error(\"[sfc-asm] ${base}: no render generated by assembler\");\nexport default {};`;
+                                        res.statusCode = 200;
+                                        res.end(err);
+                                        return;
+                                    }
+                                }
+                                catch { }
+                                // Cosmetic and parser-friendly: ensure a newline after the canonical banner
+                                try {
+                                    inlineCode2 = inlineCode2.replace(/(\/\/ \[sfc-asm\]\[canonical\])(?!\n)/, '$1\n');
+                                }
+                                catch { }
+                                // Bust device cache for runtime bridge so helpers are always current for this graph version
+                                try {
+                                    const origin = getServerOrigin(server);
+                                    inlineCode2 = ensureVersionedRtImports(inlineCode2, origin, Number(ver));
+                                    inlineCode2 = ACTIVE_STRATEGY.ensureVersionedImports(inlineCode2, origin, Number(ver));
+                                    inlineCode2 = ensureVersionedCoreImports(inlineCode2, origin, Number(ver));
+                                }
+                                catch { }
+                                // Normalize imports/helpers via AST to ensure _defineComponent and other helpers are bound once
+                                try {
+                                    inlineCode2 = astNormalizeModuleImportsAndHelpers(inlineCode2);
+                                }
+                                catch { }
+                                // Guarantee a concrete component object exists before exporting default.
+                                try {
+                                    // Detect an existing declaration of __ns_sfc__ even if it's appended after a semicolon on the same line
+                                    // e.g., "import ...;let __ns_sfc__;" (no newline). Accept start-of-string, newline, or semicolon as anchors.
+                                    const hasDecl = /(^|[\n;])\s*(?:const|let|var)\s+__ns_sfc__\b/.test(inlineCode2);
+                                    if (!hasDecl) {
+                                        inlineCode2 = inlineCode2.replace(/(\/\/ \[sfc-asm\]\[canonical\]\n)/, `$1let __ns_sfc__ = {};\n`);
+                                    }
+                                    // Heal empty declarations (e.g., "let __ns_sfc__;" → initialize to {}), also when preceded by a semicolon
+                                    inlineCode2 = inlineCode2.replace(/(^|[\n;])\s*let\s+__ns_sfc__\s*;?/g, '$1let __ns_sfc__ = {};');
+                                    inlineCode2 = inlineCode2.replace(/(^|[\n;])\s*var\s+__ns_sfc__\s*;?/g, '$1var __ns_sfc__ = {};');
+                                }
+                                catch { }
+                                if (!/export\s+default\s+__ns_sfc__/.test(inlineCode2) && /__ns_sfc__/.test(inlineCode2))
+                                    inlineCode2 += '\nexport default __ns_sfc__';
+                                res.statusCode = 200;
+                                res.end(inlineCode2);
+                                return;
+                            }
+                        }
+                    }
+                    catch { }
+                    // Do not use compiled ?vue or variant fallbacks; assembler must succeed or emit an error
+                    // Prefer compiling template from source via compiler-sfc; fallback to variant extraction
+                    let inlineOk = false;
+                    let helperBindings = '';
+                    let renderDecl = '';
+                    let inlineBlock = undefined;
+                    try {
+                        const root = server.config?.root || process.cwd();
+                        const abs = path.join(root, base.replace(/^\//, ''));
+                        let sfcSrc = '';
+                        try {
+                            sfcSrc = readFileSync(abs, 'utf-8');
+                        }
+                        catch { }
+                        if (sfcSrc) {
+                            const { descriptor } = parse(sfcSrc, { filename: abs });
+                            const tpl = descriptor.template?.content || '';
+                            if (tpl) {
+                                const id = createHash('md5').update(abs).digest('hex').slice(0, 8);
+                                const ct = compileTemplate({
+                                    source: tpl,
+                                    id,
+                                    filename: abs,
+                                    isProd: false,
+                                    ssr: false,
+                                    compilerOptions: {
+                                        isCustomElement: (tag) => NS_NATIVE_TAGS.has(tag),
+                                    },
+                                });
+                                let compiled = (ct && (ct.code || '')) || '';
+                                if (compiled) {
+                                    // Prefer a full inline template block preserving hoists
+                                    inlineBlock = buildInlineTemplateBlock(compiled) || undefined;
+                                    if (inlineBlock) {
+                                        inlineOk = true;
+                                    }
+                                    else {
+                                        const extracted = extractTemplateRender(compiled);
+                                        inlineOk = extracted.ok;
+                                        helperBindings = extracted.helperBindings;
+                                        renderDecl = extracted.renderDecl;
+                                        inlineBlock = extracted.inlineBlock;
+                                    }
+                                }
+                            }
                         }
                     }
+                    catch { }
+                    // If compiler-sfc path didn't succeed, attempt variant extraction once
+                    if (!inlineOk) {
+                        const extracted = extractTemplateRender(templateCode);
+                        inlineOk = extracted.ok;
+                        helperBindings = extracted.helperBindings;
+                        renderDecl = extracted.renderDecl;
+                        inlineBlock = extracted.inlineBlock;
+                    }
+                    let asm;
+                    if (inlineOk) {
+                        if (inlineBlock && inlineBlock.trim()) {
+                            asm = [`// [sfc-asm] ${base} (inlined template body)`, `export * from ${JSON.stringify(scriptUrl)};`, `import * as __script from ${JSON.stringify(scriptUrl)};`, inlineBlock, `const __ns_sfc__ = (__script && __script.default) ? __script.default : {};`, `try { if (typeof __ns_render === 'function' && !__ns_sfc__.render) __ns_sfc__.render = __ns_render; } catch {}`, `export default __ns_sfc__;`].join('\n');
+                        }
+                        else {
+                            asm = [`// [sfc-asm] ${base} (inlined template)`, `export * from ${JSON.stringify(scriptUrl)};`, `import * as __script from ${JSON.stringify(scriptUrl)};`, helperBindings, renderDecl, `const __ns_sfc__ = (__script && __script.default) ? __script.default : {};`, `try { if (typeof __ns_render === 'function' && !__ns_sfc__.render) __ns_sfc__.render = __ns_render; } catch {}`, `export default __ns_sfc__;`].filter(Boolean).join('\n');
+                        }
+                    }
+                    else {
+                        // Deterministic error path when template extraction failed
+                        res.statusCode = 500;
+                        res.end(`throw new Error('[sfc-asm] ${base}: template extraction failed');\nexport default {};`);
+                        return;
+                    }
+                    // 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, true, /(?:^|\/)node_modules\//.test(base), base);
+                    try {
+                        code = ensureVersionedCoreImports(code, getServerOrigin(server), Number(ver));
+                    }
+                    catch { }
+                    code = rewriteImports(code, base, sfcFileMap, depFileMap, projectRoot, !!verbose, undefined, getServerOrigin(server));
+                    try {
+                        code = ensureDestructureCoreImports(code);
+                    }
+                    catch { }
+                    code = ensureVariableDynamicImportHelper(code);
+                    code = ensureGuardPlainDynamicImports(code, origin);
+                    try {
+                        const origin = getServerOrigin(server);
+                        code = ensureVersionedRtImports(code, origin, Number(ver));
+                        code = ACTIVE_STRATEGY.ensureVersionedImports(code, origin, Number(ver));
+                        code = ensureVersionedCoreImports(code, origin, Number(ver));
+                    }
+                    catch { }
+                    // Inline-template body path already runs processCodeForDevice (AST + sanitizers); no additional _defineComponent fix needed
                     res.statusCode = 200;
                     res.end(code);
                 }
                 catch (e) {
-                    next();
+                    res.statusCode = 500;
+                    res.end('export {}\n');
                 }
             });
-            registerTxnHandler(server, {
-                resolveTxnIds: (version, fallbackChangedIds) => {
-                    const ids = txnBatches.get(version) || [];
-                    if (ids.length) {
-                        return ids;
-                    }
-                    return fallbackChangedIds.length ? computeTxnOrderForChanged(fallbackChangedIds) : [];
-                },
-            });
-            registerVueSfcHandlers(server, {
-                verbose,
-                requireGuardSnippet: REQUIRE_GUARD_SNIPPET,
-                appVirtualWithSlash: APP_VIRTUAL_WITH_SLASH,
-                sfcFileMap,
-                depFileMap,
-                getGraphVersion: () => Number(graphVersion || 0),
-                getStrategy: () => ACTIVE_STRATEGY,
-                getServerOrigin,
-                cleanCode,
-                processCodeForDevice,
-                rewriteImports,
-                ensureVariableDynamicImportHelper,
-                ensureGuardPlainDynamicImports,
-                ensureVersionedRtImports,
-                ensureVersionedCoreImports,
-                ensureDestructureCoreImports,
-                extractExportMetadata,
-            });
             wss.on('connection', async (ws) => {
                 if (verbose)
                     console.log('[hmr-ws] Client connected (dynamic fetch mode)');
@@ -3690,6 +6054,103 @@ export const piniaSymbol = p.piniaSymbol;
             if (isRuntimeGraphExcludedPath(file)) {
                 return;
             }
+            // Always-on update timing — see HMR_CORE_REALM_DETERMINISTIC_PLAN.md
+            // ("Track 2 — round one, 2026-04: HMR update metrics"). 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,
+                // Round-eight diagnostic — populated by the angular branch when
+                // the changed file is `.ts`, otherwise remains undefined and is
+                // omitted from the summary line entirely. See
+                // HMR_CORE_REALM_DETERMINISTIC_PLAN.md ("Round-eight — surface
+                // narrowing decision").
+                narrowed: undefined,
+                emitted: false,
+            };
+            // alpha.62 follow-up — 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 { }
+            };
+            // Track 1.3: 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);
@@ -3739,6 +6200,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);
@@ -3757,12 +6219,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
@@ -3778,6 +6242,7 @@ export const piniaSymbol = p.piniaSymbol;
                 });
                 if (!(isHtml || isTs))
                     return;
+                updateMetrics.invalidated += angularHotUpdateRoots.length;
                 if (angularHotUpdateRoots.length) {
                     for (const mod of angularHotUpdateRoots) {
                         try {
@@ -3794,13 +6259,80 @@ export const piniaSymbol = p.piniaSymbol;
                     }
                 }
                 const angularTransitiveInvalidationRoots = (angularHotUpdateRoots.length ? angularHotUpdateRoots : ctx.modules);
-                if (shouldInvalidateAngularTransitiveImporters({ flavor: ACTIVE_STRATEGY.flavor, file })) {
+                // Round-six narrowing: 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
+                // pre-round-six "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,
+                });
+                // Round-eight diagnostic. We surface the narrowing decision on
+                // every `.ts` Angular hot update (HTML routes always invalidate
+                // transitively today and aren't subject to Round-Seven, 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
+                // pre-Round-Seven (broad) behavior.
+                if (isTs) {
+                    updateMetrics.narrowed = !angularNeedsTransitive;
+                }
+                // alpha.59 — 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`. Pre-alpha.59 code computed
+                // this list twice in adjacent try blocks; consolidating it
+                // 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).
+                //
+                // alpha.59.1 — 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);
@@ -3815,24 +6347,40 @@ 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') {
+                        // Round-eight: was previously gated on `verbose`. Surfacing this
+                        // log unconditionally lets the user immediately confirm whether
+                        // Round-Seven's 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`).
+                        //
+                        // alpha.59.1 — narrowing now means "skip Vite re-transform"
+                        // (the importers still get evicted from the V8 module
+                        // registry so live bindings refresh). The log call-out is
+                        // preserved but extended with the importer count to make the
+                        // distinction 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,
-                        })
-                        : [];
+                    // alpha.59.1 — 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) {
@@ -3846,17 +6394,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();
+                    // alpha.59 — 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`. Pre-alpha.59 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) => ({
@@ -3868,12 +6473,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 [];
                 }
@@ -3881,6 +6488,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)
@@ -3894,6 +6502,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.
@@ -3907,6 +6516,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)
@@ -3931,6 +6541,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
@@ -4216,6 +6827,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 [];
         },