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

package/configuration/angular.d.ts

@@ -1,4 +1,4 @@
 import { type UserConfig } from 'vite';
 export declare const angularConfig: ({ mode }: {
-    mode: any;
+    mode: string;
 }) => UserConfig;

package/configuration/angular.js

@@ -4,14 +4,40 @@ import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import angular from '@analogjs/vite-plugin-angular';
 import { angularLinkerVitePlugin, angularLinkerVitePluginPost } from '../helpers/angular/angular-linker.js';
-import { ensureSharedAngularLinker } from '../helpers/angular/shared-linker.js';
+import { synthesizeMissingInjectableFactories } from '../helpers/angular/synthesize-injectable-factories.js';
+import { ensureSharedAngularLinker, resolveAngularFileSystem } from '../helpers/angular/shared-linker.js';
+import { inlineDecoratorComponentTemplates } from '../helpers/angular/inline-decorator-component-templates.js';
+import { synthesizeDecoratorCtorParameters } from '../helpers/angular/synthesize-decorator-ctor-parameters.js';
 import { containsRealNgDeclare } from '../helpers/angular/util.js';
 import { baseConfig } from './base.js';
 import { getCliFlags } from '../helpers/cli-flags.js';
+import { resolveRelativeToImportMeta } from '../helpers/import-meta-path.js';
+// Lazily import the Angular linker factory function. Used by chunk-level linkers
+// to create FRESH plugin instances per invocation (avoiding stale state in watch mode).
+let _cachedLinkerFactory = null;
+async function importLinkerFactory() {
+    if (_cachedLinkerFactory)
+        return _cachedLinkerFactory;
+    const req = createRequire(process.cwd() + '/package.json');
+    try {
+        const linkerPath = req.resolve('@angular/compiler-cli/linker/babel');
+        const linkerMod = await import(linkerPath);
+        _cachedLinkerFactory = linkerMod.createLinkerPlugin || linkerMod.createEs2015LinkerPlugin || null;
+    }
+    catch {
+        try {
+            const linkerMod = await import('@angular/compiler-cli/linker/babel');
+            _cachedLinkerFactory = linkerMod.createLinkerPlugin || linkerMod.createEs2015LinkerPlugin || null;
+        }
+        catch { }
+    }
+    return _cachedLinkerFactory;
+}
 // Rollup-level linker to guarantee Angular libraries are linked when included in the bundle graph.
 function angularRollupLinker(projectRoot) {
     let babel = null;
     let createLinker = null;
+    let angularFileSystem = null;
     const FILTER = /node_modules\/(?:@angular|@nativescript\/angular)\/.*\.[mc]?js$/;
     async function ensureDeps() {
         if (babel && createLinker)
@@ -35,6 +61,9 @@ function angularRollupLinker(projectRoot) {
             }
             catch { }
         }
+        if (!angularFileSystem) {
+            angularFileSystem = await resolveAngularFileSystem(projectRoot);
+        }
     }
     return {
         name: 'ns-angular-linker-rollup',
@@ -56,7 +85,7 @@ function angularRollupLinker(projectRoot) {
                     return null;
                 if (!forceLink && code.indexOf('\u0275\u0275ngDeclare') === -1 && code.indexOf('ɵɵngDeclare') === -1 && code.indexOf('ngDeclare') === -1)
                     return null;
-                const plugin = createLinker({ sourceMapping: false });
+                const plugin = createLinker({ sourceMapping: false, fileSystem: angularFileSystem });
                 if (debug) {
                     try {
                         console.log('[ns-angular-linker][rollup-load] linking', cleanId);
@@ -92,7 +121,7 @@ function angularRollupLinker(projectRoot) {
             if (!babel || !createLinker)
                 return null;
             try {
-                const plugin = createLinker({ sourceMapping: false });
+                const plugin = createLinker({ sourceMapping: false, fileSystem: angularFileSystem });
                 if (debug) {
                     try {
                         console.log('[ns-angular-linker][rollup] linking', cleanId);
@@ -126,76 +155,212 @@ let tsConfig = tsConfigAppPath;
 if (!fs.existsSync(tsConfigAppPath) && fs.existsSync(tsConfigPath)) {
     tsConfig = tsConfigPath;
 }
-const plugins = [
-    // Allow external html template changes to trigger hot reload: Make .ts files depend on their .html templates
-    {
-        name: 'angular-template-deps',
-        transform(code, id) {
-            // For .ts files that reference templateUrl, add the .html file as a dependency
-            if (id.endsWith('.ts') && code.includes('templateUrl')) {
-                const templateUrlMatch = code.match(/templateUrl:\s*['"]\.\/(.*?\.html)['"]/);
-                if (templateUrlMatch) {
-                    const htmlPath = path.resolve(path.dirname(id), templateUrlMatch[1]);
-                    // Add the HTML file as a dependency so Vite watches it
-                    this.addWatchFile(htmlPath);
-                }
+function normalizeAngularWatchPath(filePath) {
+    return filePath
+        .split('?', 1)[0]
+        .replace(/\\/g, '/')
+        .replace(/^file:\/\//, '');
+}
+function normalizeAngularWatchKey(filePath) {
+    const normalizedPath = normalizeAngularWatchPath(filePath);
+    const fileSystemPath = normalizedPath.startsWith('/@fs/') ? normalizedPath.slice('/@fs'.length) : normalizedPath;
+    const normalizedProjectRoot = projectRoot.replace(/\\/g, '/').replace(/\/$/, '');
+    if (normalizedProjectRoot && fileSystemPath.startsWith(normalizedProjectRoot)) {
+        const relative = fileSystemPath.slice(normalizedProjectRoot.length);
+        return relative.startsWith('/') ? relative : `/${relative}`;
+    }
+    return fileSystemPath;
+}
+function getAngularWatchKeys(filePath) {
+    const normalizedPath = normalizeAngularWatchPath(filePath);
+    const keys = new Set();
+    keys.add(normalizedPath);
+    keys.add(normalizeAngularWatchKey(normalizedPath));
+    return Array.from(keys).filter(Boolean);
+}
+function resolveAngularWatchFilePath(filePath) {
+    const normalizedPath = normalizeAngularWatchPath(filePath);
+    const fileSystemPath = normalizedPath.startsWith('/@fs/') ? normalizedPath.slice('/@fs'.length) : normalizedPath;
+    if (path.isAbsolute(fileSystemPath) && fs.existsSync(fileSystemPath)) {
+        return fileSystemPath;
+    }
+    if (fileSystemPath.startsWith('/')) {
+        return path.resolve(projectRoot, `.${fileSystemPath}`);
+    }
+    return path.resolve(projectRoot, fileSystemPath);
+}
+function extractComponentAssetPaths(code, componentId) {
+    const componentPath = normalizeAngularWatchPath(componentId);
+    const assetPaths = new Set();
+    const resolveAssetPath = (assetPath) => normalizeAngularWatchPath(path.resolve(path.dirname(componentPath), assetPath));
+    const templateUrlMatch = code.match(/templateUrl\s*:\s*['"](.+?\.(?:html|htm))['"]/);
+    if (templateUrlMatch) {
+        assetPaths.add(resolveAssetPath(templateUrlMatch[1]));
+    }
+    const styleUrlMatch = code.match(/styleUrl\s*:\s*['"](.+?\.(?:css|less|sass|scss))['"]/);
+    if (styleUrlMatch) {
+        assetPaths.add(resolveAssetPath(styleUrlMatch[1]));
+    }
+    const styleUrlsMatch = code.match(/styleUrls\s*:\s*\[([\s\S]*?)\]/m);
+    if (styleUrlsMatch) {
+        for (const match of styleUrlsMatch[1].matchAll(/['"](.+?\.(?:css|less|sass|scss))['"]/g)) {
+            assetPaths.add(resolveAssetPath(match[1]));
+        }
+    }
+    return Array.from(assetPaths);
+}
+function createAngularPlugins(opts) {
+    const assetToComponents = new Map();
+    const componentToAssets = new Map();
+    const pendingComponentInvalidations = new Set();
+    const untrackComponentAssets = (componentPath) => {
+        const previousAssets = componentToAssets.get(componentPath);
+        if (!previousAssets)
+            return;
+        for (const assetPath of previousAssets) {
+            const components = assetToComponents.get(assetPath);
+            if (!components)
+                continue;
+            components.delete(componentPath);
+            if (components.size === 0) {
+                assetToComponents.delete(assetPath);
             }
-            return null;
+        }
+        componentToAssets.delete(componentPath);
+    };
+    const trackComponentAssets = (componentPath, assetPaths) => {
+        untrackComponentAssets(componentPath);
+        if (assetPaths.length === 0)
+            return;
+        const normalizedAssets = new Set(assetPaths.flatMap((assetPath) => getAngularWatchKeys(assetPath)));
+        componentToAssets.set(componentPath, normalizedAssets);
+        for (const assetPath of normalizedAssets) {
+            const components = assetToComponents.get(assetPath) || new Set();
+            components.add(componentPath);
+            assetToComponents.set(assetPath, components);
+        }
+    };
+    return [
+        // Allow external html template changes to trigger hot reload: Make .ts files depend on their .html templates
+        {
+            name: 'angular-template-deps',
+            enforce: 'pre',
+            transform(code, id) {
+                const componentPath = normalizeAngularWatchPath(id);
+                const componentKey = normalizeAngularWatchKey(id);
+                if (!componentKey.endsWith('.ts'))
+                    return null;
+                const assetPaths = extractComponentAssetPaths(code, componentPath);
+                trackComponentAssets(componentKey, assetPaths);
+                for (const assetPath of assetPaths) {
+                    this.addWatchFile(assetPath);
+                }
+                return null;
+            },
+            watchChange(id) {
+                const changedPath = normalizeAngularWatchPath(id);
+                const components = new Set();
+                for (const assetKey of getAngularWatchKeys(changedPath)) {
+                    for (const componentPath of assetToComponents.get(assetKey) || []) {
+                        components.add(componentPath);
+                    }
+                }
+                if (components?.size) {
+                    for (const componentPath of components) {
+                        pendingComponentInvalidations.add(componentPath);
+                    }
+                    return;
+                }
+                if (/\.(html|htm)$/i.test(changedPath)) {
+                    const componentPath = changedPath.replace(/\.(html|htm)$/i, '.ts');
+                    if (fs.existsSync(resolveAngularWatchFilePath(componentPath))) {
+                        pendingComponentInvalidations.add(normalizeAngularWatchKey(componentPath));
+                    }
+                }
+            },
+            shouldTransformCachedModule({ id }) {
+                const componentPath = normalizeAngularWatchKey(id);
+                if (!pendingComponentInvalidations.has(componentPath))
+                    return null;
+                pendingComponentInvalidations.delete(componentPath);
+                return true;
+            },
         },
-    },
-    // Transform Angular partial declarations in node_modules to avoid runtime JIT
-    // Pass the project root so linker deps resolve from the app, not the plugin package.
-    angularLinkerVitePlugin(process.cwd()),
-    // Simplify: rely on Vite pre plugin (load/transform) for linking; Rollup safety net disabled unless re-enabled later
-    // angularRollupLinker(process.cwd()),
-    angular({
-        liveReload: false, // Disable live reload in favor of HMR
-        tsconfig: tsConfig,
-    }),
-    // Post-phase linker to catch any declarations introduced after other transforms (including project code)
-    angularLinkerVitePluginPost(process.cwd()),
-    // Enforce: fully disable dependency optimization during serve to avoid rxjs esm5 crawling and OOM
-    {
-        name: 'ns-disable-optimize-deps',
-        enforce: 'post',
-        apply: 'serve',
-        config(userConfig) {
-            const od = userConfig?.optimizeDeps || {};
-            const prevExclude = Array.isArray(od.exclude) ? od.exclude : [];
-            const exclude = new Set(prevExclude);
-            ['@nativescript/core', 'rxjs', '@valor/nativescript-websockets', 'set-value', 'react', 'react-reconciler', 'react-nativescript'].forEach((x) => exclude.add(x));
-            return {
-                optimizeDeps: {
-                    noDiscovery: true,
-                    entries: [],
-                    include: [],
-                    exclude: Array.from(exclude),
-                    rolldownOptions: {
-                        ...(od.rolldownOptions || {}),
-                        plugins: [],
+        // Transform Angular partial declarations in node_modules to avoid runtime JIT
+        // Pass the project root so linker deps resolve from the app, not the plugin package.
+        angularLinkerVitePlugin(process.cwd()),
+        // Simplify: rely on Vite pre plugin (load/transform) for linking; Rollup safety net disabled unless re-enabled later
+        // angularRollupLinker(process.cwd()),
+        ...angular({
+            experimental: {
+                useAngularCompilationAPI: opts.useAngularCompilationAPI,
+            },
+            liveReload: false, // Disable live reload in favor of HMR
+            tsconfig: tsConfig,
+        }),
+        // Post-phase linker to catch any declarations introduced after other transforms (including project code)
+        angularLinkerVitePluginPost(process.cwd()),
+        // Enforce: fully disable dependency optimization during serve to avoid rxjs esm5 crawling and OOM
+        {
+            name: 'ns-disable-optimize-deps',
+            enforce: 'post',
+            apply: 'serve',
+            config(userConfig) {
+                const od = userConfig?.optimizeDeps || {};
+                const prevExclude = Array.isArray(od.exclude) ? od.exclude : [];
+                const exclude = new Set(prevExclude);
+                ['@nativescript/core', 'rxjs', '@valor/nativescript-websockets', 'set-value', 'react', 'react-reconciler', 'react-nativescript'].forEach((x) => exclude.add(x));
+                return {
+                    optimizeDeps: {
+                        noDiscovery: true,
+                        entries: [],
+                        include: [],
+                        exclude: Array.from(exclude),
+                        rolldownOptions: {
+                            ...(od.rolldownOptions || {}),
+                            plugins: [],
+                        },
                     },
-                },
-            };
-        },
-        configResolved(resolved) {
-            const deps = (resolved.optimizeDeps || (resolved.optimizeDeps = {}));
-            deps.noDiscovery = true;
-            deps.entries = [];
-            deps.include = [];
-            const exclude = new Set(Array.isArray(deps.exclude) ? deps.exclude : []);
-            ['@nativescript/core', 'rxjs', '@valor/nativescript-websockets', 'set-value', 'react', 'react-reconciler', 'react-nativescript'].forEach((x) => exclude.add(x));
-            deps.exclude = Array.from(exclude);
-            const rolldownOptions = (deps.rolldownOptions || (deps.rolldownOptions = {}));
-            rolldownOptions.plugins = [];
+                };
+            },
+            configResolved(resolved) {
+                const resolvedConfig = resolved;
+                const deps = (resolvedConfig.optimizeDeps || (resolvedConfig.optimizeDeps = {}));
+                deps.noDiscovery = true;
+                deps.entries = [];
+                deps.include = [];
+                const exclude = new Set(Array.isArray(deps.exclude) ? deps.exclude : []);
+                ['@nativescript/core', 'rxjs', '@valor/nativescript-websockets', 'set-value', 'react', 'react-reconciler', 'react-nativescript'].forEach((x) => exclude.add(x));
+                deps.exclude = Array.from(exclude);
+                const rolldownOptions = (deps.rolldownOptions || (deps.rolldownOptions = {}));
+                rolldownOptions.plugins = [];
+            },
         },
-    },
-];
+    ];
+}
 export const angularConfig = ({ mode }) => {
+    const useSingleBundleDevOutput = mode === 'development' && !hmrActive;
+    const plugins = createAngularPlugins({
+        // Vite build --watch with the legacy Analog compilation path can regress
+        // Angular app sources from Ivy output back to decorator emit on rebuild.
+        // Restrict the newer compilation API to NativeScript's development no-HMR
+        // flow, which is where the unstable rebuilds occur today.
+        useAngularCompilationAPI: useSingleBundleDevOutput,
+    });
     const disableAnimations = true;
     //process.env.NS_DISABLE_NG_ANIMATIONS === "1" ||
     //process.env.NS_DISABLE_NG_ANIMATIONS === "true";
     // Post-link emitted chunks to catch any remaining partial declarations that slipped through
     // due to plugin order or external transforms.
+    const applyAngularChunkPostProcessing = (code, options = {}) => {
+        const codeWithInjectables = synthesizeMissingInjectableFactories(code, {
+            vendorInjectExport: options.vendorInjectExport,
+        });
+        const codeWithCtorParameters = synthesizeDecoratorCtorParameters(codeWithInjectables);
+        return inlineDecoratorComponentTemplates(codeWithCtorParameters, {
+            projectRoot: process.cwd(),
+        });
+    };
     const postLinker = {
         name: 'ns-angular-linker-post',
         apply: 'build',
@@ -206,13 +371,22 @@ export const angularConfig = ({ mode }) => {
                     return false;
                 return Object.keys(chunk.modules).some((m) => m.includes('node_modules/@nativescript/angular/fesm2022/nativescript-angular-polyfills.mjs'));
             }
-            const { babel, linkerPlugin } = await ensureSharedAngularLinker(process.cwd());
-            if (!babel || !linkerPlugin)
+            const { babel } = await ensureSharedAngularLinker(process.cwd());
+            if (!babel)
+                return;
+            const fileSystem = await resolveAngularFileSystem(process.cwd());
+            const linkerFactory = await importLinkerFactory();
+            if (!linkerFactory)
                 return;
             const strict = process.env.NS_STRICT_NG_LINK === '1' || process.env.NS_STRICT_NG_LINK === 'true';
             const enforceStrict = process.env.NS_STRICT_NG_LINK_ENFORCE === '1' || process.env.NS_STRICT_NG_LINK_ENFORCE === 'true';
             const debug = process.env.VITE_DEBUG_LOGS === '1' || process.env.VITE_DEBUG_LOGS === 'true';
             const unlinked = [];
+            const vendorInjectExport = (() => {
+                const vendorChunk = Object.entries(bundle).find(([name, value]) => value && value.type === 'chunk' && /(^|\/)vendor\.mjs$/.test(name));
+                const vendorCode = vendorChunk ? vendorChunk[1].code : undefined;
+                return vendorCode?.match(/\binject as ([A-Za-z_$][\w$]*)/)?.[1];
+            })();
             for (const [fileName, chunk] of Object.entries(bundle)) {
                 if (!fileName.endsWith('.mjs') && !fileName.endsWith('.js'))
                     continue;
@@ -222,15 +396,19 @@ export const angularConfig = ({ mode }) => {
                         continue;
                     const isNsPolyfills = isNsAngularPolyfillsChunk(chunk);
                     try {
+                        // Create a FRESH linker plugin per chunk — the linker may have
+                        // internal state that becomes stale across watch-mode rebuild cycles.
+                        const freshPlugin = linkerFactory({ sourceMapping: false, fileSystem });
                         const res = await babel.transformAsync(code, {
                             filename: fileName,
                             configFile: false,
                             babelrc: false,
                             sourceMaps: false,
                             compact: false,
-                            plugins: [linkerPlugin],
+                            plugins: [freshPlugin],
                         });
-                        const finalCode = res?.code && res.code !== code ? res.code : code;
+                        const linkedCode = res?.code && res.code !== code ? res.code : code;
+                        const finalCode = applyAngularChunkPostProcessing(linkedCode, { vendorInjectExport });
                         if (finalCode !== code) {
                             chunk.code = finalCode;
                             if (debug) {
@@ -244,7 +422,8 @@ export const angularConfig = ({ mode }) => {
                             unlinked.push(fileName);
                         }
                     }
-                    catch {
+                    catch (e) {
+                        console.warn(`[ns-angular-linker][post] linking FAILED for ${fileName}:`, e?.message || e);
                         if (strict)
                             unlinked.push(fileName);
                     }
@@ -290,37 +469,46 @@ export const angularConfig = ({ mode }) => {
             }
         },
     };
-    // Safety net: transform each rendered chunk to link any remaining ɵɵngDeclare* call sites
+    // Safety net: transform each rendered chunk to link any remaining ɵɵngDeclare* call sites.
+    // IMPORTANT: create a FRESH linker plugin per invocation — the shared instance may have
+    // stale internal state from a prior build cycle, causing silent failures in watch-mode rebuilds.
     const renderChunkLinker = {
         name: 'ns-angular-linker-render',
         apply: 'build',
         enforce: 'post',
         async renderChunk(code, chunk) {
+            if (!code)
+                return null;
+            const filename = chunk.fileName || chunk.name || 'chunk.mjs';
+            const debug = process.env.VITE_DEBUG_LOGS === '1' || process.env.VITE_DEBUG_LOGS === 'true';
             try {
-                if (!code)
-                    return null;
-                if (!containsRealNgDeclare(code))
-                    return null;
-                const { babel, linkerPlugin } = await ensureSharedAngularLinker(process.cwd());
-                if (!babel || !linkerPlugin)
-                    return null;
-                const filename = chunk.fileName || chunk.name || 'chunk.mjs';
-                const debug = process.env.VITE_DEBUG_LOGS === '1' || process.env.VITE_DEBUG_LOGS === 'true';
-                const runLink = async (input) => {
-                    const result = await babel.transformAsync(input, {
-                        filename,
-                        configFile: false,
-                        babelrc: false,
-                        sourceMaps: false,
-                        compact: false,
-                        plugins: [linkerPlugin],
-                    });
-                    return result?.code ?? input;
-                };
-                let transformed = await runLink(code);
-                if (containsRealNgDeclare(transformed)) {
-                    transformed = await runLink(transformed);
+                let transformed = code;
+                if (containsRealNgDeclare(code)) {
+                    const { babel } = await ensureSharedAngularLinker(process.cwd());
+                    if (!babel)
+                        return null;
+                    const fileSystem = await resolveAngularFileSystem(process.cwd());
+                    // Fresh plugin per chunk — avoids stale linker state across watch-mode rebuilds
+                    const freshPlugin = (await importLinkerFactory())?.({ sourceMapping: false, fileSystem });
+                    if (!freshPlugin)
+                        return null;
+                    const runLink = async (input) => {
+                        const result = await babel.transformAsync(input, {
+                            filename,
+                            configFile: false,
+                            babelrc: false,
+                            sourceMaps: false,
+                            compact: false,
+                            plugins: [freshPlugin],
+                        });
+                        return result?.code ?? input;
+                    };
+                    transformed = await runLink(code);
+                    if (containsRealNgDeclare(transformed)) {
+                        transformed = await runLink(transformed);
+                    }
                 }
+                transformed = applyAngularChunkPostProcessing(transformed);
                 if (transformed !== code) {
                     if (debug) {
                         try {
@@ -331,40 +519,42 @@ export const angularConfig = ({ mode }) => {
                     return { code: transformed, map: null };
                 }
             }
-            catch { }
+            catch (e) {
+                console.warn(`[ns-angular-linker][render] linking FAILED for ${filename}:`, e?.message || e);
+            }
             return null;
         },
     };
     const enableRollupLinker = process.env.NS_ENABLE_ROLLUP_LINKER === '1' || process.env.NS_ENABLE_ROLLUP_LINKER === 'true' || hmrActive;
-    return mergeConfig(baseConfig({ mode, flavor: 'angular' }), {
+    // Build a single merged alias array to avoid property override conflicts.
+    // Previously the disableAnimations spread added a second `resolve` key
+    // that silently clobbered the fesm2022 and RxJS aliases.
+    const angularAliases = [
+        // Map Angular deep ESM paths to bare package ids
+        { find: /^@angular\/([^/]+)\/fesm2022\/.*\.mjs$/, replacement: '@angular/$1' },
+        { find: /^@nativescript\/angular\/fesm2022\/.*\.mjs$/, replacement: '@nativescript/angular' },
+        // RxJS esm5 → esm redirects removed: Vite 8 enforces the rxjs `exports` field,
+        // blocking deep path aliases. Instead, the `es2015` resolve condition is added
+        // below so rxjs resolves to its modern ESM builds via the exports map.
+    ];
+    if (disableAnimations) {
+        angularAliases.push({
+            find: /^@angular\/animations(\/.+)?$/, // match subpaths too
+            replacement: resolveRelativeToImportMeta(import.meta.url, '../shims/angular-animations-stub.js'),
+        }, {
+            find: /^@angular\/platform-browser\/animations(\/.+)?$/,
+            replacement: resolveRelativeToImportMeta(import.meta.url, '../shims/angular-animations-stub.js'),
+        });
+    }
+    const config = mergeConfig(baseConfig({ mode, flavor: 'angular' }), {
         plugins: [...plugins, ...(enableRollupLinker ? [angularRollupLinker(process.cwd())] : []), renderChunkLinker, postLinker],
-        // Always alias fesm2022 deep imports to package root so vendor bridge can externalize properly
         resolve: {
-            alias: [
-                // Map Angular deep ESM paths to bare package ids
-                { find: /^@angular\/([^/]+)\/fesm2022\/.*\.mjs$/, replacement: '@angular/$1' },
-                { find: /^@nativescript\/angular\/fesm2022\/.*\.mjs$/, replacement: '@nativescript/angular' },
-                // Prefer modern RxJS builds; avoid esm5 which explodes module count and memory
-                { find: /^rxjs\/dist\/esm5\/(.*)$/, replacement: 'rxjs/dist/esm2015/$1' },
-                { find: /^rxjs\/operators$/, replacement: 'rxjs/dist/esm2015/operators/index.js' },
-                { find: /^rxjs$/, replacement: 'rxjs/dist/esm2015/index.js' },
-                // Existing optional animations shims
-            ],
+            alias: angularAliases,
+            // Add 'es2015' condition so RxJS resolves to dist/esm (modern ESM) rather
+            // than dist/esm5 via the 'default' condition. This avoids the esm5 module
+            // explosion and OOM while respecting the package's exports field in Vite 8.
+            conditions: ['es2015'],
         },
-        ...(disableAnimations && {
-            resolve: {
-                alias: [
-                    {
-                        find: /^@angular\/animations(\/.+)?$/, // match subpaths too
-                        replacement: new URL('../shims/angular-animations-stub.js', import.meta.url).pathname,
-                    },
-                    {
-                        find: /^@angular\/platform-browser\/animations(\/.+)?$/,
-                        replacement: new URL('../shims/angular-animations-stub.js', import.meta.url).pathname,
-                    },
-                ],
-            },
-        }),
         // Disable dependency optimization entirely for NativeScript Angular HMR.
         // Vite 5.1+: use noDiscovery with an empty include list (disabled was removed).
         // The HTTP loader + vendor bridge manage dependencies; pre-bundling can OOM.
@@ -376,5 +566,19 @@ export const angularConfig = ({ mode }) => {
             rolldownOptions: { plugins: [] },
         },
     });
+    if (useSingleBundleDevOutput) {
+        const build = (config.build ?? (config.build = {}));
+        const rolldownOptions = (build.rolldownOptions ?? (build.rolldownOptions = {}));
+        const outputConfigs = Array.isArray(rolldownOptions.output) ? rolldownOptions.output : [rolldownOptions.output ?? {}];
+        for (const output of outputConfigs) {
+            // Angular non-HMR reloads are more reliable when rebuilds keep a single boot bundle.
+            // This avoids watch-time chunk alias/name drift that can leave the native app reloading into stale split points.
+            delete output.manualChunks;
+            delete output.chunkFileNames;
+            output.codeSplitting = false;
+        }
+        rolldownOptions.output = Array.isArray(rolldownOptions.output) ? outputConfigs : outputConfigs[0];
+    }
+    return config;
 };
 //# sourceMappingURL=angular.js.map