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

package/hmr/shared/vendor/manifest.js

@@ -1,11 +1,13 @@
 import * as esbuild from 'esbuild';
 import { readFile } from 'fs/promises';
 import path from 'path';
-import { readFileSync } from 'fs';
+import fs, { readFileSync } from 'fs';
 import { createHash } from 'crypto';
 import { createRequire } from 'node:module';
 import { registerVendorManifest, clearVendorManifest, getVendorManifest } from './registry.js';
+import { generatePlatformPolyfills } from '../runtime/platform-polyfills.js';
 import { createNativeClassEsbuildPlugin } from '../../../helpers/nativeclass-esbuild-plugin.js';
+import { getGlobalDefines } from '../../../helpers/global-defines.js';
 export const VENDOR_MANIFEST_ID = '@nativescript/vendor-manifest';
 export const VENDOR_MANIFEST_VIRTUAL_ID = '\0' + VENDOR_MANIFEST_ID;
 export const VENDOR_BUNDLE_ID = '@nativescript/vendor';
@@ -17,10 +19,10 @@ export const DEFAULT_MANIFEST_FILENAME = 'ns-vendor-manifest.json';
 // Do not force-include @nativescript/core in the dev vendor bundle.
 // Keeping core out of vendor avoids duplicate side-effect registrations (e.g.,
 // com.tns.FragmentClass, com.tns.NativeScriptActivity) across bundle.mjs and vendor.
-// Reserved for any future always-include packages; keep empty by default so
-// framework-specific tooling like @angular/compiler are only pulled in when
-// the corresponding framework is actually used.
-const ALWAYS_INCLUDE = new Set([]);
+// Force runtime-sensitive packages onto the vendor path so they do not drift
+// between startup bundle, HTTP-wrapped CommonJS, and base-require semantics
+// during HMR sessions.
+const ALWAYS_INCLUDE = new Set(['stacktrace-js']);
 const ALWAYS_EXCLUDE = new Set([
     '@nativescript/android',
     '@nativescript/ios',
@@ -39,6 +41,9 @@ const ALWAYS_EXCLUDE = new Set([
     'bufferutil',
     'utf-8-validate',
     'node-gyp-build',
+    // All @babel/* and babel-* packages are build-time tools, never runtime deps.
+    // They get pulled in as peer deps of packages like @nativescript-community/solid-js
+    // but should never be in the vendor bundle (they require 'fs', 'path', etc.).
     '@babel/core',
     '@babel/helper-plugin-utils',
     '@babel/generator',
@@ -47,7 +52,11 @@ const ALWAYS_EXCLUDE = new Set([
     '@babel/parser',
     '@babel/plugin-syntax-typescript',
     '@babel/plugin-transform-typescript',
+    '@babel/preset-typescript',
+    '@babel/preset-env',
     '@babel/types',
+    'babel-preset-solid',
+    'babel-plugin-jsx-dom-expressions',
     // Heavy dependency not needed in vendor dev bundle; fetch via HTTP loader instead
     'rxjs',
     'nativescript',
@@ -57,6 +66,54 @@ const ALWAYS_EXCLUDE = new Set([
     'ws',
     '@types/node',
     'nativescript-theme-core',
+    // Build-time tools that get pulled in as transitive dependencies but should
+    // never be in the device vendor bundle (they require Node built-ins like fs,
+    // path, child_process, etc.). Now that we collect transitive runtime deps,
+    // these need explicit exclusion.
+    'esbuild',
+    'prettier',
+    'acorn',
+    'recast',
+    'source-map',
+    'source-map-js',
+    'tsx',
+    'diff',
+    'esprima',
+    // TanStack build-time router tooling (code generation, file-based routing)
+    '@tanstack/router-plugin',
+    '@tanstack/router-generator',
+    '@tanstack/router-utils',
+    '@tanstack/virtual-file-routes',
+    // File system / glob utilities — build-time only, require Node fs
+    'fdir',
+    'picomatch',
+    'tinyglobby',
+    // SSR-only library (bot detection) — not needed on device
+    'isbot',
+    // Type-only packages with no runtime JavaScript
+    'csstype',
+    // NativeScript CLI hook system — build-time only, requires Node os/path
+    '@nativescript/hook',
+    // Test runner uses webpack's require.context API which doesn't exist in Vite.
+    // Including it in the vendor bundle causes __require.context crashes at runtime.
+    '@nativescript/unit-test-runner',
+    'nativescript-unit-test-runner',
+    // CSS build tools — postcss, tailwindcss, and related tooling are exclusively
+    // build-time processors. They require Node APIs (process, fs, path) and must
+    // never run on device. esbuild bundles their transitive deps (picocolors,
+    // nanoid, etc.) which reference `process` and crash at runtime.
+    'tailwindcss',
+    '@nativescript/tailwind',
+    'postcss',
+    'autoprefixer',
+    'postcss-import',
+    'postcss-url',
+    'postcss-nested',
+    'picocolors',
+    'nanoid',
+    // Server-side SDKs that require Node networking APIs (net, tls, dns, crypto).
+    // These are backend tools, not device-side.
+    'mongodb',
 ]);
 const INDEX_ALIAS_SUFFIXES = ['/index', '/index.js', '/index.android.js', '/index.ios.js', '/index.visionos.js'];
 export function vendorManifestPlugin(options) {
@@ -106,7 +163,7 @@ export function vendorManifestPlugin(options) {
             const result = await ensureResult('server');
             if (req.url === SERVER_VENDOR_PATH) {
                 res.setHeader('Content-Type', 'application/javascript');
-                res.end(result.code);
+                res.end(createVendorBundleRuntimeModule(result));
                 return true;
             }
             if (req.url === SERVER_MANIFEST_PATH) {
@@ -173,15 +230,8 @@ export function vendorManifestPlugin(options) {
             }
             if (id === VENDOR_BUNDLE_VIRTUAL_ID) {
                 const result = await ensureResult('load-bundle');
-                // Return a single self-contained module that includes both the vendor module map
-                // and the vendor manifest to avoid extra imports that can influence chunking.
-                // - result.code exports `__nsVendorModuleMap`
-                // - we append an inline manifest export
                 return {
-                    code: `${result.code}
-export const vendorManifest = ${JSON.stringify(result.manifest)};
-export default vendorManifest;
-`,
+                    code: createVendorBundleRuntimeModule(result),
                     moduleType: 'js',
                 };
             }
@@ -219,7 +269,31 @@ async function generateVendorBundle(options) {
     const { projectRoot, platform, mode, flavor } = options;
     const collected = collectVendorModules(projectRoot, platform, flavor);
     const entryCode = createVendorEntry(collected.entries);
+    // Externalize @nativescript/core and its subpaths in the vendor bundle so
+    // vendored packages (e.g. @nativescript-community/ui-material-bottomsheet)
+    // do NOT bring their own copy of core with them. The iOS import map maps
+    // `@nativescript/core` → `/ns/core` (the core bridge) at runtime, and the
+    // bridge delegates to the canonical Application/View/etc. already set up
+    // by bundle.mjs via installCoreAliasesEarly + the globalThis.Application
+    // seed. Without this externalization, vendor.mjs bundles a second copy of
+    // iOSApplication/View/LayoutBase — the second iosApp never receives the
+    // iOS launch event (bundle.mjs's iosApp registered first as
+    // UIApplication.delegate), so Application.getRootView() on it returns
+    // undefined, and any vendor-internal code that reads .getRootView() or
+    // checks `instanceof View` against bundle's classes fails under HMR.
+    const nsCoreExternalPlugin = {
+        name: 'ns-core-external',
+        setup(build) {
+            build.onResolve({ filter: /^@nativescript\/core(?:\/.*)?$/ }, (args) => ({
+                path: args.path,
+                external: true,
+            }));
+        },
+    };
     const plugins = [
+        // Mark @nativescript/core external BEFORE other plugins so esbuild never
+        // tries to read/transform core's source files. See comment above.
+        nsCoreExternalPlugin,
         // Apply NativeClass transformer to convert @NativeClass decorated classes to ES5 IIFE pattern.
         // This MUST run before other plugins to ensure proper transformation.
         createNativeClassEsbuildPlugin(platform),
@@ -233,6 +307,14 @@ async function generateVendorBundle(options) {
     if (flavor === 'angular') {
         plugins.push(angularLinkerEsbuildPlugin(projectRoot));
     }
+    // Solid packages (e.g. solid-navigation) may ship raw .jsx/.tsx source
+    // files instead of pre-compiled .js. esbuild's default JSX transform
+    // targets React (React.createElement), which crashes at runtime with
+    // "React is not defined". Add a plugin that compiles .jsx/.tsx through
+    // babel-preset-solid so the vendor bundle gets proper Solid output.
+    if (flavor === 'solid') {
+        plugins.push(createSolidJsxEsbuildPlugin(projectRoot));
+    }
     const buildResult = await esbuild.build({
         stdin: {
             contents: entryCode,
@@ -252,23 +334,164 @@ async function generateVendorBundle(options) {
         // that Rollup warns it "cannot interpret due to the position of the comment".
         // This preserves license text while preventing noisy warnings.
         legalComments: 'eof',
-        conditions: ['module', 'import', platform, mode],
+        // NativeScript is always a client environment — never server-side. The conditions
+        // must include 'browser' so packages with conditional exports (e.g.,
+        // @tanstack/router-core/isServer) resolve to client-side variants.
+        //
+        // 'development'/'production' (mode) is intentionally excluded: esbuild resolves
+        // conditions in the order they appear in the package.json exports object, and
+        // many packages list 'development' before 'browser'. Including it would cause
+        // environment-ambiguous stubs (e.g., isServer = undefined) to win over the
+        // correct client-side value (isServer = false). The 'import' condition already
+        // provides the correct ESM entry points, and process.env.NODE_ENV (set via
+        // define below) handles dev/prod branching at runtime.
+        //
+        // This aligns with the non-HMR Vite build: ['module', 'react-native', 'import', 'browser', 'default'].
+        conditions: ['module', 'react-native', 'import', 'browser', 'default'],
         mainFields: ['module', 'browser', 'main'],
         resolveExtensions: resolveExtensionsForPlatform(platform),
         loader: {
             '.css': 'text',
             '.json': 'json',
         },
-        define: {
-            'process.env.NODE_ENV': JSON.stringify(mode),
-        },
+        // Mirror Vite's main-bundle DefinePlugin in the vendor esbuild build.
+        //
+        // esbuild's `define` requires every value to be a JS expression
+        // expressed as a string (the same constraint Vite normalises away).
+        // `getGlobalDefines()` returns a few raw `boolean` values for
+        // historical reasons (e.g. `__COMMONJS__: false`,
+        // `__UI_USE_XML_PARSER__: true`), so coerce any non-string entries
+        // through `JSON.stringify` before handing the table to esbuild.
+        define: (() => {
+            const raw = getGlobalDefines({
+                platform,
+                targetMode: mode,
+                verbose: !!options.verbose,
+                flavor: flavor ?? '',
+                isCI: !!process.env.CI,
+            });
+            const out = {};
+            for (const [key, value] of Object.entries(raw)) {
+                out[key] = typeof value === 'string' ? value : JSON.stringify(value);
+            }
+            // Belt-and-suspenders: keep the original NODE_ENV define explicit so
+            // future changes to `getGlobalDefines()` can't silently drop it.
+            out['process.env.NODE_ENV'] = JSON.stringify(mode);
+            return out;
+        })(),
         plugins,
-        external: ['fs', 'fs/promises', 'path', 'url', 'module', 'node:fs', 'node:fs/promises', 'node:path', 'node:url', 'node:module', 'assert', 'process', 'v8', 'util'],
+        // Externalize ALL Node built-in modules. The vendor bundle runs on the
+        // NativeScript device runtime, not Node, so any Node API reference must
+        // be external. Using both bare and 'node:' prefixed forms.
+        external: [
+            'assert',
+            'async_hooks',
+            'buffer',
+            'child_process',
+            'cluster',
+            'console',
+            'constants',
+            'crypto',
+            'dgram',
+            'diagnostics_channel',
+            'dns',
+            'domain',
+            'events',
+            'fs',
+            'fs/promises',
+            'http',
+            'http2',
+            'https',
+            'inspector',
+            'module',
+            'net',
+            'os',
+            'path',
+            'path/posix',
+            'path/win32',
+            'perf_hooks',
+            'process',
+            'punycode',
+            'querystring',
+            'readline',
+            'repl',
+            'stream',
+            'stream/web',
+            'stream/promises',
+            'string_decoder',
+            'sys',
+            'timers',
+            'timers/promises',
+            'tls',
+            'trace_events',
+            'tty',
+            'url',
+            'util',
+            'v8',
+            'vm',
+            'wasi',
+            'worker_threads',
+            'zlib',
+            // node: prefixed variants
+            'node:assert',
+            'node:async_hooks',
+            'node:buffer',
+            'node:child_process',
+            'node:cluster',
+            'node:console',
+            'node:constants',
+            'node:crypto',
+            'node:dgram',
+            'node:diagnostics_channel',
+            'node:dns',
+            'node:domain',
+            'node:events',
+            'node:fs',
+            'node:fs/promises',
+            'node:http',
+            'node:http2',
+            'node:https',
+            'node:inspector',
+            'node:module',
+            'node:net',
+            'node:os',
+            'node:path',
+            'node:path/posix',
+            'node:path/win32',
+            'node:perf_hooks',
+            'node:process',
+            'node:punycode',
+            'node:querystring',
+            'node:readline',
+            'node:repl',
+            'node:stream',
+            'node:stream/web',
+            'node:stream/promises',
+            'node:string_decoder',
+            'node:sys',
+            'node:timers',
+            'node:timers/promises',
+            'node:tls',
+            'node:trace_events',
+            'node:tty',
+            'node:url',
+            'node:util',
+            'node:v8',
+            'node:vm',
+            'node:wasi',
+            'node:worker_threads',
+            'node:zlib',
+        ],
     });
     if (!buildResult.outputFiles?.length) {
         throw new Error('Vendor bundle generation produced no output');
     }
-    const vendorCode = buildResult.outputFiles[0].text;
+    const rawVendorCode = buildResult.outputFiles[0].text;
+    // Prepend platform polyfills so they run BEFORE any vendor module code.
+    // This ensures globals like AbortController and self are available when
+    // frameworks (TanStack Router, etc.) first execute inside the bundle.
+    const polyfillPrelude = generatePlatformPolyfills();
+    const vendorCode = polyfillPrelude + rawVendorCode;
     const hash = createHash('sha1').update(vendorCode).digest('hex');
     const manifest = buildManifest(collected.entries, hash);
     return {
@@ -281,9 +504,17 @@ function collectVendorModules(projectRoot, platform, flavor) {
     const packageJsonPath = path.resolve(projectRoot, 'package.json');
     const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
     const projectRequire = createRequire(packageJsonPath);
+    const debug = process.env.VITE_DEBUG_LOGS === 'true' || process.env.VITE_DEBUG_LOGS === '1';
     const vendor = new Set();
     const visited = new Set();
     const queue = [];
+    // Local-source deps (file: pointing to a directory, link:, workspace:) are
+    // app code, not pre-packaged libraries. esbuild's vendor pipeline has none
+    // of the user's tsconfig path aliases or other Vite plugin resolvers, so
+    // any aliased import inside their source will fail with "Could not
+    // resolve". We collect their names here so that peer-dep traversal can
+    // also skip them.
+    const localSourceNames = new Set();
     const isPackageRootSpecifier = (name) => {
         if (!name)
             return false;
@@ -307,12 +538,14 @@ function collectVendorModules(projectRoot, platform, flavor) {
         if (!isAngularFlavor && (name === '@angular/compiler' || name.startsWith('@angular/'))) {
             return;
         }
-        const isRoot = isPackageRootSpecifier(name);
-        if (!visited.has(name)) {
-            visited.add(name);
+        // Skip already-visited packages to avoid redundant queue processing
+        if (visited.has(name)) {
+            return;
         }
+        visited.add(name);
         vendor.add(name);
-        // Only traverse peer deps for package roots; subpaths should not attempt package.json resolution
+        const isRoot = isPackageRootSpecifier(name);
+        // Only traverse deps for package roots; subpaths should not attempt package.json resolution
         if (isRoot) {
             queue.push(name);
         }
@@ -321,14 +554,35 @@ function collectVendorModules(projectRoot, platform, flavor) {
         if (!deps) {
             return;
         }
-        for (const name of Object.keys(deps)) {
+        for (const [name, spec] of Object.entries(deps)) {
+            if (isUnvendorableLocalSource(name, spec, projectRequire, platform)) {
+                // Defer to the regular Vite/Rolldown pipeline (HTTP-served in
+                // dev, bundled in production) where the
+                // ns-tsconfig-paths-resolver and the rest of the plugin chain
+                // can handle aliased imports. Local .tgz file: refs ARE proper
+                // packaged libraries and DO stay in vendor; so do file:
+                // directory refs that point at packages with compiled JS
+                // entry points (a common NativeScript monorepo pattern that
+                // hoists installs and re-exposes them from the app's
+                // package.json via `file:../../node_modules/<name>`).
+                localSourceNames.add(name);
+                if (debug) {
+                    console.log(`[vendor] skipping local source dependency ${name} (spec: ${String(spec)})`);
+                }
+                continue;
+            }
             addCandidate(name);
         }
     };
     addDeps(pkg.dependencies);
     addDeps(pkg.optionalDependencies);
     for (const name of ALWAYS_INCLUDE) {
-        addCandidate(name);
+        // Some force-included packages are only present transitively in apps that
+        // actually use them. Skip missing packages quietly so unrelated projects do
+        // not fail vendor collection just because the policy list names them.
+        if (canResolveDependencyPackageJson(name, projectRequire)) {
+            addCandidate(name);
+        }
     }
     // Ensure Android Activity proxy is present for SBG scanning in dev/HMR
     // and non-HMR builds alike: explicitly include the side-effect module
@@ -339,16 +593,10 @@ function collectVendorModules(projectRoot, platform, flavor) {
     if (pkg.dependencies?.['nativescript-vue'] && pkg.devDependencies?.vue) {
         addCandidate('vue');
     }
-    if (pkg.dependencies?.['@nativescript/angular']) {
-        if (pkg.dependencies?.['@angular/core']) {
-            addCandidate('@angular/core');
-        }
-        if (pkg.dependencies?.['@angular/common']) {
-            addCandidate('@angular/common');
-        }
-        // RxJS is large and not required inside the vendor bundle for dev HMR.
-        // Avoid bundling to reduce memory pressure; let app import via HTTP loader.
-    }
+    // Angular framework packages are intentionally NOT added to vendor. They are
+    // served via HTTP only so every importer resolves to a single module realm.
+    // See shouldSkipDependency() for the full rationale. RxJS is also left out of
+    // vendor (large, and not required in the vendor bundle for dev HMR).
     if (pkg.dependencies?.['react-nativescript']) {
         if (pkg.dependencies?.react) {
             addCandidate('react');
@@ -357,6 +605,21 @@ function collectVendorModules(projectRoot, platform, flavor) {
             addCandidate('react-dom');
         }
     }
+    // SolidJS / TanStack Router: when @nativescript/tanstack-router is a dependency,
+    // its runtime deps (@tanstack/solid-router, @tanstack/router-core, @tanstack/history)
+    // MUST be in the vendor bundle. These packages:
+    // 1. Use browser APIs (window.dispatchEvent) that don't exist in NativeScript — they
+    //    must be bundled where the NativeScript wrapper intercepts those calls
+    // 2. Contain JSX source that needs Solid compilation (dist/source/*.jsx) — the HTTP
+    //    fallback can't compile node_modules JSX since vite-plugin-solid skips it
+    // 3. Import solid-js internally — loading via HTTP creates a separate solid-js instance
+    // esbuild uses the 'import' condition (not 'solid'), resolving to pre-compiled
+    // dist/esm/*.js which avoids all three issues.
+    if (pkg.dependencies?.['@nativescript/tanstack-router']) {
+        addCandidate('@tanstack/solid-router');
+        addCandidate('@tanstack/router-core');
+        addCandidate('@tanstack/history');
+    }
     parseEnvList(process.env.NS_VENDOR_INCLUDE).forEach(addCandidate);
     const projectDeps = {
         dependencies: new Set(Object.keys(pkg.dependencies ?? {})),
@@ -371,13 +634,19 @@ function collectVendorModules(projectRoot, platform, flavor) {
         }
         const peerDependencies = Object.keys(dependencyPkg.peerDependencies ?? {});
         for (const peer of peerDependencies) {
-            if (shouldSkipDependency(peer)) {
+            if (shouldSkipDependency(peer) || localSourceNames.has(peer)) {
                 continue;
             }
             if (projectDeps.dependencies.has(peer) || projectDeps.optional.has(peer) || projectDeps.dev.has(peer)) {
                 addCandidate(peer);
             }
         }
+        // NOTE: We intentionally do NOT collect transitive runtime dependencies
+        // here. The import map + runtime specifier normalization handles non-vendor
+        // packages by routing them through HTTP to the Vite dev server. This avoids
+        // the fragility of trying to esbuild-bundle every transitive dep (which can
+        // fail due to Node built-ins, type-only packages, duplicate module instances,
+        // etc.). Only direct project dependencies go into the vendor bundle.
     }
     parseEnvList(process.env.NS_VENDOR_EXCLUDE).forEach((name) => {
         vendor.delete(name);
@@ -393,6 +662,44 @@ function shouldSkipDependency(name) {
     if (ALWAYS_EXCLUDE.has(name)) {
         return true;
     }
+    // Angular framework packages must only be served via the HTTP path so every
+    // importer resolves to a single module realm. When these packages are present
+    // in the vendor bundle AND imported by app modules via HTTP subpath, every
+    // @Component/@Injectable gets defined twice (once per realm), producing NG0912
+    // selector collisions, cross-realm `instanceof` failures, and dual class
+    // identities throughout Angular's DI container. HTTP-only is the single-realm
+    // invariant for user-level framework code.
+    if (name === '@nativescript/angular' || name === 'nativescript-angular' || name.startsWith('@angular/')) {
+        return true;
+    }
+    // All Babel packages are build tools — never bundle into device runtime.
+    // They require Node built-ins (fs, path, url) that don't exist on device.
+    if (name.startsWith('@babel/') || name.startsWith('babel-')) {
+        return true;
+    }
+    // Dev tools and type-only packages — not needed on device
+    if (name.startsWith('@solid-devtools/')) {
+        return true;
+    }
+    if (name.startsWith('@types/')) {
+        return true;
+    }
+    // PostCSS ecosystem — all build-time CSS processing
+    if (name === 'postcss' || name.startsWith('postcss-')) {
+        return true;
+    }
+    // Tailwind ecosystem — build-time only CSS framework
+    if (name.includes('tailwind')) {
+        return true;
+    }
+    // Test runners and frameworks — never needed on device
+    if (name.includes('test-runner') || name.includes('unit-test')) {
+        return true;
+    }
+    // Linters and formatters — build-time tools
+    if (name.includes('eslint') || name.includes('stylelint')) {
+        return true;
+    }
     if (name.startsWith('.')) {
         return true;
     }
@@ -407,6 +714,160 @@ function shouldSkipDependency(name) {
     }
     return false;
 }
+const COMPILED_JS_ENTRY_EXTENSIONS = ['.js', '.mjs', '.cjs'];
+const COMPILED_JS_ENTRY_REGEX = /\.(?:c|m)?jsx?$/;
+function compiledJsExtensionsForPlatform(platform) {
+    const exts = [...COMPILED_JS_ENTRY_EXTENSIONS];
+    switch (platform) {
+        case 'android':
+            exts.push('.android.js');
+            break;
+        case 'ios':
+            exts.push('.ios.js', '.visionos.js');
+            break;
+        case 'visionos':
+            exts.push('.visionos.js', '.ios.js');
+            break;
+    }
+    return exts;
+}
+/**
+ * Determine whether a `package.json` dependency must be excluded from the
+ * HMR vendor bundle because esbuild's standalone vendor pipeline can't
+ * resolve its source.
+ *
+ * The HMR vendor bundle is generated by a standalone esbuild build that
+ * has none of the Vite plugin chain (most notably
+ * `ns-tsconfig-paths-resolver`), so any aliased import inside the
+ * package's **source** files will fail with "Could not resolve" and abort
+ * the whole bundle.
+ *
+ * Skip:
+ *  - `link:` and `workspace:` refs (always app-side source).
+ *  - `file:` refs to a directory whose installed package only ships
+ *    TypeScript/JSX source (no compiled `.js`/`.mjs`/`.cjs` entry).
+ *
+ * Keep (return false):
+ *  - Regular semver / git / url specs (normal third-party libraries).
+ *  - Local `.tgz` file refs (pre-packaged libraries extracted at install).
+ *  - `file:` directory refs that resolve to a package with a compiled JS
+ *    entry — a common NativeScript monorepo convention where the app's
+ *    `package.json` redirects to `../../node_modules/<name>` to avoid
+ *    duplicate installs while letting the NativeScript CLI discover
+ *    plugins from the app directory.
+ */
+export function isUnvendorableLocalSource(name, spec, projectRequire, platform) {
+    if (typeof spec !== 'string')
+        return false;
+    if (spec.startsWith('link:') || spec.startsWith('workspace:'))
+        return true;
+    if (!spec.startsWith('file:'))
+        return false;
+    // Tarballs are already pre-packaged libraries — install extracts them
+    // into a normal node_modules entry.
+    if (/\.t(?:ar\.)?gz(?:[?#].*)?$/.test(spec))
+        return false;
+    // Directory file: refs need a deeper check: peek at the installed
+    // package.json and ask "does this ship compiled JS?". If yes, vendor
+    // it. If no (TS source only), defer to the regular Vite pipeline.
+    return !packageHasCompiledJsEntry(name, projectRequire, platform);
+}
+function packageHasCompiledJsEntry(name, projectRequire, platform) {
+    let pkgJsonPath;
+    try {
+        pkgJsonPath = projectRequire.resolve(`${name}/package.json`);
+    }
+    catch {
+        return false;
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+    }
+    catch {
+        return false;
+    }
+    const pkgDir = path.dirname(pkgJsonPath);
+    const candidates = [];
+    const pushCandidate = (value) => {
+        if (typeof value === 'string' && value)
+            candidates.push(value);
+    };
+    pushCandidate(pkg.module);
+    pushCandidate(pkg.main);
+    // Recursively flatten conditional `exports` maps to surface concrete
+    // file paths. We only need `string` leaves; anything else (function-
+    // based exports, etc.) doesn't apply to esbuild's resolution.
+    const visitExports = (node) => {
+        if (!node)
+            return;
+        if (typeof node === 'string') {
+            pushCandidate(node);
+            return;
+        }
+        if (Array.isArray(node)) {
+            for (const item of node)
+                visitExports(item);
+            return;
+        }
+        if (typeof node === 'object') {
+            for (const value of Object.values(node))
+                visitExports(value);
+        }
+    };
+    visitExports(pkg.exports);
+    if (candidates.length === 0) {
+        // node's default lookup falls back to `index.js`.
+        candidates.push('index');
+    }
+    const extensionsToTry = compiledJsExtensionsForPlatform(platform);
+    for (const cand of candidates) {
+        const abs = path.resolve(pkgDir, cand);
+        const ext = path.extname(cand);
+        if (COMPILED_JS_ENTRY_REGEX.test(cand)) {
+            // Explicit JS extension. If the file exists, vendor it. If not
+            // (a NativeScript plugin commonly declares `main: "index.js"`
+            // but ships only platform variants like `index.ios.js`), try
+            // the platform-specific variants which esbuild's
+            // `resolveExtensions` will pick up at bundle time.
+            if (fs.existsSync(abs))
+                return true;
+            const baseAbs = abs.slice(0, -ext.length);
+            for (const e of extensionsToTry) {
+                if (fs.existsSync(baseAbs + e))
+                    return true;
+            }
+            continue;
+        }
+        if (!ext) {
+            // Extensionless main — try plain JS variants AND the
+            // platform-specific variants NativeScript plugins commonly use
+            // (`index.ios.js`, `index.android.js`, `index.visionos.js`).
+            for (const e of extensionsToTry) {
+                if (fs.existsSync(abs + e))
+                    return true;
+            }
+            continue;
+        }
+        // A non-JS extension (typically `.ts`/`.tsx`) means the package
+        // only ships TS source — esbuild's vendor pipeline can't resolve
+        // any tsconfig-aliased imports inside it.
+    }
+    return false;
+}
+export const __test_collectVendorModules = collectVendorModules;
+export const __test_createVendorBundleRuntimeModule = createVendorBundleRuntimeModule;
+export const __test_isUnvendorableLocalSource = isUnvendorableLocalSource;
+export const __test_packageHasCompiledJsEntry = packageHasCompiledJsEntry;
+function canResolveDependencyPackageJson(specifier, projectRequire) {
+    try {
+        projectRequire.resolve(`${specifier}/package.json`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function readDependencyPackageJson(specifier, projectRequire) {
     try {
         const packageJsonPath = projectRequire.resolve(`${specifier}/package.json`);
@@ -437,6 +898,12 @@ function createVendorEntry(entries) {
     const modules = entries.map((specifier, index) => `${JSON.stringify(specifier)}: __nsVendor_${index}`).join(',\n  ');
     return `${imports}\n\nexport const __nsVendorModuleMap = {\n  ${modules}\n};\n`;
 }
+function createVendorBundleRuntimeModule(result) {
+    return `${result.code}
+export const vendorManifest = ${JSON.stringify(result.manifest)};
+export default vendorManifest;
+`;
+}
 function resolveExtensionsForPlatform(platform) {
     const base = ['.tsx', '.jsx', '.ts', '.js', '.mjs', '.cjs', '.json'];
     const extensions = new Set(base);
@@ -518,10 +985,7 @@ function createVendorEsbuildPlugin(projectRoot) {
             // @angular/platform-browser/animations -> provide concrete named stubs
             build.onResolve({ filter: /^@angular\/platform-browser\/animations(?:\/.*)?$/ }, (args) => {
                 if (debug) {
-                    try {
-                        console.log('[vendor] map', args.path, '->', PB_ANIMATIONS_ID);
-                    }
-                    catch { }
+                    console.log('[vendor] map', args.path, '->', PB_ANIMATIONS_ID);
                 }
                 return { path: PB_ANIMATIONS_ID, namespace: 'ns-vendor' };
             });
@@ -547,10 +1011,7 @@ function createVendorEsbuildPlugin(projectRoot) {
             // @angular/animations/browser -> provide ɵ* engine/renderer/style normalizer stubs
             build.onResolve({ filter: /^@angular\/animations\/browser(?:\/.*)?$/ }, (args) => {
                 if (debug) {
-                    try {
-                        console.log('[vendor] map', args.path, '->', ANIMATIONS_BROWSER_ID);
-                    }
-                    catch { }
+                    console.log('[vendor] map', args.path, '->', ANIMATIONS_BROWSER_ID);
                 }
                 return { path: ANIMATIONS_BROWSER_ID, namespace: 'ns-vendor' };
             });
@@ -572,10 +1033,7 @@ function createVendorEsbuildPlugin(projectRoot) {
             // Keep generic mapping for @angular/animations base; /browser is handled above
             { filter: /^@angular\/animations(?:$|\/)$/ }, (args) => {
                 if (debug) {
-                    try {
-                        console.log('[vendor] map', args.path, '->', ANIMATIONS_ID);
-                    }
-                    catch { }
+                    console.log('[vendor] map', args.path, '->', ANIMATIONS_ID);
                 }
                 return { path: ANIMATIONS_ID, namespace: 'ns-vendor' };
             });
@@ -606,6 +1064,63 @@ function createVendorEsbuildPlugin(projectRoot) {
         },
     };
 }
+/**
+ * esbuild plugin to compile .jsx/.tsx files from Solid packages through
+ * babel-preset-solid. Without this, esbuild uses its default React JSX
+ * transform, producing React.createElement calls that crash at runtime.
+ *
+ * Only applied to files inside node_modules that have .jsx or .tsx extension.
+ */
+function createSolidJsxEsbuildPlugin(projectRoot) {
+    // Lazy-load Babel and the Solid preset so they're only required when
+    // the Solid flavor is active.
+    let babel;
+    let solidPreset;
+    return {
+        name: 'ns-vendor-solid-jsx',
+        setup(build) {
+            // Intercept .jsx and .tsx files from node_modules
+            build.onLoad({ filter: /node_modules\/.*\.[jt]sx$/ }, async (args) => {
+                try {
+                    if (!babel) {
+                        babel = await import('@babel/core');
+                        // babel-preset-solid is the standard Solid JSX transform
+                        solidPreset = (await import('babel-preset-solid')).default;
+                    }
+                    const source = await readFile(args.path, 'utf-8');
+                    const result = await babel.transformAsync(source, {
+                        filename: args.path,
+                        presets: [
+                            [
+                                solidPreset,
+                                {
+                                    generate: 'universal',
+                                    hydratable: false,
+                                    moduleName: '@nativescript-community/solid-js',
+                                },
+                            ],
+                        ],
+                        parserOpts: {
+                            plugins: ['jsx', ...(args.path.endsWith('.tsx') ? ['typescript'] : [])],
+                        },
+                        ast: false,
+                        sourceMaps: false,
+                        configFile: false,
+                        babelrc: false,
+                    });
+                    if (result?.code) {
+                        return { contents: result.code, loader: 'js' };
+                    }
+                }
+                catch (e) {
+                    console.warn(`[ns-vendor-solid-jsx] failed to transform ${args.path}:`, e?.message || e);
+                }
+                // Fall through to esbuild's default handling
+                return undefined;
+            });
+        },
+    };
+}
 /**
  * Minimal esbuild plugin to run Angular linker (Babel) over partial-compiled
  * Angular packages in node_modules. This converts ɵɵngDeclare* calls into
@@ -615,6 +1130,7 @@ function angularLinkerEsbuildPlugin(projectRoot) {
     // Lazily resolve Babel and Angular linker from the project to avoid hard deps
     let babel = null;
     let createLinker = null;
+    let angularFileSystem = null;
     async function ensureDeps() {
         if (babel && createLinker)
             return;
@@ -639,6 +1155,40 @@ function angularLinkerEsbuildPlugin(projectRoot) {
             }
             catch { }
         }
+        // Angular 21+ requires a fileSystem for the linker plugin
+        if (!angularFileSystem) {
+            try {
+                const req = createRequire(projectRoot + '/package.json');
+                const cliPath = req.resolve('@angular/compiler-cli');
+                const cliMod = await import(cliPath);
+                if (cliMod.NodeJSFileSystem) {
+                    angularFileSystem = new cliMod.NodeJSFileSystem();
+                }
+            }
+            catch { }
+            if (!angularFileSystem) {
+                try {
+                    const cliMod = await import('@angular/compiler-cli');
+                    if (cliMod.NodeJSFileSystem) {
+                        angularFileSystem = new cliMod.NodeJSFileSystem();
+                    }
+                }
+                catch { }
+            }
+            if (!angularFileSystem) {
+                // Minimal fallback
+                const nodePath = await import('node:path');
+                const nodeFs = await import('node:fs');
+                angularFileSystem = {
+                    resolve: (...paths) => nodePath.resolve(...paths),
+                    dirname: (p) => nodePath.dirname(p),
+                    join: (...paths) => nodePath.join(...paths),
+                    isRooted: (p) => nodePath.isAbsolute(p),
+                    exists: (p) => nodeFs.existsSync(p),
+                    readFile: (p) => nodeFs.readFileSync(p, 'utf8'),
+                };
+            }
+        }
     }
     // Restrict to Angular framework packages to minimize esbuild memory usage.
     const FILTER = /node_modules\/(?:@angular|@nativescript\/angular)\/.*\.[mc]?js$/;
@@ -659,15 +1209,11 @@ function angularLinkerEsbuildPlugin(projectRoot) {
                         return { contents: source, loader: 'js' };
                     }
                     const plugin = createLinker({
-                        // Link everything the filter captures; plugin will no-op otherwise
-                        // shouldLink is inferred by plugin when left unset for Babel version
                         sourceMapping: false,
+                        fileSystem: angularFileSystem,
                     });
                     if (debug) {
-                        try {
-                            console.log('[ns-angular-linker][vendor] linking', args.path);
-                        }
-                        catch { }
+                        console.log('[ns-angular-linker][vendor] linking', args.path);
                     }
                     const result = await babel.transformAsync(source, {
                         filename: args.path,
@@ -773,15 +1319,84 @@ function normalizeSpecifier(spec) {
   return value;
 }
 
+function normalizeCoreSubLocal(s) {
+  if (!s) return "";
+  let t = String(s).split("?")[0].split("#")[0].trim();
+  t = t.replace(/^\\/+/, "").replace(/\\/+$/, "");
+  t = t.replace(/\\.(?:mjs|cjs|js)$/, "");
+  if (t.length >= 6 && t.substring(t.length - 6) === "/index") {
+    t = t.substring(0, t.length - 6);
+  }
+  if (!t || t === "index") return "";
+  return t;
+}
+
+// Invariant D: shape ESM namespaces before returning to CJS callers.
+//
+// The /ns/core handler's registration footer (see websocket.ts) and the
+// main-entry require shim (see helpers/main-entry.ts) both install the
+// shape function on globalThis. In practice, entries stored in
+// __NS_CORE_MODULES__ are ALREADY shaped, so this pass-through is a
+// fast no-op (the shape function's fast path returns obj as-is when it
+// already has Object.prototype). We call it anyway as defense-in-depth
+// against future callers that might populate the registry without
+// shaping.
+function shapeForCjs(value) {
+  if (!value || typeof value !== "object") return value;
+  const shape = g.__NS_CJS_SHAPE__;
+  if (typeof shape === "function") {
+    try { return shape(value); } catch (e) {}
+  }
+  return value;
+}
+
+function resolveCoreFromRegistry(normalizedId) {
+  if (
+    normalizedId !== "@nativescript/core" &&
+    normalizedId.indexOf("@nativescript/core/") !== 0
+  ) {
+    return null;
+  }
+  const table = g.__NS_CORE_MODULES__;
+  if (!table) return null;
+  if (table[normalizedId]) return shapeForCjs(table[normalizedId]);
+  const rawSub =
+    normalizedId === "@nativescript/core"
+      ? ""
+      : normalizedId.slice("@nativescript/core/".length);
+  const normSub = normalizeCoreSubLocal(rawSub);
+  const bareKey = normSub ? "@nativescript/core/" + normSub : "@nativescript/core";
+  if (table[bareKey]) return shapeForCjs(table[bareKey]);
+  if (normSub && table[normSub]) return shapeForCjs(table[normSub]);
+  if (!normSub && table[""]) return shapeForCjs(table[""]);
+  return null;
+}
+
 export function createRequire(_url) {
   const nsRequire = getNativeScriptRequire();
   if (!nsRequire) {
-    return function () {
+    return function (id) {
+      // Even without nsRequire, the @nativescript/core registry populated by
+      // the /ns/core bridge may already have the module — return it so
+      // vendor install() hooks that run against the HMR-served core don't
+      // crash at module-instantiation time.
+      const fromRegistry = resolveCoreFromRegistry(normalizeSpecifier(id));
+      if (fromRegistry) return fromRegistry;
       throw new Error("NativeScript require() is not available in this context");
     };
   }
   const req = function (id) {
     const normalizedId = normalizeSpecifier(id);
+    // Invariant C: @nativescript/core and its subpaths are served ONCE via
+    // the /ns/core HTTP bridge, which self-registers each module's ESM
+    // namespace on globalThis.__NS_CORE_MODULES__. CommonJS require() from
+    // vendor packages (e.g. \`require('@nativescript/core/ui/core/view').View\`
+    // in @nativescript-community/gesturehandler, or \`require('@nativescript/core').View\`
+    // in @nativescript-community/ui-material-core) MUST resolve to that
+    // same namespace; otherwise we re-trigger class identity splits and
+    // applyMixins() crashes with "Cannot read properties of undefined".
+    const fromRegistry = resolveCoreFromRegistry(normalizedId);
+    if (fromRegistry) return fromRegistry;
     if (
       normalizedId.includes("../data/patch.json") ||
       normalizedId.includes("css-tree/lib/data/patch.json")
@@ -804,7 +1419,12 @@ export function createRequire(_url) {
     if (normalizedId.endsWith(".json")) {
       return {};
     }
-    return nsRequire(normalizedId);
+    // Shape the native require result too. The NativeScript CJS loader
+    // may serve an @nativescript/core subpath over HTTP before the
+    // /ns/core footer has run (e.g., during initial boot). In that
+    // window, the result is a raw ESM namespace with null [[Prototype]]
+    // and zone.js/vendor install() hooks crash on hasOwnProperty.
+    return shapeForCjs(nsRequire(normalizedId));
   };
   req.resolve = nsRequire.resolve
     ? function (id) {