create-octane-xplat 0.6.0 → 0.7.0

package/template/patches/@nativescript__vite@8.0.11.patch

@@ -1,294 +1,564 @@
-diff --git a/hmr/server/core-bundle.js b/hmr/server/core-bundle.js
-index 993097b9d861a2a7c477f4e664213efec3eb6293..7a9b95180cbd47e1d9c71180bc4582a450333a7c 100644
---- a/hmr/server/core-bundle.js
-+++ b/hmr/server/core-bundle.js
-@@ -607,17 +607,32 @@ export function buildCoreMainShimCode() {
-  * class/function values. `exportNames` comes from the same disk-based export
-  * discovery the per-module bridge relies on (collectStaticExportNamesFromFile).
-  */
--const RESERVED_EXPORT_NAMES = new Set(['default', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'let', 'static', 'yield', 'await', 'eval', 'arguments', '__ns_core_sub_ns__']);
-+// `default` is emitted separately (below); `__ns_core_sub_ns__` is this shim's
-+// own local — a module exporting that name can't collide with it.
-+const NON_DECLARABLE_EXPORT_NAMES = new Set(['default', '__ns_core_sub_ns__']);
-+// Reserved words can't be declaration bindings (`export const enum` is a
-+// syntax error), but they ARE legal export names — the specifier position in
-+// `export { x as name }` accepts any IdentifierName. Emit those through a
-+// temp + alias so a reserved-word export (zod's `enum`/`catch`/… shapes this
-+// same code path) still reaches the bridged namespace.
-+const RESERVED_EXPORT_NAMES = new Set(['break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'let', 'static', 'yield', 'await', 'eval', 'arguments']);
- export function buildCoreSubShimCode(sub, exportNames, hasOwnDefaultExport = false) {
-     const canonical = normalizeCoreSub(sub);
-     const registryKey = `@nativescript/core/${canonical}`;
--    const names = Array.from(new Set(exportNames)).filter((n) => /^[A-Za-z_$][\w$]*$/.test(n) && !RESERVED_EXPORT_NAMES.has(n));
-+    const names = Array.from(new Set(exportNames)).filter((n) => /^[A-Za-z_$][\w$]*$/.test(n) && !NON_DECLARABLE_EXPORT_NAMES.has(n));
-     const lines = [];
-     lines.push(`/* @nativescript/core bridge (bundle mode) — sub: ${canonical} */`);
-     lines.push(`import ${JSON.stringify(CORE_BUNDLE_PATH)};`);
-     lines.push(`const __ns_core_sub_ns__ = (globalThis.__NS_CORE_MODULES__ || {})[${JSON.stringify(registryKey)}];`);
-     lines.push(`if (!__ns_core_sub_ns__) { throw new Error(${JSON.stringify(`[ns-core] core bundle registry missing '${registryKey}' — restart the dev server or set NS_CORE_PER_MODULE=1`)}); }`);
-+    let aliasIdx = 0;
-     for (const name of names) {
-+        if (RESERVED_EXPORT_NAMES.has(name)) {
-+            const alias = `__ns_core_alias_${aliasIdx++}`;
-+            lines.push(`const ${alias} = __ns_core_sub_ns__[${JSON.stringify(name)}];`);
-+            lines.push(`export { ${alias} as ${name} };`);
-+            continue;
-+        }
-         lines.push(`export const ${name} = __ns_core_sub_ns__.${name};`);
-     }
-     // Deep-subpath contract (see isDeepCoreSubpath / per-module bridge): a sub
 diff --git a/hmr/server/deps-bundle.js b/hmr/server/deps-bundle.js
-index 50e5abddddf80b35044d45eb108a64dd175bf6e7..799c7257a8a730515633f19f6221ad26ff8678eb 100644
+index 50e5abddddf80b35044d45eb108a64dd175bf6e7..4f16f129b4c4271173169871f42645d16d3cfa0c 100644
 --- a/hmr/server/deps-bundle.js
 +++ b/hmr/server/deps-bundle.js
-@@ -219,8 +219,37 @@ function isPackageRootSpec(spec) {
-         return false;
-     return pkgSub.split('/').length === (pkgSub.startsWith('@') ? 2 : 1);
+@@ -53,6 +53,7 @@
+ import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+ import * as path from 'node:path';
+ import { createHash } from 'node:crypto';
++import { createRequire } from 'node:module';
+ import * as esbuild from 'esbuild';
+ import { resolvePlatform } from '../../helpers/cli-flags.js';
+ import { getGlobalDefines, getUserDefineEntries } from '../../helpers/global-defines.js';
+@@ -669,6 +670,29 @@ export async function generateDepsBundle(options) {
+     // the device cannot resolve.
+     const buildPlugins = () => [
+         createWebpackLoaderStubEsbuildPlugin(),
++        // Bare `octane` is the DOM entry — a dep importing it (published
++        // @octane-xplat/* dist files kept `from "octane"` through 0.6.0)
++        // bundles a second runtime next to the universal one, and hooks read
++        // an empty CURRENT_SCOPE ("Cannot read properties of null (reading
++        // 'hooks')"). Vite resolve.alias never reaches these esbuild passes;
++        // route exact `octane` imports to the host-neutral entry here.
++        {
++            name: 'ns-deps-bundle-octane-universal-alias',
++            setup(build) {
++                build.onResolve({ filter: /^octane$/ }, (args) => {
++                    for (const dir of [args.importer && path.dirname(args.importer), args.resolveDir, projectRoot]) {
++                        if (!dir)
++                            continue;
++                        try {
++                            return { path: createRequire(path.join(dir, 'noop.js')).resolve('octane/universal/native') };
++                        }
++                        catch {
++                        }
++                    }
++                    return null;
++                });
++            },
++        },
+         createNodeBuiltinPolyfillEsbuildPlugin(projectRoot, NODE_BUILTINS),
+         createNativeClassEsbuildPlugin(platform),
+         createVendorEsbuildPlugin(projectRoot),
+diff --git a/helpers/ts-config-paths.js b/helpers/ts-config-paths.js
+index 27013b5c8f78a72b6e6df903ac36f72fc0d75c1a..53a2e7d489ab91593cbec47ee6fb640fc56c786f 100644
+--- a/helpers/ts-config-paths.js
++++ b/helpers/ts-config-paths.js
+@@ -113,15 +113,20 @@ function resolveTsConfigPath(fullPath, platform, verbose, debugId) {
+     if (verbose && debugId) {
+         console.log(`📁 TypeScript path candidate: ${debugId} -> ${fullPath}`);
+     }
++    // `.mobile` is the shared ios/android suffix tier — it sits between the os
++    // qualifier and the unsuffixed default. Probing it per extension keeps
++    // paths-mapped imports consistent with the bundler's extension chain.
++    const suffixes = platform === 'ios' || platform === 'android' ? [platform, 'mobile'] : platform ? [platform] : [];
+     if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+-        const platformIndexPatterns = [`index.${platform}.ts`, `index.${platform}.js`, `index.${platform}.mjs`];
+-        for (const indexFile of platformIndexPatterns) {
+-            const indexPath = path.join(fullPath, indexFile);
+-            if (fs.existsSync(indexPath)) {
+-                if (verbose) {
+-                    console.log(`📁 Found platform-specific directory index: ${indexPath}`);
++        for (const suffix of suffixes) {
++            for (const ext of ['.ts', '.js', '.mjs']) {
++                const indexPath = path.join(fullPath, `index.${suffix}${ext}`);
++                if (fs.existsSync(indexPath)) {
++                    if (verbose) {
++                        console.log(`📁 Found platform-specific directory index: ${indexPath}`);
++                    }
++                    return indexPath;
+                 }
+-                return indexPath;
+             }
+         }
+         for (const indexFile of ['index.ts', 'index.js', 'index.mjs']) {
+@@ -135,12 +140,14 @@ function resolveTsConfigPath(fullPath, platform, verbose, debugId) {
+         }
+     }
+     for (const ext of ['.ts', '.js', '.mjs']) {
+-        const platformPath = `${fullPath}.${platform}${ext}`;
+-        if (fs.existsSync(platformPath)) {
+-            if (verbose) {
+-                console.log(`📁 Found platform-specific file: ${platformPath}`);
++        for (const suffix of suffixes) {
++            const platformPath = `${fullPath}.${suffix}${ext}`;
++            if (fs.existsSync(platformPath)) {
++                if (verbose) {
++                    console.log(`📁 Found platform-specific file: ${platformPath}`);
++                }
++                return platformPath;
+             }
+-            return platformPath;
+         }
+         const basePath = `${fullPath}${ext}`;
+         if (fs.existsSync(basePath)) {
+diff --git a/hmr/server/device-transform-helpers.js b/hmr/server/device-transform-helpers.js
+index 9364ce9942b84fffd0e3a6eb6700d8253fa66e7e..0ae5a89f0359afc3c700b43b2c80b176536100a6 100644
+--- a/hmr/server/device-transform-helpers.js
++++ b/hmr/server/device-transform-helpers.js
+@@ -89,7 +89,11 @@ function bareSpecifierFromFlatDepPath(depPath) {
+     return bareSpecifier;
  }
--function resolveSpecToFile(spec, projectRoot, workspaceRoot, platform) {
+ function rewriteVitePrebundleImportsForDevice(code, preserveVendorImports) {
+-    const imports = collectTopLevelImportRecords(code);
++    // Re-export statements (`export { x } from`/`export * from`) carry specifiers
++    // too — vite's importAnalysis rewrites them to `.vite/deps?v=` URLs the same
++    // as `import` declarations, so they need the same decode. Barrel modules
++    // (e.g. a linked framework package's index) are nothing but re-exports.
++    const imports = collectTopLevelImportRecords(code, true);
+     if (!imports.length) {
+         return code;
+     }
+diff --git a/hmr/server/rewrite-imports.js b/hmr/server/rewrite-imports.js
+index 4a6575cb00a6aeecbbb7ac5ccac3268cb10d7f54..dc70055007e26117b76fbb9d2f4f17fabfd8db00 100644
+--- a/hmr/server/rewrite-imports.js
++++ b/hmr/server/rewrite-imports.js
+@@ -253,11 +253,29 @@ export function rewriteImports(code, importerPath, sfcFileMap, depFileMap, proje
+                 }
+                 return `${prefix}${rewritten}${suffix}`;
+             }
+-            // Path resolves outside both roots — leave Vite's URL alone as a
+-            // last resort. The original behaviour was to fall through here
+-            // and let downstream branches (e.g. `normalizeNodeModulesSpecifier`)
+-            // handle paths whose abs form happens to contain `/node_modules/`,
+-            // so preserve that for the unrewritable case below.
++            // Path resolves outside both roots — the `link:`/`workspace:` case,
++            // where a package's realpath lives in another checkout entirely.
++            // A raw /@fs URL makes the device fetch vite's standard middleware
++            // response, bypassing the device transform: optimizer
++            // `.vite/deps?v=` specifiers inside reach the runtime unrewritten
++            // and 504 once the optimizer re-commits its browserHash. The /ns/m
++            // route already resolves an absolute `/@fs` spec through the full
++            // device pipeline, so route it there. Paths whose realpath still
++            // contains /node_modules/ keep falling through to the bare-package
++            // branch below (upstream behavior).
++            if (!spec.includes('/node_modules/')) {
++                const out = `/ns/m${spec}`;
++                if (httpOriginSafe) {
++                    return `${prefix}${httpOriginSafe}${out}${suffix}`;
++                }
++                return `${prefix}${out}${suffix}`;
++            }
++            // Path resolves outside both roots but still names a node_modules
++            // file — leave Vite's URL alone as a last resort. The original
++            // behaviour was to fall through here and let downstream branches
++            // (e.g. `normalizeNodeModulesSpecifier`) handle paths whose abs
++            // form happens to contain `/node_modules/`, so preserve that for
++            // the unrewritable case below.
+         }
+         // Vite 8 oxc runtime helpers (decorators etc.) — emitted as
+         // `/@id/__x00__@oxc-project+runtime@<ver>/helpers/<name>.js`. These are
+diff --git a/hmr/server/websocket-core-bridge.js b/hmr/server/websocket-core-bridge.js
+index 444ea4474645a10ce4f9ca3b81d96ec9c017c0cb..caa3724caeeb04b4d69d04a15a5899f835fec5ff 100644
+--- a/hmr/server/websocket-core-bridge.js
++++ b/hmr/server/websocket-core-bridge.js
+@@ -8,7 +8,76 @@ import { getGlobalScope } from '../shared/runtime/global-scope.js';
+  * an ASCII filter silently drops every such export from generated shims.
+  */
+ export const JS_IDENTIFIER_RE = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
 +/**
-+ * `/node_modules/<pkg>/<sub...>` → the exports-mapped file on disk
-+ * (`rouzer/http` → `rouzer/dist/http.js`). Without this, non-root specs fall
-+ * back to `resolveId` and land on Vite's dep-optimizer artifacts under
-+ * `.vite/deps/` — flat bundles whose generated shared chunks
-+ * (`foo-<hash>.js`) this pipeline cannot serve to the device.
++ * Blank out `//` and `/* ... *\/` comment bodies (positions and length
++ * preserved — every matched index stays valid). Export-name scanners are
++ * regex-based, so a commented-out declaration like ui-image's
++ * `// export const roundRadiusProperty = ...` would otherwise register a
++ * phantom export and the emitted explicit re-export list then fails to link
++ * on device ("does not provide an export named ...").
++ *
++ * Strings and template literals are skipped so `//` inside quotes isn't
++ * treated as a comment start. Regex literals are intentionally not tracked —
++ * an unescaped `//` inside one (e.g. `[//]` char classes) still masks the
++ * rest of the line; that is rare enough to accept in a dev-server path.
 + */
-+function resolvePackageSubpathFromSpecRoots(spec, roots, platform) {
-+    const pkgSub = spec.replace(/^\/node_modules\//, '');
-+    const parts = pkgSub.split('/');
-+    const nameSegs = parts[0].startsWith('@') ? 2 : 1;
-+    if (parts.length <= nameSegs)
-+        return null;
-+    const subpath = parts.slice(nameSegs).join('/');
-+    for (const root of roots) {
-+        const pkgDir = path.join(root, 'node_modules', ...parts.slice(0, nameSegs));
-+        if (!existsSync(path.join(pkgDir, 'package.json')))
-+            continue;
-+        const resolved = resolvePackageSubpathEntry(pkgDir, subpath, platform);
-+        if (resolved)
-+            return resolved;
++export function maskJsComments(code) {
++    if (!code || (code.indexOf('//') === -1 && code.indexOf('/*') === -1)) {
++        return code;
++    }
++    const chars = code.split('');
++    const n = code.length;
++    let i = 0;
++    while (i < n) {
++        const c = code[i];
++        const next = code[i + 1];
++        if (c === '/' && next === '/') {
++            chars[i] = ' ';
++            chars[i + 1] = ' ';
++            i += 2;
++            while (i < n && code[i] !== '\n') {
++                chars[i] = ' ';
++                i++;
++            }
++        }
++        else if (c === '/' && next === '*') {
++            chars[i] = ' ';
++            chars[i + 1] = ' ';
++            i += 2;
++            while (i < n && !(code[i] === '*' && code[i + 1] === '/')) {
++                if (code[i] !== '\n')
++                    chars[i] = ' ';
++                i++;
++            }
++            if (i < n) {
++                chars[i] = ' ';
++                chars[i + 1] = ' ';
++                i += 2;
++            }
++        }
++        else if (c === "'" || c === '"' || c === '`') {
++            const quote = c;
++            i++;
++            while (i < n) {
++                if (code[i] === '\\') {
++                    i += 2;
++                    continue;
++                }
++                if (code[i] === quote) {
++                    i++;
++                    break;
++                }
++                i++;
++            }
++        }
++        else {
++            i++;
++        }
 +    }
-+    return null;
++    return chars.join('');
 +}
-+export function resolveSpecToFile(spec, projectRoot, workspaceRoot, platform) {
-     const roots = [projectRoot, ...(workspaceRoot && path.resolve(workspaceRoot) !== path.resolve(projectRoot) ? [workspaceRoot] : [])];
-+    // `.vite/` is Vite's dep-optimizer store — generated artifacts with
-+    // content-hashed names, not package files. Resolving them here would mint
-+    // deps-bundle entries/shims for files whose names churn per optimization.
-+    if (spec.includes('/.vite/'))
-+        return null;
-     // Package roots honor the declared entry (exports/module/main) FIRST —
-     // matching esbuild's resolution of bare imports inside the bundle. The
-     // index fan-out would otherwise pick stray root files like a shipped
-@@ -236,6 +265,12 @@ function resolveSpecToFile(spec, projectRoot, workspaceRoot, platform) {
-         if (abs)
-             return abs;
-     }
-+    // Non-root specs (`rouzer/http`, `qubu/sqlite`): consult the package's
-+    // exports map so the real dist file wins — the alternative downstream is
-+    // the dep optimizer's `.vite/deps` artifact, whose sibling chunks 404.
-+    const subpathEntry = resolvePackageSubpathFromSpecRoots(spec, roots, platform);
-+    if (subpathEntry)
-+        return subpathEntry;
-     return isPackageRootSpec(spec) ? null : resolvePackageRootEntry(spec, roots, platform);
- }
- // Never bundled: `@nativescript/core` belongs to the /ns/core bridge realm,
-@@ -869,7 +904,15 @@ export function collectDepsModuleExportInfo(absPath, platform, seen = new Set())
-     names.delete('default');
-     return { names: Array.from(names).sort(), hasDefault: hasExistingDefaultExport(code) };
- }
--const RESERVED_EXPORT_NAMES = new Set(['default', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'let', 'static', 'yield', 'await', 'eval', 'arguments', '__ns_dep_ns__']);
-+// `default` is emitted separately (below); `__ns_dep_ns__` is this shim's own
-+// local — a package exporting that name can't collide with it.
-+const NON_DECLARABLE_EXPORT_NAMES = new Set(['default', '__ns_dep_ns__']);
-+// Reserved words can't be declaration bindings (`export const enum` is a
-+// syntax error), but they ARE legal export names — the specifier position in
-+// `export { x as name }` accepts any IdentifierName. Emit those through a
-+// temp + alias so packages like zod (`enum`, `catch`, `function`, …) keep
-+// their full surface on the bridged namespace.
-+const RESERVED_EXPORT_NAMES = new Set(['break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'let', 'static', 'yield', 'await', 'eval', 'arguments']);
- /**
-  * Shim served at `/ns/m/node_modules/...` for a bundled module. The static
-  * bundle import guarantees the registry is populated before the body reads it
-@@ -880,13 +923,20 @@ const RESERVED_EXPORT_NAMES = new Set(['default', 'break', 'case', 'catch', 'cla
- export function buildDepsShimCode(key, exportNames, hasOwnDefaultExport) {
-     // JS_IDENTIFIER_RE (not ASCII \w): Angular exports `ɵɵdefineInjectable`-style
-     // names — dropping them here breaks every `import * as i0` consumer.
--    const names = Array.from(new Set(exportNames)).filter((n) => JS_IDENTIFIER_RE.test(n) && !RESERVED_EXPORT_NAMES.has(n));
-+    const names = Array.from(new Set(exportNames)).filter((n) => JS_IDENTIFIER_RE.test(n) && !NON_DECLARABLE_EXPORT_NAMES.has(n));
-     const lines = [];
-     lines.push(`/* ns-deps bridge (bundle mode) — ${key} */`);
-     lines.push(`import ${JSON.stringify(DEPS_BUNDLE_PATH)};`);
-     lines.push(`const __ns_dep_ns__ = (globalThis.__NS_DEPS_MODULES__ || {})[${JSON.stringify(key)}];`);
-     lines.push(`if (!__ns_dep_ns__) { throw new Error(${JSON.stringify(`[ns-deps] deps bundle registry missing '${key}' — restart the dev server or set NS_DEPS_PER_MODULE=1`)}); }`);
-+    let aliasIdx = 0;
-     for (const name of names) {
-+        if (RESERVED_EXPORT_NAMES.has(name)) {
-+            const alias = `__ns_dep_alias_${aliasIdx++}`;
-+            lines.push(`const ${alias} = __ns_dep_ns__[${JSON.stringify(name)}];`);
-+            lines.push(`export { ${alias} as ${name} };`);
+ export function extractDirectExportedNames(code) {
++    code = maskJsComments(code);
+     const names = new Set();
+     const declRe = /\bexport\s+(?:async\s+)?(?:function|class)\s+([$_\p{ID_Start}][$\p{ID_Continue}]*)/gu;
+     let match;
+diff --git a/hmr/server/websocket-module-bindings.js b/hmr/server/websocket-module-bindings.js
+index 54b8fba2def7ed0128e8e1dd4b2549d25559de82..fd276ae860d0805533be0bff4399247b38ebac01 100644
+--- a/hmr/server/websocket-module-bindings.js
++++ b/hmr/server/websocket-module-bindings.js
+@@ -7,6 +7,7 @@ import { getProjectRootPath } from '../../helpers/project.js';
+ import { extractRootPackageName } from '../shared/package-classifier.js';
+ import { isEsmFrameworkPackageSpecifier, isLikelyNativeScriptPluginSpecifier, isLikelyNativeScriptRuntimePluginSpecifier, normalizeNodeModulesSpecifier, resolveInternalRuntimePluginBareSpecifier, resolveNodeModulesPackageBoundary, resolveVendorFromCandidate, shouldPreserveBareRuntimePluginSubpathImport } from './websocket-module-specifiers.js';
+ import { MODULE_IMPORT_ANALYSIS_PLUGINS } from './websocket-served-module-helpers.js';
++import { getVendorManifest, resolveVendorSpecifier } from '../shared/vendor/registry.js';
+ const sourceImportIntentCache = new Map();
+ const EXPLICIT_RUNTIME_PLUGIN_SCRIPT_EXT_RE = /(?:\.(?:ios|android|visionos))?\.(?:ts|tsx|js|jsx|mjs|mts|cts)$/i;
+ function hasExplicitRuntimePluginScriptExtension(segment) {
+@@ -109,6 +110,9 @@ export function ensureNativeScriptModuleBindings(code, options) {
+             }
+             const runtimePluginBareSpecifier = resolveInternalRuntimePluginBareSpecifier(specifier, getProjectRootPath());
+             let canonical = runtimePluginBareSpecifier || resolveVendorFromCandidate(specifier);
++            if (canonical && getVendorManifest() && !resolveVendorSpecifier(canonical)) {
++                canonical = null;
++            }
+             const runtimePluginSpecifier = isLikelyNativeScriptRuntimePluginSpecifier(canonical || specifier, getProjectRootPath());
+             // Preserving a bare vendor id is only correct where the IMPORT MAP
+             // exists to route it (main realm). Worker realms have no import map —
+@@ -120,7 +124,7 @@ export function ensureNativeScriptModuleBindings(code, options) {
+                 preservedImports.push(original);
+                 continue;
+             }
+-            if (!canonical && isLikelyNativeScriptPluginSpecifier(specifier, getProjectRootPath())) {
++            if (!canonical && isLikelyNativeScriptPluginSpecifier(specifier, getProjectRootPath()) && (!getVendorManifest() || resolveVendorSpecifier(specifier))) {
+                 canonical = specifier;
+             }
+             if (canonical && /^@nativescript\/core(\b|\/)/i.test(canonical)) {
+@@ -163,6 +167,9 @@ export function ensureNativeScriptModuleBindings(code, options) {
+         }
+         const runtimePluginBareSpecifier = resolveInternalRuntimePluginBareSpecifier(specifier, getProjectRootPath());
+         let canonical = runtimePluginBareSpecifier || resolveVendorFromCandidate(specifier);
++        if (canonical && getVendorManifest() && !resolveVendorSpecifier(canonical)) {
++            canonical = null;
++        }
+         const runtimePluginSpecifier = isLikelyNativeScriptRuntimePluginSpecifier(canonical || specifier, getProjectRootPath());
+         // See the side-effect branch above: bare preservation relies on the main
+         // realm's import map; in a worker serve (vendorImportsAsHttp) it must not
+@@ -171,7 +178,7 @@ export function ensureNativeScriptModuleBindings(code, options) {
+             preservedImports.push(original);
+             continue;
+         }
+-        if (!canonical && isLikelyNativeScriptPluginSpecifier(specifier, getProjectRootPath())) {
++        if (!canonical && isLikelyNativeScriptPluginSpecifier(specifier, getProjectRootPath()) && (!getVendorManifest() || resolveVendorSpecifier(specifier))) {
+             canonical = specifier;
+         }
+         if (canonical && /^@nativescript\/core(\b|\/)/i.test(canonical)) {
+diff --git a/hmr/server/websocket-module-specifiers.js b/hmr/server/websocket-module-specifiers.js
+index 2f1dd5d5d688076c5fc0ec8c5c888f9e834e7831..68cdd051144c1d69d8d20271558c8f8e79532d73 100644
+--- a/hmr/server/websocket-module-specifiers.js
++++ b/hmr/server/websocket-module-specifiers.js
+@@ -1,4 +1,4 @@
+-import { existsSync, readFileSync, realpathSync } from 'fs';
++import { existsSync, readdirSync, readFileSync, realpathSync } from 'fs';
+ import * as path from 'path';
+ import * as PAT from './constants.js';
+ import { getVendorManifest, resolveVendorSpecifier } from '../shared/vendor/registry.js';
+@@ -331,6 +331,68 @@ export function resolveVendorFromCandidate(specifier) {
+  * request to the dev server's bridge fails with a "transform miss"
+  * 404 even though the file is right there at the workspace root.
+  */
++const workspacePackageNodeModulesDirsCache = new Map();
++/**
++ * Enumerate `node_modules` directories that belong to workspace packages
++ * (e.g. `<root>/packages/<pkg>/node_modules`, `<root>/apps/<app>/node_modules`)
++ * plus the workspace root's own. pnpm's isolated linker gives each workspace
++ * package a private `node_modules` — a dependency declared by a workspace
++ * package (say a NativeScript plugin inside a library) is invisible from the
++ * app root, so `/ns/m/node_modules/<pkg>/...` requests for transitive deps 404
++ * without this fallback.
++ *
++ * Bounded: direct children of the root plus one level down
++ * (`<root>/<group>/<pkg>/node_modules`) covers standard workspace layouts
++ * without walking arbitrary depth. Cached for the dev-server lifetime.
++ */
++function enumerateWorkspacePackageNodeModulesDirs(workspaceRoot) {
++    const resolved = path.resolve(workspaceRoot);
++    const cached = workspacePackageNodeModulesDirsCache.get(resolved);
++    if (cached) {
++        return cached;
++    }
++    const dirs = [];
++    const pushIfPresent = (dir) => {
++        const nm = path.join(dir, 'node_modules');
++        try {
++            if (existsSync(nm)) {
++                dirs.push(nm);
++            }
++        }
++        catch {
++            // unreadable dirs are skipped — this is a best-effort fallback
++        }
++    };
++    pushIfPresent(resolved);
++    let groups = [];
++    try {
++        groups = readdirSync(resolved, { withFileTypes: true });
++    }
++    catch {
++        groups = [];
++    }
++    for (const group of groups) {
++        if (!group.isDirectory() || group.name === 'node_modules' || group.name.startsWith('.')) {
 +            continue;
 +        }
-         lines.push(`export const ${name} = __ns_dep_ns__.${name};`);
-     }
-     if (hasOwnDefaultExport) {
-diff --git a/hmr/server/device-transform-helpers.js b/hmr/server/device-transform-helpers.js
-index 9364ce9942b84fffd0e3a6eb6700d8253fa66e7e..93ee2bf2570303277d7b4350018b00fbbb31e2a4 100644
---- a/hmr/server/device-transform-helpers.js
-+++ b/hmr/server/device-transform-helpers.js
-@@ -81,12 +81,18 @@ function bareSpecifierFromFlatDepPath(depPath) {
++        const groupDir = path.join(resolved, group.name);
++        pushIfPresent(groupDir);
++        let packages = [];
++        try {
++            packages = readdirSync(groupDir, { withFileTypes: true });
++        }
++        catch {
++            packages = [];
++        }
++        for (const pkg of packages) {
++            if (pkg.isDirectory() && !pkg.name.startsWith('.')) {
++                pushIfPresent(path.join(groupDir, pkg.name));
++            }
++        }
++    }
++    workspacePackageNodeModulesDirsCache.set(resolved, dirs);
++    return dirs;
++}
+ export function resolveCandidateFilePath(candidate, projectRoot, workspaceRoot) {
+     const cleaned = candidate.replace(PAT.QUERY_PATTERN, '');
+     if (!cleaned)
+@@ -363,7 +425,24 @@ export function resolveCandidateFilePath(candidate, projectRoot, workspaceRoot)
+         const resolvedProject = path.resolve(projectRoot);
+         const resolvedWorkspace = path.resolve(workspaceRoot);
+         if (resolvedWorkspace !== resolvedProject) {
+-            return tryUnderRoot(resolvedWorkspace);
++            const fromWorkspace = tryUnderRoot(resolvedWorkspace);
++            if (fromWorkspace) {
++                return fromWorkspace;
++            }
++        }
++        // Transitive-dep fallback: the `/ns/m/node_modules/<pkg>/<sub>` URL
++        // form drops the importer, so a package that only exists under a
++        // workspace package's private node_modules (pnpm isolated linker)
++        // can't be anchored to a root. Probe every workspace package's
++        // node_modules for `<pkg>/<sub>` and serve the first hit.
++        if (cleaned.includes('/node_modules/')) {
++            const afterNodeModules = cleaned.slice(cleaned.lastIndexOf('/node_modules/') + '/node_modules/'.length);
++            for (const nmDir of enumerateWorkspacePackageNodeModulesDirs(resolvedWorkspace)) {
++                const absPath = path.join(nmDir, afterNodeModules);
++                if (existsSync(absPath)) {
++                    return absPath;
++                }
++            }
          }
-         catch { }
      }
--    const bareSpecifier = resolved || candidates[0];
-+    // Unverified decode → NOT a package: `depPath` is a generated optimizer
-+    // artifact (a hash-named shared chunk like `http-Dm_BQhab.js`, whose
-+    // base64url '_' decodes to a bogus '/'). Returning null lets the caller
-+    // keep the real `.vite/deps` URL instead of emitting a garbage specifier.
-+    if (!resolved) {
-+        return null;
-+    }
-     if (!warnedVendorMisses.has(depPath)) {
-         warnedVendorMisses.add(depPath);
--        console.warn(`[ns-vite] vendor-manifest miss: prebundled dep '${depPath}' is not in the vendor bundle — serving '${bareSpecifier}' over HTTP via /ns/m/node_modules/${resolved ? '' : ' (could not verify the package on disk; the specifier is a best-effort decode of the flattened id)'}.`);
-+        console.warn(`[ns-vite] vendor-manifest miss: prebundled dep '${depPath}' is not in the vendor bundle — serving '${resolved}' over HTTP via /ns/m/node_modules/${resolved}.`);
+     return null;
+@@ -794,16 +873,24 @@ export function resolveVendorRouting(nodeModulesSpec, projectRoot) {
+     if (rootPackageName && pkgName !== rootPackageName) {
+         return { route: 'http' };
      }
--    return bareSpecifier;
-+    return resolved;
- }
- function rewriteVitePrebundleImportsForDevice(code, preserveVendorImports) {
-     const imports = collectTopLevelImportRecords(code);
-@@ -111,6 +117,15 @@ function rewriteVitePrebundleImportsForDevice(code, preserveVendorImports) {
-             if (bareSpecifier) {
-                 replacement = imp.text.replace(source, bareSpecifier);
-             }
-+            else {
-+                // Generated optimizer chunk (hash-named sibling of an
-+                // optimized entry) — not a package and not decodable to one.
-+                // Route the real artifact URL back through the bridge: the
-+                // /ns/m route serves it from the dep-optimizer store (the
-+                // `?v` stamp rides along as forcedVer) or emits an
-+                // actionable optimizeDeps.exclude error.
-+                replacement = imp.text.replace(source, `/ns/m/node_modules/.vite/deps/${depPath}`);
-+            }
+-    if (isLikelyNativeScriptRuntimePluginSpecifier(pkgName, projectRoot) && (!subpath || isRootLevelMainEntry)) {
++    // A plugin-patterned package absent from an active vendor manifest (a
++    // transitive dep under pnpm's isolated linker, an NS_VENDOR_EXCLUDE/
++    // flavor-excluded package) must not take the vendor route — the registry
++    // has no entry and the sync require resolves to the missing-module stub.
++    // Fall through to null so callers emit the per-module /ns/m HTTP form,
++    // which resolves transitive deps through Vite's importer-aware resolution.
++    // A null manifest (early boot) keeps the legacy behavior.
++    const manifest = getVendorManifest();
++    const pluginVendored = !manifest || !!manifest.modules?.[pkgName];
++    if (isLikelyNativeScriptRuntimePluginSpecifier(pkgName, projectRoot) && pluginVendored && (!subpath || isRootLevelMainEntry)) {
+         return { route: 'vendor', bareSpec: pkgName };
+     }
+-    if (isLikelyNativeScriptRuntimePluginSpecifier(pkgName, projectRoot) && subpath.includes('/')) {
++    if (isLikelyNativeScriptRuntimePluginSpecifier(pkgName, projectRoot) && pluginVendored && subpath.includes('/')) {
+         const exactBareSpecifier = resolveInternalRuntimePluginBareSpecifier(nodeModulesSpec, projectRoot);
+         if (exactBareSpecifier) {
+             return { route: 'vendor', bareSpec: exactBareSpecifier };
          }
-         edits.push({
-             start: imp.start,
+     }
+-    const manifest = getVendorManifest();
+     if (!manifest?.modules?.[pkgName]) {
+         return null;
+     }
 diff --git a/hmr/server/websocket-ns-m-request.js b/hmr/server/websocket-ns-m-request.js
-index b54aefcc839e95906d76d02e522c052a706ca76f..d49159de94ba05dcfc372aa7a3c513e0f5c0a0d3 100644
+index b54aefcc839e95906d76d02e522c052a706ca76f..a9c38c32b8752765044cd8f2c1eac558a30052dd 100644
 --- a/hmr/server/websocket-ns-m-request.js
 +++ b/hmr/server/websocket-ns-m-request.js
-@@ -1,6 +1,9 @@
+@@ -1,6 +1,41 @@
  import * as path from 'path';
-+import { realpathSync } from 'fs';
  import { filterExistingNodeModulesTransformCandidates, getBlockedDeviceNodeModulesReason, resolveCandidateFilePath, tryReadRawExplicitJavaScriptModule } from './websocket-module-specifiers.js';
  import { collapseLegacyNsMTags } from './websocket-ns-m-paths.js';
-+import { resolveSpecToFile } from './deps-bundle.js';
 +import { resolvePlatform } from '../../helpers/cli-flags.js';
- function normalizeAbsoluteFilesystemSpec(spec, serverRoot) {
-     const toPosix = (value) => value.replace(/\\/g, '/');
-     const rootPosix = toPosix(serverRoot);
-@@ -93,6 +96,29 @@ export function createNsMRequestContext(requestUrl, serverRoot, appVirtualWithSl
-         return { kind: 'next' };
-     }
- }
++let cachedPlatformSuffixes = undefined;
 +/**
-+ * Canonical request URL for a resolved node_modules file. Project-root files
-+ * keep the `/node_modules/...` form so module identity matches the /ns/m
-+ * spec space; files outside the project root (hoisted/workspace) use the
-+ * `/@fs` form Vite can load directly. Symlinked workspace-source packages
-+ * resolve to their realpath so the TS transform applies — same policy as
-+ * filterExistingNodeModulesTransformCandidates.
++ * Platform-suffixed resolution tags (`ios`, `android`, `visionos`, plus the
++ * shared `native` tag used by split-entry packages). Packages shipped with
++ * platform-split entries — e.g. `@nativescript-community/*` plugins carrying
++ * `index.ios.js`/`index.android.js` and a `main` like `./index` — 404 on the
++ * device bridge when only unsuffixed candidates are probed. Candidates are
++ * existence-filtered later, so probing every suffix is safe; the active
++ * platform's variants go first so a package shipping several platforms picks
++ * the right one.
 + */
-+function nodeModulesFileToRequestUrl(absPath, serverRoot) {
-+    try {
-+        const real = realpathSync(absPath);
-+        if (real !== absPath && !real.split(path.sep).includes('node_modules')) {
-+            return `/@fs${real.replace(/\\/g, '/')}`;
-+        }
-+    }
-+    catch { }
-+    const rootPosix = path.resolve(serverRoot).replace(/\\/g, '/').replace(/\/+$/, '');
-+    const absPosix = absPath.replace(/\\/g, '/');
-+    if (absPosix.startsWith(`${rootPosix}/`)) {
-+        return absPosix.slice(rootPosix.length);
++function platformSuffixes() {
++    if (cachedPlatformSuffixes === undefined) {
++        const platform = resolvePlatform();
++        const list = [platform, 'ios', 'android', 'visionos', 'native'].filter(Boolean);
++        cachedPlatformSuffixes = [...new Set(list)];
 +    }
-+    return `/@fs${absPosix}`;
++    return cachedPlatformSuffixes;
 +}
- async function tryTransformRequest(transformRequest, url, timeoutMs) {
-     try {
-         return await transformRequest(url, timeoutMs);
-@@ -146,6 +172,38 @@ export async function resolveNsMTransformedModule(options) {
-             return { transformed, resolvedCandidate };
-         }
-     }
-+    // Optimizer-artifact requests (`/node_modules/.vite/deps/<file>`): flat
-+    // entries and hash-named shared chunks live in the dep-optimizer's store
-+    // (often memory-only), keyed by the `?v=<browserHash>` stamp Vite emits —
-+    // captured inbound as `forcedVer`. Replay it so Vite resolves the artifact
-+    // as-is; a miss falls through to the route's transform-miss branch, which
-+    // names optimizeDeps.exclude as the fix.
-+    if (spec.includes('/.vite/deps/')) {
-+        const depUrl = context.forcedVer ? `${spec}?v=${context.forcedVer}` : spec;
-+        transformed = await tryTransformRequest(transformRequest, depUrl, timeoutMs);
-+        if (transformed?.code) {
-+            return { transformed, resolvedCandidate: depUrl };
-+        }
-+        return { transformed: null, resolvedCandidate };
-+    }
-+    // Bare or subpath node_modules specs (`rouzer/http`, `qubu/sqlite`) that
-+    // survive the on-disk candidate fan-out would otherwise hit `resolveId`
-+    // and land on Vite's dep-optimizer output: `/node_modules/.vite/deps/
-+    // <flat>.js` bundles whose generated sibling chunks (`foo-<hash>.js`)
-+    // this pipeline cannot serve — and whose flattened ids decode to bogus
-+    // bare specifiers downstream (`http-Dm/BQhab`). Prefer the real package
-+    // file (exports-map aware) so the device gets the same per-module source
-+    // an `optimizeDeps.exclude` entry produces.
-+    if (spec.includes('/node_modules/')) {
-+        const realFile = resolveSpecToFile(spec.slice(spec.lastIndexOf('/node_modules/')), serverRoot, workspaceRoot, resolvePlatform() || 'ios');
-+        const realUrl = realFile ? nodeModulesFileToRequestUrl(realFile, serverRoot) : null;
-+        if (realUrl) {
-+            transformed = await tryTransformRequest(transformRequest, realUrl, timeoutMs);
-+            if (transformed?.code) {
-+                return { transformed, resolvedCandidate: realUrl };
++const CANDIDATE_EXTS = ['ts', 'tsx', 'js', 'jsx', 'mjs', 'mts', 'cts', 'vue'];
++function expandModuleCandidates(spec, hasExt, baseNoExt) {
++    const candidates = [...(hasExt ? [spec] : [])];
++    for (const base of [baseNoExt, `${baseNoExt}/index`]) {
++        for (const suffix of platformSuffixes()) {
++            for (const ext of CANDIDATE_EXTS) {
++                candidates.push(`${base}.${suffix}.${ext}`);
 +            }
 +        }
++        for (const ext of CANDIDATE_EXTS) {
++            candidates.push(`${base}.${ext}`);
++        }
 +    }
-     const resolvedId = await resolveId(spec);
-     if (resolvedId) {
-         transformed = await tryTransformRequest(transformRequest, resolvedId, timeoutMs);
++    return candidates;
++}
+ function normalizeAbsoluteFilesystemSpec(spec, serverRoot) {
+     const toPosix = (value) => value.replace(/\\/g, '/');
+     const rootPosix = toPosix(serverRoot);
+@@ -49,6 +84,14 @@ export function createNsMRequestContext(requestUrl, serverRoot, appVirtualWithSl
+             };
+         }
+         spec = spec.replace(/[?#].*$/, '');
++        // urlObj.pathname keeps percent-encoding — device fetches encode
++        // characters like `[`/`]` in file-based route names, so decode the
++        // spec before resolving it to a filesystem path. Malformed escapes
++        // keep the raw spelling rather than throwing.
++        try {
++            spec = decodeURIComponent(spec);
++        }
++        catch { }
+         const decorated = collapseLegacyNsMTags(spec, 'inbound-request-spec');
+         spec = decorated.cleanedSpec;
+         bootTaggedRequest = decorated.bootTaggedRequest;
+@@ -73,7 +116,7 @@ export function createNsMRequestContext(requestUrl, serverRoot, appVirtualWithSl
+         }
+         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 candidates = expandModuleCandidates(spec, hasExt, baseNoExt);
+         const transformCandidates = filterExistingNodeModulesTransformCandidates(spec, candidates, serverRoot, workspaceRoot);
+         return {
+             kind: 'context',
 diff --git a/hmr/server/websocket-ns-m.js b/hmr/server/websocket-ns-m.js
-index 8eeb51ab59497e7f775da3117c4207e05f1814c7..346b676fbb67ce6bebe81cc379fdbe0d0aeac876 100644
+index 8eeb51ab59497e7f775da3117c4207e05f1814c7..407c2a2484c843bc538ce6ef9cf7af0b9b883ad3 100644
 --- a/hmr/server/websocket-ns-m.js
 +++ b/hmr/server/websocket-ns-m.js
-@@ -265,6 +265,30 @@ export function registerNsModuleServerRoute(server, options) {
-             catch { }
-             // If transformRequest failed, handle bare-module vendor shims for 'vue' and 'pinia'
-             if (!transformed?.code) {
-+                // Dep-optimizer artifacts (`.vite/deps` entries + generated
-+                // shared chunks) aren't package files — when one reaches the
-+                // bridge unserved, the fix is keeping that dep out of
-+                // optimizeDeps. Name the optimized set so the on-device
-+                // error is actionable instead of a generic transform miss.
-+                if (spec.includes('/.vite/deps/')) {
-+                    const optimizedIds = [];
-+                    try {
-+                        for (const env of Object.values(server.environments || {})) {
-+                            const meta = env?.depsOptimizer?.metadata;
-+                            for (const record of [meta?.optimized, meta?.discovered]) {
-+                                if (record)
-+                                    optimizedIds.push(...Object.keys(record));
-+                            }
+@@ -6,6 +6,7 @@ import { isRuntimeGraphExcludedPath } from './runtime-graph-filter.js';
+ import { buildPiniaVendorShim, buildVueVendorShim } from './vendor-bare-module-shims.js';
+ import { collapseLegacyNsMTags } from './websocket-ns-m-paths.js';
+ import { createNsMRequestContext, resolveNsMTransformedModule } from './websocket-ns-m-request.js';
++import { resolveCandidateFilePath } from './websocket-module-specifiers.js';
+ import { setDeviceModuleHeaders } from './route-helpers.js';
+ import { CSS_MODULE_RE, buildCssRegisterSnippetFromVar, normalizeCssForDevice } from './css-device-module.js';
+ import { assertNoOptimizedArtifacts, buildBootProgressSnippet, canonicalizeRtImports, dedupeRtNamedImportsAgainstDestructures, deduplicateLinkerImports, ensureDestructureCoreImports, ensureGuardPlainDynamicImports, ensureVariableDynamicImportHelper, expandStarExports, hoistTopLevelStaticImports, MODULE_IMPORT_ANALYSIS_PLUGINS, wrapCommonJsModuleForDevice, ensureWorkerEntryGlobalsImport, classifyServedRequest } from './websocket-served-module-helpers.js';
+@@ -154,7 +155,22 @@ export function registerNsModuleServerRoute(server, options) {
+             // string for `import css from './x.css'`. `app.css` has its own path.
+             if (CSS_MODULE_RE.test(spec)) {
+                 try {
+-                    const inlineRes = await sharedTransformRequest(`${spec}?inline`);
++                    // `spec` is root-relative to the app package — workspace
++                    // css (e.g. `packages/ui/theme/tokens.css` in a monorepo)
++                    // resolves under the workspace root, so a bare `${spec}
++                    // ?inline` transform misses there. Anchor it to the real
++                    // file via /@fs/ first, like the module pipeline does.
++                    let inlineSpec = spec;
++                    const cssFsRoots = [serverRoot, ...(monorepoWorkspaceRoot && path.resolve(monorepoWorkspaceRoot) !== path.resolve(serverRoot) ? [monorepoWorkspaceRoot] : [])];
++                    for (const root of cssFsRoots) {
++                        const fsId = `/@fs${String(root).replace(/\\/g, '/').replace(/\/$/, '')}${spec.startsWith('/') ? '' : '/'}${spec}`;
++                        const abs = resolveCandidateFilePath(fsId, serverRoot, monorepoWorkspaceRoot);
++                        if (abs) {
++                            inlineSpec = `/@fs${abs.replace(/\\/g, '/')}`;
++                            break;
 +                        }
 +                    }
-+                    catch { }
-+                    const hint = optimizedIds.length
-+                        ? ` Currently optimized: ${Array.from(new Set(optimizedIds)).join(', ')} — add the package that pulls in this chunk to optimizeDeps.exclude in the native vite config (or restart with NS_DEPS_PER_MODULE=1).`
-+                        : ' Add the importing package to optimizeDeps.exclude in the native vite config.';
-+                    res.statusCode = 404;
-+                    res.end(`throw new Error(${JSON.stringify(`[ns/m] Vite optimizeDeps artifact '${spec}' is not servable on device — its shared chunks are generated files outside the package tree.${hint}`)});\nexport {};\n`);
-+                    return;
-+                }
-                 const bare = spec.startsWith('/') ? spec.slice(1) : spec;
-                 const isBare = bare && !bare.includes('/') && !/\.(ts|tsx|js|jsx|mjs|mts|cts|vue)$/i.test(bare);
-                 if (isBare && (bare === 'vue' || bare === 'nativescript-vue' || bare === 'pinia')) {
++                    const inlineRes = await sharedTransformRequest(`${inlineSpec}?inline`);
+                     const inlineCode = inlineRes?.code || '';
+                     // `?inline` output is `export default "<compiled css>"`.
+                     const m = inlineCode.match(/export\s+default\s+("(?:[^"\\]|\\.)*")\s*;?/s);
+diff --git a/hmr/server/websocket-served-module-helpers.js b/hmr/server/websocket-served-module-helpers.js
+index e65b1abaaf223cca4b11b65b8428c85c484f125d..c738f974ccdef53166365cf3f34d45136a4684f6 100644
+--- a/hmr/server/websocket-served-module-helpers.js
++++ b/hmr/server/websocket-served-module-helpers.js
+@@ -6,7 +6,7 @@ import * as PAT from './constants.js';
+ import { isDeepCoreSubpath } from './core-sanitize.js';
+ import { getCjsNamedExports } from '../helpers/cjs-named-exports.js';
+ import { getMonorepoWorkspaceRoot } from '../../helpers/project.js';
+-import { extractDirectExportedNames, parseExportSpecList } from './websocket-core-bridge.js';
++import { extractDirectExportedNames, maskJsComments, parseExportSpecList } from './websocket-core-bridge.js';
+ import { resolveCandidateFilePath } from './websocket-module-specifiers.js';
+ let cachedWorkspaceCoreRoot;
+ /**
+@@ -105,8 +105,8 @@ export function classifyServedRequest(spec, resolvedId) {
+     return classifyServedModule(spec);
+ }
+ export const MODULE_IMPORT_ANALYSIS_PLUGINS = ['typescript', 'jsx', 'importMeta', 'topLevelAwait', 'classProperties', 'classPrivateProperties', 'classPrivateMethods', 'decorators-legacy'];
+-export function collectTopLevelImportRecords(code) {
+-    if (!code || typeof code !== 'string' || !/\bimport\b/.test(code)) {
++export function collectTopLevelImportRecords(code, includeReExports = false) {
++    if (!code || typeof code !== 'string' || !(includeReExports ? /\b(?:import|export)\b/ : /\bimport\b/).test(code)) {
+         return [];
+     }
+     try {
+@@ -119,7 +119,7 @@ export function collectTopLevelImportRecords(code) {
+             return [];
+         }
+         return body
+-            .filter((node) => t.isImportDeclaration(node) && typeof node.start === 'number' && typeof node.end === 'number' && typeof node.source?.value === 'string')
++            .filter((node) => (t.isImportDeclaration(node) || (includeReExports && (t.isExportNamedDeclaration(node) || t.isExportAllDeclaration(node)))) && typeof node.start === 'number' && typeof node.end === 'number' && typeof node.source?.value === 'string')
+             .map((node) => ({
+             start: node.start,
+             end: node.end,
+@@ -366,6 +366,10 @@ function normalizeStarExportTargetPath(spec, parentVitePath) {
+ //   - `extractExportMetadata` (below): does a module have a default export
+ //     and which named ones — shape-only, for SFC route metadata.
+ function scanModuleExportSurface(code) {
++    // Mask comments up front: the unanchored `export * as`/`export {} from`
++    // regexes below would otherwise claim names from commented-out lines and
++    // shadow the same name's real star-export source.
++    code = maskJsComments(code);
+     const ownNames = new Set(extractDirectExportedNames(code));
+     for (const m of code.matchAll(/\bexport\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s*["'][^"']+["']/g)) {
+         ownNames.add(m[1]);