@blotch/rsbuild-plugin-angular-lynx 22.2.1 → 22.2.2

package/dist/index.js

@@ -1,23 +1,31 @@
 /*! LICENSE: index.js.LICENSE.txt */
 import node_fs, { existsSync } from "node:fs";
 import node_path, { join, resolve } from "node:path";
-import { DiagnosticModes, createAngularCompilation } from "@angular/build/src/tools/angular/compilation";
-import { JavaScriptTransformer } from "@angular/build/src/tools/javascript-transformer";
+import { CSSPlugins, LynxEncodePlugin, LynxTemplatePlugin, WebEncodePlugin } from "@lynx-js/template-webpack-plugin";
+import { RuntimeWrapperWebpackPlugin } from "@lynx-js/runtime-wrapper-webpack-plugin";
+import { RuntimeGlobals } from "@lynx-js/webpack-runtime-globals";
+import tiny_invariant from "tiny-invariant";
 import { createHash } from "node:crypto";
 import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
 import { availableParallelism } from "node:os";
-import node_assert from "node:assert";
-import { access, constants } from "node:fs/promises";
 import { workspaces } from "@angular-devkit/core";
 import { NodeJsSyncHost } from "@angular-devkit/core/node";
-import { CSSPlugins, LynxEncodePlugin, LynxTemplatePlugin, WebEncodePlugin } from "@lynx-js/template-webpack-plugin";
-import { RuntimeWrapperWebpackPlugin } from "@lynx-js/runtime-wrapper-webpack-plugin";
-import { RuntimeGlobals } from "@lynx-js/webpack-runtime-globals";
-import tiny_invariant from "tiny-invariant";
+import { access, constants } from "node:fs/promises";
 import node_http from "node:http";
 import { pluginTailwindCSS } from "rsbuild-plugin-tailwindcss";
 import * as __rspack_external_typescript from "typescript";
 import * as __rspack_external_node_path_c5b9b54f from "node:path";
+const ANGULAR_CLI_CONTEXT = Symbol.for('@blotch/rsbuild-plugin-angular-lynx:angular-cli-context');
+const ANGULAR_CLI_CONTEXT_PLUGIN_NAME = 'lynx:angular-cli-context';
+const pluginAngularCliContext = (context)=>({
+        name: ANGULAR_CLI_CONTEXT_PLUGIN_NAME,
+        enforce: 'pre',
+        setup: (api)=>{
+            api.expose(ANGULAR_CLI_CONTEXT, context);
+        }
+    });
+const getAngularCliContext = (api)=>api.useExposed(ANGULAR_CLI_CONTEXT);
 const TYPESCRIPT_FILE = /\.[cm]?tsx?$/;
 const readFileVersion = (file)=>node_fs.statSync(file, {
         throwIfNoEntry: false
@@ -76,200 +84,817 @@ const createAngularRebuildCoordinator = ({ compile, getFileVersion = readFileVer
         }
     };
 };
-const injectLynxSchema = (source)=>{
-    if (source.includes('CUSTOM_ELEMENTS_SCHEMA') || source.includes('NO_ERRORS_SCHEMA')) return source;
-    const importLine = `import { CUSTOM_ELEMENTS_SCHEMA as __LynxCES__ } from '@angular/core';\n`;
-    const patched = source.replace(/@Component\s*\(\s*\{/g, '@Component({ schemas: [__LynxCES__],');
-    if (patched === source) return source;
-    return importLine + patched;
-};
-const stripTemplateWhitespace = (source)=>source.replace(/(?<=>)[ \t]*\n[ \t]*([^\n<]+?)[ \t]*\n[ \t]*(?=<)/g, '$1');
-const buildLynxSchemaSourceFileCache = (tsconfig, shouldInclude = ()=>true)=>{
-    const sourceFileCache = new Map();
-    let fileNames;
-    try {
-        const configFile = __rspack_external_typescript.readConfigFile(tsconfig, (p)=>node_fs.readFileSync(p, 'utf-8'));
-        const parsedConfig = __rspack_external_typescript.parseJsonConfigFileContent(configFile.config, __rspack_external_typescript.sys, node_path.dirname(tsconfig));
-        fileNames = parsedConfig.fileNames;
-    } catch  {
-        return {
-            sourceFileCache,
-            fileNames: []
-        };
-    }
-    for (const filePath of fileNames){
-        if (filePath.includes('node_modules')) continue;
-        if (!shouldInclude(filePath)) continue;
-        let source;
-        try {
-            source = node_fs.readFileSync(filePath, 'utf-8');
-        } catch  {
-            continue;
-        }
-        if (!source.includes('@Component')) continue;
-        const transformed = stripTemplateWhitespace(injectLynxSchema(source));
-        sourceFileCache.set(filePath, __rspack_external_typescript.createSourceFile(filePath, transformed, __rspack_external_typescript.ScriptTarget.Latest, true));
-    }
-    return {
-        sourceFileCache,
-        fileNames
-    };
+const LAYERS = {
+    BACKGROUND: 'background',
+    MAIN_THREAD: 'main'
 };
-const generateComponentScopeId = (className, containingFile)=>{
-    const hash = createHash('sha256').update(`${className}|${containingFile}`).digest('hex').slice(0, 10);
-    return `l${hash}`;
+const applyLayers = (api)=>{
+    api.modifyBundlerChain((chain)=>{
+        chain.module.rule("typescript").oneOf(LAYERS.BACKGROUND).layer(LAYERS.BACKGROUND).test(/\.[cm]?[jt]sx?$/).use('builtin:swc-loader').loader('builtin:swc-loader').options({
+            jsc: {
+                target: 'es2015',
+                parser: {
+                    syntax: "typescript"
+                }
+            }
+        }).end();
+        chain.module.rule("typescript").oneOf(LAYERS.MAIN_THREAD).layer(LAYERS.MAIN_THREAD).test(/\.[cm]?[jt]sx?$/).use('builtin:swc-loader').loader('builtin:swc-loader').options({
+            jsc: {
+                target: 'es2019',
+                parser: {
+                    syntax: "typescript"
+                }
+            }
+        }).end();
+    });
 };
-const createTransformStylesheet = (params)=>{
-    const { basePath, scopedCssCacheDir, componentStylesCache, componentScopeIds, onStylesheetWritten } = params;
-    return async (data, containingFile, stylesheetFile, order, className)=>{
-        const resolvedClassName = className ?? 'Component';
-        const scopeId = generateComponentScopeId(resolvedClassName, containingFile);
-        let componentStyles = componentStylesCache.get(containingFile);
-        if (!componentStyles) {
-            componentStyles = {
-                imports: [],
-                inlineStyles: [],
-                scopeId,
-                processedFiles: new Map()
-            };
-            componentStylesCache.set(containingFile, componentStyles);
-        }
-        const stylesheetKey = stylesheetFile ?? `__inline_${order}`;
-        const previousPath = componentStyles.processedFiles.get(stylesheetKey);
-        if (previousPath && !className) return '';
-        if (className || !componentScopeIds.has(containingFile)) componentScopeIds.set(containingFile, {
-            className: resolvedClassName,
-            scopeId
-        });
-        const scopedCss = data;
-        const writeIfChanged = (filePath, content)=>{
-            try {
-                if (node_fs.readFileSync(filePath, 'utf-8') === content) return;
-            } catch  {}
-            node_fs.writeFileSync(filePath, content);
-            onStylesheetWritten?.(filePath);
-        };
-        let scopedPath;
-        if (stylesheetFile) {
-            const relName = node_path.relative(basePath, stylesheetFile);
-            scopedPath = node_path.join(scopedCssCacheDir, `${relName.replace(/[/\\]/g, '__')}.__scoped_${scopeId}.css`);
-        } else {
-            const relDir = node_path.relative(basePath, node_path.dirname(containingFile));
-            scopedPath = node_path.join(scopedCssCacheDir, `${relDir.replace(/[/\\]/g, '__')}__inline_${resolvedClassName}_${order}.__scoped_${scopeId}.css`);
+const createLynxProcessEvalResultRuntimeModule = (webpack)=>class extends webpack.RuntimeModule {
+        constructor(){
+            super('Lynx process eval result', webpack.RuntimeModule.STAGE_ATTACH);
         }
-        writeIfChanged(scopedPath, scopedCss);
-        if (previousPath) {
-            const idx = componentStyles.imports.indexOf(previousPath);
-            if (idx >= 0) componentStyles.imports[idx] = scopedPath;
-            else componentStyles.imports.push(scopedPath);
-            if (previousPath !== scopedPath) try {
-                node_fs.unlinkSync(previousPath);
-            } catch  {}
-        } else componentStyles.imports.push(scopedPath);
-        componentStyles.processedFiles.set(stylesheetKey, scopedPath);
-        return '';
-    };
-};
-const isLynxUnknownElementMessage = (text)=>(text?.includes('is not a known element') || text?.includes("isn't a known property of")) ?? false;
-const seedCompilationSourceFiles = (compilation, sourceFileCache)=>{
-    const { sourceFiles } = compilation;
-    if (!(sourceFiles instanceof Map)) return false;
-    for (const [fileName, sourceFile] of sourceFileCache)sourceFiles.set(fileName, sourceFile);
-    return true;
-};
-const MAIN_THREAD_DIRECTIVE = 'main thread';
-const MAIN_THREAD_DIRECTIVE_ALT = 'main-thread';
-const transformWorklets = (code, filename)=>{
-    if (!code.includes(MAIN_THREAD_DIRECTIVE) && !code.includes(MAIN_THREAD_DIRECTIVE_ALT)) return code;
-    const sourceFile = __rspack_external_typescript.createSourceFile(filename, code, __rspack_external_typescript.ScriptTarget.Latest, true);
-    const workletRanges = [];
-    visitNode(sourceFile, sourceFile, workletRanges);
-    if (0 === workletRanges.length) return code;
-    let result = code;
-    for(let i = workletRanges.length - 1; i >= 0; i--){
-        const { start, end } = workletRanges[i];
-        const fnText = result.slice(start, end);
-        result = result.slice(0, start) + `mainThreadFn(${fnText})` + result.slice(end);
-    }
-    result = `import { mainThreadFn } from '@blotch/angular-lynx';\n` + result;
-    return result;
-};
-const visitNode = (node, sourceFile, ranges)=>{
-    if (__rspack_external_typescript.isArrowFunction(node) || __rspack_external_typescript.isFunctionExpression(node)) {
-        if (hasMainThreadDirective(node) && !isAlreadyWrapped(node)) return void ranges.push({
-            start: node.getStart(sourceFile),
-            end: node.getEnd()
-        });
+        generate() {
+            const chunk = this.chunk;
+            const compilation = this.compilation;
+            if (!chunk || !compilation) return '';
+            const chunkGroup = chunk._groupsIterable?.[0];
+            const modules = compilation.chunkGraph?.getChunkModules(chunk) ?? [];
+            modules.sort((a, b)=>{
+                const aIdx = chunkGroup?.getModulePreOrderIndex(a) ?? 0;
+                const bIdx = chunkGroup?.getModulePreOrderIndex(b) ?? 0;
+                return aIdx - bIdx;
+            });
+            const sortedIds = modules.map((m)=>compilation.chunkGraph.getModuleId(m)).filter((id)=>null != id);
+            const moduleOrder = JSON.stringify(sortedIds);
+            return `
+${RuntimeGlobals.lynxProcessEvalResult} = function (result, schema) {
+  var chunk = result && result(schema);
+  if (chunk && chunk.ids && chunk.modules) {
+    ${webpack.RuntimeGlobals.externalInstallChunk}(chunk);
+    var moduleOrder = ${moduleOrder};
+    for (var i = 0; i < moduleOrder.length; i++) {
+      if (chunk.modules[moduleOrder[i]]) {
+        ${webpack.RuntimeGlobals.require}(moduleOrder[i]);
+      }
     }
-    __rspack_external_typescript.forEachChild(node, (child)=>visitNode(child, sourceFile, ranges));
-};
-const hasMainThreadDirective = (node)=>{
-    const body = node.body;
-    if (!__rspack_external_typescript.isBlock(body)) return false;
-    if (0 === body.statements.length) return false;
-    const first = body.statements[0];
-    if (!__rspack_external_typescript.isExpressionStatement(first)) return false;
-    const expr = first.expression;
-    if (!__rspack_external_typescript.isStringLiteral(expr)) return false;
-    const text = expr.text;
-    return text === MAIN_THREAD_DIRECTIVE || text === MAIN_THREAD_DIRECTIVE_ALT;
-};
-const isAlreadyWrapped = (node)=>{
-    const parent = node.parent;
-    if (!parent || !__rspack_external_typescript.isCallExpression(parent)) return false;
-    const callee = parent.expression;
-    if (__rspack_external_typescript.isIdentifier(callee) && 'mainThreadFn' === callee.text) return true;
-    if (__rspack_external_typescript.isPropertyAccessExpression(callee) && 'mainThreadFn' === callee.name.text) return true;
-    return false;
-};
-const buildTransformedCode = (params)=>{
-    const { resourcePath, componentStyles, scopeInfo } = params;
-    let code = params.code;
-    if (componentStyles) {
-        const { imports } = componentStyles;
-        let importsString = '';
-        for(let i = 0; i < imports.length; ++i){
-            let relativeImport = node_path.relative(node_path.dirname(resourcePath), imports[i]);
-            if (!relativeImport.startsWith('.')) relativeImport = `./${relativeImport}`;
-            importsString += `import "${relativeImport}";`;
+    return chunk;
+  }
+  return chunk
+}
+`;
         }
-        code = importsString + code;
+    };
+class AngularWebpackPlugin {
+    options;
+    constructor(options){
+        this.options = options;
     }
-    if (scopeInfo) code += `\n;${scopeInfo.className}.ɵcmp.id = '${scopeInfo.scopeId}';\n`;
-    return transformWorklets(code, resourcePath);
-};
-const applyAngularConfig = (api, buildOptions)=>{
-    const __dirname = node_path.dirname(fileURLToPath(import.meta.url));
-    api.modifyRsbuildConfig((config)=>{
-        config.output = config.output ?? {};
-        if (buildOptions.outputPath) config.output.distPath = {
-            ...'object' == typeof config.output.distPath ? config.output.distPath : {},
-            root: buildOptions.outputPath
-        };
-        config.output.cleanDistPath = true;
-        config.source ??= {};
-        if ('string' == typeof config.source.preEntry) config.source.preEntry = [
-            config.source.preEntry
-        ];
-        else config.source.preEntry ??= [];
-        config.source.preEntry.push(node_path.resolve(__dirname, './polyfills'));
-        if (buildOptions.i18n.hasDefinedSourceLocale) config.source.preEntry.push('@angular/localize/init');
-        const polyfills = buildOptions.polyfills;
-        if (polyfills) config.source.preEntry.push(...polyfills);
-        config.source.preEntry.push(...buildOptions.styles);
-        config.source.tsconfigPath = buildOptions.tsconfig;
-        config.source.define ??= {};
-        config.source.define['__LYNX_SOURCE_LOCALE__'] = JSON.stringify(buildOptions.i18n.sourceLocale);
-        const isProd = 'production' === process.env.NODE_ENV || 'production' === config.mode;
-        if (isProd) config.source.define.ngDevMode = false;
-    });
-};
-const isPresent = (variable)=>'string' == typeof variable && '' !== variable;
-const isDisabled = (variable)=>'0' === variable || 'false' === variable.toLowerCase();
-const maxWorkersVariable = process.env.NG_BUILD_MAX_WORKERS;
-const maxWorkers = isPresent(maxWorkersVariable) ? +maxWorkersVariable : Math.min(4, Math.max(availableParallelism() - 1, 1));
-const typeCheckingVariable = process.env.NG_BUILD_TYPE_CHECK;
+    static defaultOptions = Object.freeze({
+        disableCreateSelectorQueryIncompatibleWarning: false,
+        firstScreenSyncTiming: 'immediately',
+        enableSSR: false,
+        isWeb: false,
+        mainThreadChunks: [],
+        extractStr: false,
+        experimental_isLazyBundle: false
+    });
+    apply(compiler) {
+        const options = Object.assign({}, AngularWebpackPlugin.defaultOptions, this.options);
+        if (options.enableSSR && 'jsReady' !== options.firstScreenSyncTiming) options.firstScreenSyncTiming = 'jsReady';
+        const { DefinePlugin, EnvironmentPlugin } = compiler.webpack;
+        new EnvironmentPlugin({
+            DEBUG: null
+        }).apply(compiler);
+        new DefinePlugin({
+            __DEV__: JSON.stringify('development' === compiler.options.mode),
+            __PROFILE__: JSON.stringify('development' === compiler.options.mode),
+            __EXTRACT_STR__: JSON.stringify(Boolean(options.extractStr)),
+            __FIRST_SCREEN_SYNC_TIMING__: JSON.stringify(options.firstScreenSyncTiming),
+            __ENABLE_SSR__: JSON.stringify(options.enableSSR),
+            __WEB__: JSON.stringify(Boolean(options.isWeb)),
+            __DISABLE_CREATE_SELECTOR_QUERY_INCOMPATIBLE_WARNING__: JSON.stringify(options.disableCreateSelectorQueryIncompatibleWarning)
+        }).apply(compiler);
+        compiler.hooks.thisCompilation.tap(this.constructor.name, (compilation)=>{
+            const onceForChunkSet = new WeakSet();
+            compilation.hooks.runtimeRequirementInTree.for(compiler.webpack.RuntimeGlobals.ensureChunkHandlers).tap('VanillaWebpackPlugin', (chunk, runtimeRequirements)=>{
+                runtimeRequirements.add(RuntimeGlobals.lynxProcessEvalResult);
+            });
+            compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.lynxProcessEvalResult).tap('VanillaWebpackPlugin', (chunk)=>{
+                if (onceForChunkSet.has(chunk)) return;
+                onceForChunkSet.add(chunk);
+                const LynxProcessEvalResultRuntimeModule = createLynxProcessEvalResultRuntimeModule(compiler.webpack);
+                compilation.addRuntimeModule(chunk, new LynxProcessEvalResultRuntimeModule());
+            });
+            compilation.hooks.processAssets.tap({
+                name: this.constructor.name,
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
+            }, ()=>{
+                for (const name of options.mainThreadChunks ?? [])this.#updateMainThreadInfo(compilation, name);
+                for (const cg of compilation.chunkGroups.filter((cg)=>!cg.isInitial()).filter((cg)=>cg.origins.every((origin)=>origin.module?.layer === LAYERS.MAIN_THREAD))){
+                    const files = cg.getFiles();
+                    for (const name of files.filter((name)=>name.endsWith('.js')))this.#updateMainThreadInfo(compilation, name);
+                }
+            });
+            {
+                const { ConcatSource } = compiler.webpack.sources;
+                const mainThreadChunkSet = new Set(options.mainThreadChunks ?? []);
+                compilation.hooks.processAssets.tap({
+                    name: `${this.constructor.name}:threadGlobals`,
+                    stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+                }, ()=>{
+                    for (const [name] of Object.entries(compilation.assets).filter(([n])=>n.endsWith('.js'))){
+                        const isMainThread = mainThreadChunkSet.has(name);
+                        const prefix = `globalThis["__MAIN_THREAD__"]=${isMainThread};`;
+                        compilation.updateAsset(name, (old)=>new ConcatSource(prefix, old));
+                    }
+                    if (!options.experimental_isLazyBundle) for (const name of options.mainThreadChunks ?? []){
+                        const asset = compilation.getAsset(name);
+                        if (!asset) continue;
+                        const source = asset.source.source().toString();
+                        const useStrictPrefix = /^(['"])use strict\1;?/.test(source) ? "'use strict';" : '';
+                        compilation.updateAsset(name, (old)=>new ConcatSource(`${useStrictPrefix}var globDynamicComponentEntry=globDynamicComponentEntry||'__Card__';`, old));
+                    }
+                });
+            }
+            const hooks = LynxTemplatePlugin.getLynxTemplatePluginHooks(compilation);
+            const { ConcatSource } = compiler.webpack.sources;
+            hooks.beforeEncode.tap(this.constructor.name, (args)=>{
+                const { encodeData } = args;
+                encodeData.sourceContent.config = {
+                    ...encodeData.sourceContent.config,
+                    enableCSSInlineVariables: true
+                };
+                if (!encodeData.lepusCode.root) return args;
+                if ('card' === encodeData.sourceContent.appType) return args;
+                compilation.updateAsset(encodeData.lepusCode.root.name, (old)=>new ConcatSource(`\
+(function (globDynamicComponentEntry) {
+  const module = { exports: {} }
+  const exports = module.exports
+`, old, `
+  ;return module.exports
+})`));
+                return args;
+            });
+        });
+    }
+    #updateMainThreadInfo(compilation, name) {
+        const asset = compilation.getAsset(name);
+        tiny_invariant(asset, `Should have main thread asset ${name}`);
+        compilation.updateAsset(asset.name, asset.source, {
+            ...asset.info,
+            'lynx:main-thread': true
+        });
+    }
+}
+const S_LYNX_CONFIG = Symbol.for('@lynx-js/rsbuild-plugin:config');
+const PLUGIN_NAME_TEMPLATE = 'lynx:template';
+const PLUGIN_NAME_RUNTIME_WRAPPER = 'lynx:runtime-wrapper';
+const PLUGIN_NAME_ANGULAR = 'lynx:angular';
+const applyEntry = (api, options)=>{
+    const { customCSSInheritanceList, debugInfoOutside, defaultDisplayLinear, enableA11y, enableAccessibilityElement, enableCSSInheritance, enableCSSInvalidation, enableCSSSelector, enableNewGesture, enableRemoveCSSScope, removeDescendantSelectorScope, targetSdkVersion } = options;
+    api.modifyBundlerChain((chain, { environment, isDev })=>{
+        const lynxConfig = api.useExposed(S_LYNX_CONFIG);
+        if (!lynxConfig) throw new Error('No Lynx config exposed. `pluginLynx` has to be applied for the Lynx build engine to be configured.');
+        const isLynx = 'lynx' === environment.name;
+        const isWeb = 'web' === environment.name;
+        const { hmr, liveReload } = environment.config.dev ?? {};
+        const enabledHMR = isDev && !isWeb && false !== hmr;
+        const enabledLiveReload = isDev && !isWeb && false !== liveReload;
+        const entries = chain.entryPoints.entries() ?? {};
+        chain.entryPoints.clear();
+        const mainThreadChunks = [];
+        for (const [entryName, entryPoint] of Object.entries(entries)){
+            const { imports } = getChunks(entryName, entryPoint.values());
+            const templateFilename = lynxConfig.resolveBundleFilename({
+                entryName,
+                platform: environment.name
+            });
+            const lazyBundleFilename = lynxConfig.resolveLazyBundleFilename({
+                platform: environment.name
+            });
+            const mainThreadEntry = `${entryName}__main-thread`;
+            const mainThreadName = node_path.posix.join(`${entryName}/main-thread.js`);
+            const backgroundEntry = entryName;
+            const backgroundThreadName = node_path.posix.join(`${entryName}/background-thread.js`);
+            mainThreadChunks.push(mainThreadName);
+            chain.entry(mainThreadEntry).add({
+                layer: LAYERS.MAIN_THREAD,
+                import: imports,
+                filename: mainThreadName
+            }).end();
+            chain.entry(backgroundEntry).add({
+                layer: LAYERS.BACKGROUND,
+                import: imports,
+                filename: backgroundThreadName
+            }).when(enabledHMR, (entry)=>{
+                entry.prepend({
+                    layer: LAYERS.BACKGROUND,
+                    import: '@rspack/core/hot/dev-server'
+                });
+            }).when(enabledHMR || enabledLiveReload, (entry)=>{
+                entry.prepend({
+                    layer: LAYERS.BACKGROUND,
+                    import: '@lynx-js/webpack-dev-transport/client'
+                });
+            }).end();
+            chain.plugin(`${PLUGIN_NAME_TEMPLATE}-${entryName}`).use(LynxTemplatePlugin, [
+                {
+                    filename: templateFilename,
+                    ...lazyBundleFilename ? {
+                        lazyBundleFilename
+                    } : {},
+                    intermediate: lynxConfig.resolveIntermediateDir({
+                        entryName
+                    }),
+                    chunks: [
+                        mainThreadEntry,
+                        backgroundEntry
+                    ],
+                    cssPlugins: [
+                        CSSPlugins.parserPlugins.removeFunctionWhiteSpace()
+                    ],
+                    customCSSInheritanceList,
+                    debugInfoOutside,
+                    defaultDisplayLinear,
+                    enableAccessibilityElement,
+                    enableCSSInheritance,
+                    enableCSSInvalidation,
+                    enableCSSSelector,
+                    enableNewGesture,
+                    enableRemoveCSSScope,
+                    removeDescendantSelectorScope,
+                    targetSdkVersion,
+                    enableA11y
+                }
+            ]).end();
+        }
+        if (isLynx) {
+            chain.plugin(PLUGIN_NAME_RUNTIME_WRAPPER).use(RuntimeWrapperWebpackPlugin, [
+                {
+                    injectVars (vars) {
+                        return vars.map((name)=>{
+                            if ('Component' === name) return '__Component';
+                            return name;
+                        });
+                    },
+                    targetSdkVersion,
+                    test: /^(?!.*main-thread(?:\.[A-Fa-f0-9]*)?\.js$).*\.js$/
+                }
+            ]).end();
+            chain.plugin(`${LynxEncodePlugin.name}`).use(LynxEncodePlugin, [
+                {}
+            ]).end();
+        }
+        if (isWeb) chain.plugin(`${WebEncodePlugin.name}`).use(WebEncodePlugin, []).end();
+        chain.plugin(PLUGIN_NAME_ANGULAR).after(PLUGIN_NAME_TEMPLATE).use(AngularWebpackPlugin, [
+            {
+                mainThreadChunks,
+                enableSSR: options.enableSSR,
+                isWeb
+            }
+        ]);
+    });
+};
+const getChunks = (entryName, entryValue)=>{
+    const chunks = [
+        entryName
+    ];
+    const imports = [];
+    for (const item of entryValue){
+        if ('string' == typeof item) {
+            imports.push(item);
+            continue;
+        }
+        if (Array.isArray(item)) {
+            imports.push(...imports);
+            continue;
+        }
+        const { dependOn } = item;
+        if (Array.isArray(item.import)) imports.push(...item.import);
+        else imports.push(item.import);
+        if (dependOn) if ('string' == typeof dependOn) chunks.unshift(dependOn);
+        else chunks.unshift(...dependOn);
+    }
+    return {
+        chunks,
+        imports
+    };
+};
+const BYTES_IN_KILOBYTE = 1000;
+const calculateBytes = (input, baseline, factor = 1)=>{
+    const matches = input.trim().match(/^(\d+(?:\.\d+)?)[ \t]*(%|[kmg]?b)?$/i);
+    if (!matches) return NaN;
+    const baselineBytes = baseline && calculateBytes(baseline) || 0;
+    let value = Number(matches[1]);
+    switch(matches[2]?.toLowerCase()){
+        case '%':
+            value = baselineBytes * value / 100;
+            break;
+        case 'kb':
+            value *= BYTES_IN_KILOBYTE;
+            break;
+        case 'mb':
+            value *= BYTES_IN_KILOBYTE * BYTES_IN_KILOBYTE;
+            break;
+        case 'gb':
+            value *= BYTES_IN_KILOBYTE * BYTES_IN_KILOBYTE * BYTES_IN_KILOBYTE;
+            break;
+    }
+    if (0 === baselineBytes) return value;
+    return baselineBytes + value * factor;
+};
+const calculateThresholds = (budget)=>{
+    const thresholds = [];
+    if (budget.maximumWarning) thresholds.push({
+        limit: calculateBytes(budget.maximumWarning, budget.baseline, 1),
+        type: 'maximum',
+        severity: 'warning'
+    });
+    if (budget.maximumError) thresholds.push({
+        limit: calculateBytes(budget.maximumError, budget.baseline, 1),
+        type: 'maximum',
+        severity: 'error'
+    });
+    if (budget.minimumWarning) thresholds.push({
+        limit: calculateBytes(budget.minimumWarning, budget.baseline, -1),
+        type: 'minimum',
+        severity: 'warning'
+    });
+    if (budget.minimumError) thresholds.push({
+        limit: calculateBytes(budget.minimumError, budget.baseline, -1),
+        type: 'minimum',
+        severity: 'error'
+    });
+    if (budget.warning) thresholds.push({
+        limit: calculateBytes(budget.warning, budget.baseline, -1),
+        type: 'minimum',
+        severity: 'warning'
+    }, {
+        limit: calculateBytes(budget.warning, budget.baseline, 1),
+        type: 'maximum',
+        severity: 'warning'
+    });
+    if (budget.error) thresholds.push({
+        limit: calculateBytes(budget.error, budget.baseline, -1),
+        type: 'minimum',
+        severity: 'error'
+    }, {
+        limit: calculateBytes(budget.error, budget.baseline, 1),
+        type: 'maximum',
+        severity: 'error'
+    });
+    return thresholds;
+};
+const formatSize = (size)=>{
+    if (size <= 0) return '0 bytes';
+    const abbreviations = [
+        'bytes',
+        'kB',
+        'MB',
+        'GB'
+    ];
+    const index = Math.floor(Math.log(size) / Math.log(BYTES_IN_KILOBYTE));
+    const roundedSize = size / Math.pow(BYTES_IN_KILOBYTE, index);
+    const fractionDigits = 0 === index ? 0 : 2;
+    return `${roundedSize.toFixed(fractionDigits)} ${abbreviations[index]}`;
+};
+const checkThresholds = (thresholds, size, label)=>thresholds.flatMap(({ limit, type, severity })=>{
+        if ('maximum' === type) return size <= limit ? [] : [
+            {
+                severity,
+                label,
+                message: `${label} exceeded maximum budget. Budget ${formatSize(limit)} was not met by ${formatSize(size - limit)} with a total of ${formatSize(size)}.`
+            }
+        ];
+        return size >= limit ? [] : [
+            {
+                severity,
+                label,
+                message: `${label} failed to meet minimum budget. Budget ${formatSize(limit)} was not met by ${formatSize(limit - size)} with a total of ${formatSize(size)}.`
+            }
+        ];
+    });
+const sum = (sizes)=>sizes.reduce((total, { size })=>total + size, 0);
+const calculateSizes = (budget, assets, componentStyles)=>{
+    switch(budget.type){
+        case 'initial':
+            {
+                const bundles = assets.filter((asset)=>void 0 !== asset.entryName);
+                return bundles.map((asset)=>({
+                        size: asset.size,
+                        label: 1 === bundles.length ? 'bundle initial' : `bundle initial (${asset.entryName})`
+                    }));
+            }
+        case 'bundle':
+            return budget.name ? [
+                {
+                    size: sum(assets.filter((asset)=>asset.entryName === budget.name)),
+                    label: budget.name
+                }
+            ] : [];
+        case 'all':
+            return [
+                {
+                    size: sum(assets),
+                    label: 'total'
+                }
+            ];
+        case 'allScript':
+            return [
+                {
+                    size: sum(assets),
+                    label: "total scripts"
+                }
+            ];
+        case 'any':
+        case 'anyScript':
+            return assets.map((asset)=>({
+                    size: asset.size,
+                    label: asset.name
+                }));
+        case 'anyComponentStyle':
+            return componentStyles.map((style)=>({
+                    ...style
+                }));
+        default:
+            return [];
+    }
+};
+const checkBudgets = (budgets, output)=>budgets.flatMap((budget)=>calculateSizes(budget, output.assets, output.componentStyles).flatMap(({ size, label })=>checkThresholds(calculateThresholds(budget), size, label)));
+const PLUGIN_NAME = 'lynx:angular:budgets';
+const MAIN_THREAD_ENTRY_SUFFIX = '__main-thread';
+const toBudgetError = (failure)=>{
+    const error = new Error(failure.message);
+    error.name = 'error' === failure.severity ? 'AngularBudgetError' : 'AngularBudgetWarning';
+    error.hideStack = true;
+    return error;
+};
+const bundleEntryName = (chunkGroups, entrypoints)=>chunkGroups.map((chunkGroup)=>chunkGroup.name).find((name)=>!!name && entrypoints.has(name) && !name.endsWith(MAIN_THREAD_ENTRY_SUFFIX));
+const collectBudgetAssets = (assets, entryBundles, intermediateDir)=>assets.filter(({ name, info })=>/\.(bundle|js)$/.test(name) && !info.hotModuleReplacement && !(intermediateDir && name.startsWith(`${intermediateDir}/`))).map(({ name, source })=>{
+        const entryName = entryBundles.get(name);
+        return {
+            name,
+            size: source.size(),
+            ...void 0 === entryName ? {} : {
+                entryName
+            }
+        };
+    });
+class AngularBudgetsPlugin {
+    #options;
+    constructor(options){
+        this.#options = options;
+    }
+    apply(compiler) {
+        const { budgets, componentStyleSizes, intermediateDir } = this.#options;
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation)=>{
+            const entryBundles = new Map();
+            LynxTemplatePlugin.getLynxTemplatePluginHooks(compilation).beforeEmit.tap(PLUGIN_NAME, (args)=>{
+                const entryName = bundleEntryName(args.chunkGroups, compilation.entrypoints);
+                if (void 0 !== entryName) entryBundles.set(args.outputName, entryName);
+                return args;
+            });
+            compilation.hooks.processAssets.tap({
+                name: PLUGIN_NAME,
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT + 2
+            }, ()=>{
+                const failures = checkBudgets(budgets, {
+                    assets: collectBudgetAssets(compilation.getAssets(), entryBundles, intermediateDir),
+                    componentStyles: [
+                        ...componentStyleSizes.values()
+                    ]
+                });
+                for (const failure of failures)('error' === failure.severity ? compilation.errors : compilation.warnings).push(toBudgetError(failure));
+            });
+        });
+    }
+}
+const applyBudgets = (api, { budgets, componentStyleSizes, underAngularCli })=>{
+    if (0 === budgets.length) return;
+    if (!underAngularCli && 'dev' === api.context.action) return;
+    api.modifyBundlerChain((chain, { environment })=>{
+        if ('lynx' !== environment.name) return;
+        const lynxConfig = api.useExposed(S_LYNX_CONFIG);
+        chain.plugin(PLUGIN_NAME).use(AngularBudgetsPlugin, [
+            {
+                budgets,
+                componentStyleSizes,
+                intermediateDir: lynxConfig?.resolveIntermediateDir()
+            }
+        ]);
+    });
+};
+const injectLynxSchema = (source)=>{
+    if (source.includes('CUSTOM_ELEMENTS_SCHEMA') || source.includes('NO_ERRORS_SCHEMA')) return source;
+    const importLine = `import { CUSTOM_ELEMENTS_SCHEMA as __LynxCES__ } from '@angular/core';\n`;
+    const patched = source.replace(/@Component\s*\(\s*\{/g, '@Component({ schemas: [__LynxCES__],');
+    if (patched === source) return source;
+    return importLine + patched;
+};
+const stripTemplateWhitespace = (source)=>source.replace(/(?<=>)[ \t]*\n[ \t]*([^\n<]+?)[ \t]*\n[ \t]*(?=<)/g, '$1');
+const buildLynxSchemaSourceFileCache = (tsconfig, shouldInclude = ()=>true)=>{
+    const sourceFileCache = new Map();
+    let fileNames;
+    try {
+        const configFile = __rspack_external_typescript.readConfigFile(tsconfig, (p)=>node_fs.readFileSync(p, 'utf-8'));
+        const parsedConfig = __rspack_external_typescript.parseJsonConfigFileContent(configFile.config, __rspack_external_typescript.sys, node_path.dirname(tsconfig));
+        fileNames = parsedConfig.fileNames;
+    } catch  {
+        return {
+            sourceFileCache,
+            fileNames: []
+        };
+    }
+    for (const filePath of fileNames){
+        if (filePath.includes('node_modules')) continue;
+        if (!shouldInclude(filePath)) continue;
+        let source;
+        try {
+            source = node_fs.readFileSync(filePath, 'utf-8');
+        } catch  {
+            continue;
+        }
+        if (!source.includes('@Component')) continue;
+        const transformed = stripTemplateWhitespace(injectLynxSchema(source));
+        sourceFileCache.set(filePath, __rspack_external_typescript.createSourceFile(filePath, transformed, __rspack_external_typescript.ScriptTarget.Latest, true));
+    }
+    return {
+        sourceFileCache,
+        fileNames
+    };
+};
+const generateComponentScopeId = (className, containingFile)=>{
+    const hash = createHash('sha256').update(`${className}|${containingFile}`).digest('hex').slice(0, 10);
+    return `l${hash}`;
+};
+const componentStyleSizeKey = (containingFile, stylesheetKey)=>`${containingFile}#${stylesheetKey}`;
+const forgetComponentStyleSizes = (componentStyleSizes, containingFile)=>{
+    const prefix = componentStyleSizeKey(containingFile, '');
+    for (const key of componentStyleSizes.keys())if (key.startsWith(prefix)) componentStyleSizes.delete(key);
+};
+const createTransformStylesheet = (params)=>{
+    const { basePath, scopedCssCacheDir, componentStylesCache, componentScopeIds, onStylesheetWritten, componentStyleSizes } = params;
+    return async (data, containingFile, stylesheetFile, order, className)=>{
+        const resolvedClassName = className ?? 'Component';
+        const scopeId = generateComponentScopeId(resolvedClassName, containingFile);
+        let componentStyles = componentStylesCache.get(containingFile);
+        if (!componentStyles) {
+            componentStyles = {
+                imports: [],
+                inlineStyles: [],
+                scopeId,
+                processedFiles: new Map()
+            };
+            componentStylesCache.set(containingFile, componentStyles);
+        }
+        const stylesheetKey = stylesheetFile ?? `__inline_${order}`;
+        const previousPath = componentStyles.processedFiles.get(stylesheetKey);
+        if (previousPath && !className) return '';
+        componentStyleSizes?.set(componentStyleSizeKey(containingFile, stylesheetKey), {
+            label: node_path.relative(basePath, stylesheetFile ?? containingFile).replace(/\\/g, '/'),
+            size: Buffer.byteLength(data)
+        });
+        if (className || !componentScopeIds.has(containingFile)) componentScopeIds.set(containingFile, {
+            className: resolvedClassName,
+            scopeId
+        });
+        const scopedCss = data;
+        const writeIfChanged = (filePath, content)=>{
+            try {
+                if (node_fs.readFileSync(filePath, 'utf-8') === content) return;
+            } catch  {}
+            node_fs.writeFileSync(filePath, content);
+            onStylesheetWritten?.(filePath);
+        };
+        let scopedPath;
+        if (stylesheetFile) {
+            const relName = node_path.relative(basePath, stylesheetFile);
+            scopedPath = node_path.join(scopedCssCacheDir, `${relName.replace(/[/\\]/g, '__')}.__scoped_${scopeId}.css`);
+        } else {
+            const relDir = node_path.relative(basePath, node_path.dirname(containingFile));
+            scopedPath = node_path.join(scopedCssCacheDir, `${relDir.replace(/[/\\]/g, '__')}__inline_${resolvedClassName}_${order}.__scoped_${scopeId}.css`);
+        }
+        writeIfChanged(scopedPath, scopedCss);
+        if (previousPath) {
+            const idx = componentStyles.imports.indexOf(previousPath);
+            if (idx >= 0) componentStyles.imports[idx] = scopedPath;
+            else componentStyles.imports.push(scopedPath);
+            if (previousPath !== scopedPath) try {
+                node_fs.unlinkSync(previousPath);
+            } catch  {}
+        } else componentStyles.imports.push(scopedPath);
+        componentStyles.processedFiles.set(stylesheetKey, scopedPath);
+        return '';
+    };
+};
+const isLynxUnknownElementMessage = (text)=>(text?.includes('is not a known element') || text?.includes("isn't a known property of")) ?? false;
+const filterAngularDiagnostics = (diagnostics)=>({
+        errors: (diagnostics.errors ?? []).filter((message)=>!isLynxUnknownElementMessage(message.text)),
+        warnings: (diagnostics.warnings ?? []).filter((message)=>!isLynxUnknownElementMessage(message.text))
+    });
+const formatLocation = ({ file, line, column })=>{
+    if (!file) return;
+    if (void 0 === line) return file;
+    return `${file}:${line}:${(column ?? 0) + 1}`;
+};
+const formatCodeFrame = ({ line, column, length, lineText })=>{
+    if (void 0 === line || void 0 === lineText) return;
+    const gutter = `${line} | `;
+    const caretIndent = ' '.repeat(gutter.length - 2) + '| ';
+    const caret = ' '.repeat(column ?? 0) + '^'.repeat(Math.max(1, length ?? 1));
+    return `${gutter}${lineText}\n${caretIndent}${caret}`;
+};
+const toAngularDiagnosticError = (message, severity)=>{
+    const sections = [
+        message.text ?? 'Unknown Angular compiler diagnostic'
+    ];
+    const codeFrame = message.location && formatCodeFrame(message.location);
+    if (codeFrame) sections.push(codeFrame);
+    for (const note of message.notes ?? []){
+        const noteLocation = note.location && formatLocation(note.location);
+        sections.push([
+            noteLocation,
+            note.text
+        ].filter((part)=>part).join(': '));
+    }
+    const error = new Error(sections.join('\n\n'));
+    error.name = 'error' === severity ? 'AngularCompilerError' : 'AngularCompilerWarning';
+    const file = message.location && formatLocation(message.location);
+    if (file) error.file = file;
+    error.hideStack = true;
+    return error;
+};
+const seedCompilationSourceFiles = (compilation, sourceFileCache)=>{
+    const { sourceFiles } = compilation;
+    if (!(sourceFiles instanceof Map)) return false;
+    for (const [fileName, sourceFile] of sourceFileCache)sourceFiles.set(fileName, sourceFile);
+    return true;
+};
+const MAIN_THREAD_DIRECTIVE = 'main thread';
+const MAIN_THREAD_DIRECTIVE_ALT = 'main-thread';
+const transformWorklets = (code, filename)=>{
+    if (!code.includes(MAIN_THREAD_DIRECTIVE) && !code.includes(MAIN_THREAD_DIRECTIVE_ALT)) return code;
+    const sourceFile = __rspack_external_typescript.createSourceFile(filename, code, __rspack_external_typescript.ScriptTarget.Latest, true);
+    const workletRanges = [];
+    visitNode(sourceFile, sourceFile, workletRanges);
+    if (0 === workletRanges.length) return code;
+    let result = code;
+    for(let i = workletRanges.length - 1; i >= 0; i--){
+        const { start, end } = workletRanges[i];
+        const fnText = result.slice(start, end);
+        result = result.slice(0, start) + `mainThreadFn(${fnText})` + result.slice(end);
+    }
+    result = `import { mainThreadFn } from '@blotch/angular-lynx';\n` + result;
+    return result;
+};
+const visitNode = (node, sourceFile, ranges)=>{
+    if (__rspack_external_typescript.isArrowFunction(node) || __rspack_external_typescript.isFunctionExpression(node)) {
+        if (hasMainThreadDirective(node) && !isAlreadyWrapped(node)) return void ranges.push({
+            start: node.getStart(sourceFile),
+            end: node.getEnd()
+        });
+    }
+    __rspack_external_typescript.forEachChild(node, (child)=>visitNode(child, sourceFile, ranges));
+};
+const hasMainThreadDirective = (node)=>{
+    const body = node.body;
+    if (!__rspack_external_typescript.isBlock(body)) return false;
+    if (0 === body.statements.length) return false;
+    const first = body.statements[0];
+    if (!__rspack_external_typescript.isExpressionStatement(first)) return false;
+    const expr = first.expression;
+    if (!__rspack_external_typescript.isStringLiteral(expr)) return false;
+    const text = expr.text;
+    return text === MAIN_THREAD_DIRECTIVE || text === MAIN_THREAD_DIRECTIVE_ALT;
+};
+const isAlreadyWrapped = (node)=>{
+    const parent = node.parent;
+    if (!parent || !__rspack_external_typescript.isCallExpression(parent)) return false;
+    const callee = parent.expression;
+    if (__rspack_external_typescript.isIdentifier(callee) && 'mainThreadFn' === callee.text) return true;
+    if (__rspack_external_typescript.isPropertyAccessExpression(callee) && 'mainThreadFn' === callee.name.text) return true;
+    return false;
+};
+const buildTransformedCode = (params)=>{
+    const { resourcePath, componentStyles, scopeInfo } = params;
+    let code = params.code;
+    if (componentStyles) {
+        const { imports } = componentStyles;
+        let importsString = '';
+        for(let i = 0; i < imports.length; ++i){
+            let relativeImport = node_path.relative(node_path.dirname(resourcePath), imports[i]);
+            if (!relativeImport.startsWith('.')) relativeImport = `./${relativeImport}`;
+            importsString += `import "${relativeImport}";`;
+        }
+        code = importsString + code;
+    }
+    if (scopeInfo) code += `\n;${scopeInfo.className}.ɵcmp.id = '${scopeInfo.scopeId}';\n`;
+    return transformWorklets(code, resourcePath);
+};
+const applyAngularConfig = (api, buildOptions)=>{
+    const __dirname = node_path.dirname(fileURLToPath(import.meta.url));
+    api.modifyRsbuildConfig((config)=>{
+        config.output = config.output ?? {};
+        if (buildOptions.outputPath) config.output.distPath = {
+            ...'object' == typeof config.output.distPath ? config.output.distPath : {},
+            root: buildOptions.outputPath
+        };
+        config.output.cleanDistPath = true;
+        config.source ??= {};
+        if ('string' == typeof config.source.preEntry) config.source.preEntry = [
+            config.source.preEntry
+        ];
+        else config.source.preEntry ??= [];
+        config.source.preEntry.push(node_path.resolve(__dirname, './polyfills'));
+        if (buildOptions.i18n.hasDefinedSourceLocale) config.source.preEntry.push('@angular/localize/init');
+        const polyfills = buildOptions.polyfills;
+        if (polyfills) config.source.preEntry.push(...polyfills);
+        config.source.preEntry.push(...buildOptions.styles);
+        config.source.tsconfigPath = buildOptions.tsconfig;
+        config.source.define ??= {};
+        config.source.define['__LYNX_SOURCE_LOCALE__'] = JSON.stringify(buildOptions.i18n.sourceLocale);
+        const isProd = 'production' === process.env.NODE_ENV || 'production' === config.mode;
+        if (isProd) config.source.define.ngDevMode = false;
+    });
+};
+const build_internals_require = createRequire(import.meta.url);
+const angularBuildRoot = node_path.dirname(build_internals_require.resolve('@angular/build/package.json'));
+const loadAngularBuildInternal = (subpath)=>build_internals_require(node_path.join(angularBuildRoot, subpath));
+const { createAngularCompilation: createAngularCompilation, DiagnosticModes: DiagnosticModes } = loadAngularBuildInternal('src/tools/angular/compilation');
+const { JavaScriptTransformer: JavaScriptTransformer } = loadAngularBuildInternal("src/tools/javascript-transformer");
+const { ComponentStylesheetBundler: ComponentStylesheetBundler } = loadAngularBuildInternal('src/tools/esbuild/angular/component-stylesheets');
+const isPresent = (variable)=>'string' == typeof variable && '' !== variable;
+const isDisabled = (variable)=>'0' === variable || 'false' === variable.toLowerCase();
+const maxWorkersVariable = process.env.NG_BUILD_MAX_WORKERS;
+const maxWorkers = isPresent(maxWorkersVariable) ? +maxWorkersVariable : Math.min(4, Math.max(availableParallelism() - 1, 1));
+const typeCheckingVariable = process.env.NG_BUILD_TYPE_CHECK;
 const useTypeChecking = !isPresent(typeCheckingVariable) || !isDisabled(typeCheckingVariable);
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */ const findUp = (names, from)=>{
+    const namesList = Array.isArray(names) ? names : [
+        names
+    ];
+    const root = __rspack_external_node_path_c5b9b54f.parse(from).root;
+    let currentDir = from;
+    while(currentDir && currentDir !== root){
+        for (const name of namesList){
+            const p = __rspack_external_node_path_c5b9b54f.join(currentDir, name);
+            if (existsSync(p)) return p;
+        }
+        currentDir = __rspack_external_node_path_c5b9b54f.dirname(currentDir);
+    }
+    return null;
+};
+const configNames = [
+    'angular.json',
+    '.angular.json'
+];
+const getAngularWorkspace = async (from = process.cwd())=>{
+    const host = workspaces.createWorkspaceHost(new NodeJsSyncHost());
+    const workspaceFile = findUp(configNames, from);
+    if (!workspaceFile) throw new Error("couldn't find workspace file");
+    const { workspace } = await workspaces.readWorkspace(workspaceFile, host);
+    return {
+        basePath: node_path.dirname(workspaceFile),
+        workspace
+    };
+};
+const findProjectByPath = (workspace, location, basePath)=>{
+    const isInside = (base, potential)=>{
+        const absoluteBase = node_path.resolve(basePath, base);
+        const absolutePotential = node_path.resolve(basePath, potential);
+        const relativePotential = node_path.relative(absoluteBase, absolutePotential);
+        if (!relativePotential.startsWith('..') && !node_path.isAbsolute(relativePotential)) return true;
+        return false;
+    };
+    const projects = Array.from(workspace.projects).map(([name, project])=>[
+            project.root,
+            name
+        ]).filter((tuple)=>isInside(tuple[0], location)).sort((a, b)=>b[0].length - a[0].length);
+    if (0 === projects.length) return null;
+    if (projects.length > 1) {
+        const found = new Set();
+        const sameRoots = projects.filter((v)=>{
+            if (!found.has(v[0])) {
+                found.add(v[0]);
+                return false;
+            }
+            return true;
+        });
+        if (sameRoots.length > 0) return null;
+    }
+    return projects[0][1];
+};
+const getProjectByCwd = (workspace, basePath)=>{
+    if (1 === workspace.projects.size) return Array.from(workspace.projects.keys())[0];
+    const project = findProjectByPath(workspace, process.cwd(), basePath);
+    if (project) return project;
+    return null;
+};
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -338,29 +963,37 @@ const normalizeOptimization = (optimization = true)=>{
     };
 };
 const readTarget = (project, target = 'build')=>project.targets.get(target);
-const readBuildOptions = async (project, basePath, configurationName)=>{
+const resolveIndexPath = (index, project, workspaceRoot)=>{
+    if ('boolean' == typeof index) return;
+    if ('string' == typeof index) return node_path.join(workspaceRoot, index);
+    if (index && 'object' == typeof index) return node_path.join(workspaceRoot, index.input);
+    const sourceRoot = project.sourceRoot ?? node_path.join(project.root ?? '', 'src');
+    return node_path.join(workspaceRoot, sourceRoot, 'index.html');
+};
+const resolveOutputPath = (outputPath, workspaceRoot)=>{
+    if ('string' == typeof outputPath) return node_path.join(workspaceRoot, outputPath);
+    if (outputPath && 'object' == typeof outputPath) return node_path.join(workspaceRoot, outputPath.base);
+};
+const readBuildTargetOptions = (project, configurationName)=>{
+    const target = readTarget(project);
+    if (!target) throw new Error("couldn't find target");
+    const resolvedConfigurationName = configurationName ?? target.defaultConfiguration;
+    const buildOptions = target.options;
+    if (!buildOptions) throw new Error(`No build options found for the "${configurationName ?? 'build'}" target in angular.json. Make sure the target has an "options" section with at least "browser" and "tsConfig" defined.`);
+    return {
+        ...buildOptions,
+        ...resolvedConfigurationName ? target.configurations?.[resolvedConfigurationName] : void 0
+    };
+};
+const readBuildOptions = async (project, basePath, configurationName)=>normalizeBuildOptions(readBuildTargetOptions(project, configurationName), project, basePath);
+const normalizeBuildOptions = async (buildOptions, project, basePath)=>{
     const workspaceRoot = basePath;
-    const target = readTarget(project);
-    if (!target) throw new Error("couldn't find target");
-    const resolvedConfigurationName = configurationName ?? target.defaultConfiguration;
-    const buildOptions = target?.options;
-    if (!buildOptions) throw new Error(`No build options found for the "${configurationName ?? 'build'}" target in angular.json. Make sure the target has an "options" section with at least "browser", "tsConfig", and "index" defined.`);
-    const configurations = target.configurations;
-    if (configurations) {
-        for(const name in configurations)if (name === resolvedConfigurationName) {
-            Object.assign(buildOptions, {
-                ...configurations[name]
-            });
-            break;
-        }
-    }
-    node_assert(!!buildOptions, 'build options is undefined');
     const aot = buildOptions.aot ?? true;
     const tsconfig = node_path.join(workspaceRoot, buildOptions.tsConfig);
     const optimizationOptions = normalizeOptimization(buildOptions.optimization);
     const sourcemapOptions = normalizeSourceMaps(buildOptions.sourceMap ?? false);
     const browser = node_path.join(workspaceRoot, buildOptions.browser);
-    const index = node_path.join(workspaceRoot, buildOptions.index);
+    const index = resolveIndexPath(buildOptions.index, project, workspaceRoot);
     let polyfills = buildOptions.polyfills;
     polyfills = void 0 === polyfills || Array.isArray(polyfills) ? polyfills : [
         polyfills
@@ -387,7 +1020,7 @@ const readBuildOptions = async (project, basePath, configurationName)=>{
     const cacheOptions = normalizeCacheOptions(buildOptions.projectMetadata, workspaceRoot);
     const inlineStyleLanguage = buildOptions.inlineStyleLanguage;
     const styles = (buildOptions.styles ?? []).map((stylePath)=>node_path.join(workspaceRoot, stylePath));
-    const outputPath = node_path.join(workspaceRoot, buildOptions.outputPath);
+    const outputPath = resolveOutputPath(buildOptions.outputPath, workspaceRoot);
     const i18n = normalizeI18nOptions(project.extensions['i18n']);
     const i18nMissingTranslation = buildOptions.i18nMissingTranslation ?? 'warning';
     const normalizedOptions = {
@@ -408,7 +1041,8 @@ const readBuildOptions = async (project, basePath, configurationName)=>{
         outputHashing,
         styles,
         i18n,
-        i18nMissingTranslation
+        i18nMissingTranslation,
+        budgets: buildOptions.budgets ?? []
     };
     return normalizedOptions;
 };
@@ -432,73 +1066,20 @@ const normalizeI18nOptions = (raw)=>{
         hasDefinedSourceLocale
     };
 };
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.dev/license
- */ const findUp = (names, from)=>{
-    const namesList = Array.isArray(names) ? names : [
-        names
-    ];
-    const root = __rspack_external_node_path_c5b9b54f.parse(from).root;
-    let currentDir = from;
-    while(currentDir && currentDir !== root){
-        for (const name of namesList){
-            const p = __rspack_external_node_path_c5b9b54f.join(currentDir, name);
-            if (existsSync(p)) return p;
-        }
-        currentDir = __rspack_external_node_path_c5b9b54f.dirname(currentDir);
-    }
-    return null;
-};
-const configNames = [
-    'angular.json',
-    '.angular.json'
-];
-const findWorkspaceFile = ()=>findUp(configNames, process.cwd());
-const getAngularWorkspace = async ()=>{
-    const host = workspaces.createWorkspaceHost(new NodeJsSyncHost());
-    const workspaceFile = findWorkspaceFile();
-    if (!workspaceFile) throw new Error("couldn't find workspace file");
-    const { workspace } = await workspaces.readWorkspace(workspaceFile, host);
+const resolvePrimaryBuild = async ({ workspace, basePath, pages, cli })=>{
+    let projectName;
+    if (pages) {
+        const candidates = 'all' === pages ? Array.from(workspace.projects.entries()).filter(([, project])=>'application' === project.extensions['projectType']).map(([name])=>name) : pages;
+        projectName = cli && candidates.includes(cli.project) ? cli.project : candidates[0] ?? null;
+    } else projectName = cli?.project ?? getProjectByCwd(workspace, basePath);
+    if (!projectName) throw new Error("couldn't find the project");
+    const project = workspace.projects.get(projectName);
+    if (!project) throw new Error(`Project "${projectName}" not found in workspace`);
+    const buildOptions = cli?.project === projectName ? await normalizeBuildOptions(cli.buildOptions, project, basePath) : await readBuildOptions(project, basePath);
     return {
-        basePath: node_path.dirname(workspaceFile),
-        workspace
-    };
-};
-const findProjectByPath = (workspace, location, basePath)=>{
-    const isInside = (base, potential)=>{
-        const absoluteBase = node_path.resolve(basePath, base);
-        const absolutePotential = node_path.resolve(basePath, potential);
-        const relativePotential = node_path.relative(absoluteBase, absolutePotential);
-        if (!relativePotential.startsWith('..') && !node_path.isAbsolute(relativePotential)) return true;
-        return false;
+        projectName,
+        buildOptions
     };
-    const projects = Array.from(workspace.projects).map(([name, project])=>[
-            project.root,
-            name
-        ]).filter((tuple)=>isInside(tuple[0], location)).sort((a, b)=>b[0].length - a[0].length);
-    if (0 === projects.length) return null;
-    if (projects.length > 1) {
-        const found = new Set();
-        const sameRoots = projects.filter((v)=>{
-            if (!found.has(v[0])) {
-                found.add(v[0]);
-                return false;
-            }
-            return true;
-        });
-        if (sameRoots.length > 0) return null;
-    }
-    return projects[0][1];
-};
-const getProjectByCwd = (workspace, basePath)=>{
-    if (1 === workspace.projects.size) return Array.from(workspace.projects.keys())[0];
-    const project = findProjectByPath(workspace, process.cwd(), basePath);
-    if (project) return project;
-    return null;
 };
 const resolvePages = (workspace, basePath, pages)=>{
     const projectNames = 'all' === pages ? Array.from(workspace.projects.entries()).filter(([, def])=>'application' === def.extensions['projectType']).map(([name])=>name) : pages;
@@ -618,668 +1199,393 @@ const collectElementTags = (code)=>{
     const tags = new Set();
     let match;
     let tagMatch;
-    for (const chain of code.matchAll(chainPattern)){
-        tagExtractor.lastIndex = 0;
-        while(null !== (tagMatch = tagExtractor.exec(chain[0])))tags.add(tagMatch[1]);
-    }
-    while(null !== (match = repeaterPattern.exec(code)))tags.add(match[1]);
-    return tags;
-};
-const scanCompiledOutputForHtmlElements = (fileCache)=>{
-    const diagnostics = [];
-    for (const [file, contents] of fileCache){
-        if (file.includes('node_modules')) continue;
-        const code = 'string' == typeof contents ? contents : Buffer.from(contents).toString();
-        const tags = collectElementTags(code);
-        const fileName = node_path.relative(process.cwd(), file);
-        for (const tag of tags){
-            if (!(tag in HTML_ELEMENT_SUGGESTIONS)) continue;
-            const replacement = HTML_ELEMENT_SUGGESTIONS[tag];
-            const message = null !== replacement ? `${fileName}: <${tag}> is not a Lynx element. Use <${replacement}> instead.` : `${fileName}: <${tag}> has no Lynx equivalent and will not render correctly.`;
-            diagnostics.push({
-                file,
-                message,
-                category: 'html-element'
-            });
-        }
-    }
-    return diagnostics;
-};
-const scanSourcesForUnsupportedPatterns = (fileNames)=>{
-    const diagnostics = [];
-    for (const filePath of fileNames){
-        if (filePath.includes('node_modules')) continue;
-        let source;
-        try {
-            source = node_fs.readFileSync(filePath, 'utf-8');
-        } catch  {
-            continue;
-        }
-        if (source.includes('ViewEncapsulation.ShadowDom')) {
-            const fileName = node_path.relative(process.cwd(), filePath);
-            diagnostics.push({
-                file: filePath,
-                message: `${fileName}: ViewEncapsulation.ShadowDom is not supported in Lynx (falls back to None). Use Emulated instead.`,
-                category: 'structural'
-            });
-        }
-    }
-    return diagnostics;
-};
-const scanCompiledOutputForStructuralIssues = (fileCache)=>{
-    const diagnostics = [];
-    for (const [file, contents] of fileCache){
-        if (file.includes('node_modules')) continue;
-        const code = 'string' == typeof contents ? contents : Buffer.from(contents).toString();
-        const tags = collectElementTags(code);
-        const fileName = node_path.relative(process.cwd(), file);
-        if (tags.has('list-item') && !tags.has('list')) diagnostics.push({
-            file,
-            message: `${fileName}: <list-item> used without a <list> parent. Wrap list items in a <list> element.`,
-            category: 'structural'
-        });
-    }
-    return diagnostics;
-};
-const scanSourcesForUnsupportedCss = (fileNames)=>{
-    const diagnostics = [];
-    for (const filePath of fileNames){
-        if (filePath.includes('node_modules')) continue;
-        let source;
-        try {
-            source = node_fs.readFileSync(filePath, 'utf-8');
-        } catch  {
-            continue;
-        }
-        if (!source.includes('@Component')) continue;
-        const cssChunks = [];
-        const stylesBlockMatch = source.match(/styles\s*:\s*\[([\s\S]*?)\]/);
-        if (stylesBlockMatch) {
-            for (const m of stylesBlockMatch[1].matchAll(/`([\s\S]*?)`/g))cssChunks.push(m[1]);
-            if (0 === cssChunks.length) for (const m of stylesBlockMatch[1].matchAll(/(['"])([\s\S]*?)\1/g))cssChunks.push(m[2]);
-        }
-        const styleUrlsMatch = source.match(/styleUrls?\s*:\s*\[([\s\S]*?)\]/);
-        if (styleUrlsMatch) for (const m of styleUrlsMatch[1].matchAll(/['"]([^'"]+)['"]/g)){
-            const stylePath = node_path.resolve(node_path.dirname(filePath), m[1]);
-            try {
-                cssChunks.push(node_fs.readFileSync(stylePath, 'utf-8'));
-            } catch  {}
-        }
-        const seen = new Set();
-        const fileName = node_path.relative(process.cwd(), filePath);
-        for (const css of cssChunks){
-            const withoutComments = css.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*/g, '');
-            const propertyPattern = /(?:^|[{;])\s*([a-z-]+)\s*:/gm;
-            let match;
-            while(null !== (match = propertyPattern.exec(withoutComments))){
-                const property = match[1];
-                if (UNSUPPORTED_CSS[property] && !seen.has(property)) {
-                    seen.add(property);
-                    diagnostics.push({
-                        file: filePath,
-                        message: `${fileName}: '${property}' — ${UNSUPPORTED_CSS[property]}.`,
-                        category: 'css'
-                    });
-                }
-            }
-        }
-    }
-    return diagnostics;
-};
-const reportLynxDiagnostics = (diagnostics)=>{
-    if (0 === diagnostics.length) return;
-    const htmlWarnings = diagnostics.filter((d)=>'html-element' === d.category);
-    const structuralWarnings = diagnostics.filter((d)=>'structural' === d.category);
-    const cssWarnings = diagnostics.filter((d)=>'css' === d.category);
-    if (htmlWarnings.length > 0) {
-        console.warn('[Lynx] HTML elements detected in templates:');
-        for (const w of htmlWarnings)console.warn(`  ${w.message}`);
-    }
-    if (structuralWarnings.length > 0) {
-        console.warn('[Lynx] Structural issues:');
-        for (const w of structuralWarnings)console.warn(`  ${w.message}`);
-    }
-    if (cssWarnings.length > 0) {
-        console.warn('[Lynx] Unsupported CSS properties:');
-        for (const w of cssWarnings)console.warn(`  ${w.message}`);
-    }
-};
-const applyAngularRules = async (api, pluginOptions)=>{
-    const { basePath, workspace } = await getAngularWorkspace();
-    if (pluginOptions.pages) {
-        const pages = resolvePages(workspace, basePath, pluginOptions.pages);
-        api.modifyRsbuildConfig((config)=>{
-            config.source ??= {};
-            config.source.entry = Object.fromEntries(pages.map((page)=>[
-                    page.name,
-                    page.browser
-                ]));
-        });
-    }
-    const primaryProjectName = pluginOptions.pages ? (Array.isArray(pluginOptions.pages) ? pluginOptions.pages[0] : Array.from(workspace.projects.entries()).find(([, def])=>'application' === def.extensions['projectType'])?.[0]) ?? null : getProjectByCwd(workspace, basePath);
-    if (!primaryProjectName) throw new Error("couldn't find the project");
-    const projectDefinition = workspace.projects.get(primaryProjectName);
-    if (!projectDefinition) throw new Error(`Project "${primaryProjectName}" not found in workspace`);
-    const buildOptions = await readBuildOptions(projectDefinition, basePath);
-    applyAngularConfig(api, buildOptions);
-    const sourcemap = !!(!!buildOptions.sourcemapOptions.scripts && (buildOptions.sourcemapOptions.hidden ? 'external' : true));
-    const thirdPartySourcemaps = buildOptions.sourcemapOptions.vendor;
-    const advancedOptimizations = buildOptions.advancedOptimizations;
-    const aot = buildOptions.aot;
-    const javascriptTransformer = new JavaScriptTransformer({
-        sourcemap,
-        thirdPartySourcemaps,
-        advancedOptimizations,
-        jit: !aot,
-        maxConcurrency: maxWorkers
-    }, void 0);
-    const tsconfig = buildOptions.tsconfig;
-    const compilation = await createAngularCompilation(false, aot);
-    const typeScriptFileCache = new Map();
-    const scopedCssCacheDir = node_path.join(basePath, 'node_modules', '.cache', 'angular-lynx-css');
-    node_fs.mkdirSync(scopedCssCacheDir, {
-        recursive: true
-    });
-    const componentStylesCache = new Map();
-    const componentScopeIds = new Map();
-    let componentResourceDependencies = new Map();
-    const writtenStylesheets = new Set();
-    let knownSourceFiles = new Set();
-    const transformStylesheet = createTransformStylesheet({
-        basePath,
-        scopedCssCacheDir,
-        componentStylesCache,
-        componentScopeIds,
-        onStylesheetWritten: (filePath)=>writtenStylesheets.add(filePath)
-    });
-    const compileAngular = async (changedFiles)=>{
-        const { sourceFileCache, fileNames } = buildLynxSchemaSourceFileCache(tsconfig, changedFiles && ((file)=>changedFiles.has(node_path.normalize(file)) || !knownSourceFiles.has(file)));
-        knownSourceFiles = new Set(fileNames);
-        if (changedFiles) await compilation.update?.(new Set(changedFiles));
-        const seeded = seedCompilationSourceFiles(compilation, sourceFileCache);
-        const seededFiles = new Set(seeded ? [
-            ...sourceFileCache.keys()
-        ].map((file)=>node_path.normalize(file)) : []);
-        writtenStylesheets.clear();
-        let result;
-        try {
-            result = await compilation.initialize(tsconfig, {
-                processWebWorker: (workerFile, _containingFile)=>workerFile,
-                transformStylesheet,
-                modifiedFiles: changedFiles && new Set([
-                    ...changedFiles
-                ].filter((file)=>!seededFiles.has(file)))
-            }, {
-                sourcemap: !!sourcemap,
-                preserveSymlinks: false
+    for (const chain of code.matchAll(chainPattern)){
+        tagExtractor.lastIndex = 0;
+        while(null !== (tagMatch = tagExtractor.exec(chain[0])))tags.add(tagMatch[1]);
+    }
+    while(null !== (match = repeaterPattern.exec(code)))tags.add(match[1]);
+    return tags;
+};
+const scanCompiledOutputForHtmlElements = (fileCache)=>{
+    const diagnostics = [];
+    for (const [file, contents] of fileCache){
+        if (file.includes('node_modules')) continue;
+        const code = 'string' == typeof contents ? contents : Buffer.from(contents).toString();
+        const tags = collectElementTags(code);
+        const fileName = node_path.relative(process.cwd(), file);
+        for (const tag of tags){
+            if (!(tag in HTML_ELEMENT_SUGGESTIONS)) continue;
+            const replacement = HTML_ELEMENT_SUGGESTIONS[tag];
+            const message = null !== replacement ? `${fileName}: <${tag}> is not a Lynx element. Use <${replacement}> instead.` : `${fileName}: <${tag}> has no Lynx equivalent and will not render correctly.`;
+            diagnostics.push({
+                file,
+                message,
+                category: 'html-element'
             });
-        } catch (error) {
-            throw new Error(`Angular compilation failed to initialize for "${tsconfig}". This often means a compiler worker crashed under resource pressure — lower NG_BUILD_MAX_WORKERS or reduce parallel build concurrency. Original error: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
         }
-        componentResourceDependencies = new Map([
-            ...result.componentResourcesDependencies ?? []
-        ].map(([file, dependencies])=>[
-                node_path.normalize(file),
-                dependencies.map((dependency)=>node_path.normalize(dependency))
-            ]));
-        const changedOutputs = new Set();
+    }
+    return diagnostics;
+};
+const scanSourcesForUnsupportedPatterns = (fileNames)=>{
+    const diagnostics = [];
+    for (const filePath of fileNames){
+        if (filePath.includes('node_modules')) continue;
+        let source;
         try {
-            for (const { filename, contents } of (await compilation.emitAffectedFiles())){
-                const file = node_path.normalize(filename);
-                if (typeScriptFileCache.get(file) !== contents) changedOutputs.add(file);
-                typeScriptFileCache.set(file, contents);
-            }
-        } catch (error) {
-            throw new Error(`Angular failed to emit compiled output for "${tsconfig}". Original error: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
-        }
-        for (const file of writtenStylesheets)changedOutputs.add(file);
-        for (const file of changedFiles ?? [])if (!node_fs.existsSync(file)) typeScriptFileCache.delete(file);
-        reportLynxDiagnostics([
-            ...scanCompiledOutputForHtmlElements(typeScriptFileCache),
-            ...scanCompiledOutputForStructuralIssues(typeScriptFileCache),
-            ...scanSourcesForUnsupportedPatterns(fileNames),
-            ...scanSourcesForUnsupportedCss(fileNames)
-        ]);
-        const diagnostics = await compilation.diagnoseFiles(useTypeChecking ? DiagnosticModes.All : DiagnosticModes.All & ~DiagnosticModes.Semantic);
-        const actionableErrors = diagnostics.errors?.filter((e)=>!isLynxUnknownElementMessage(e.text));
-        const actionableWarnings = diagnostics.warnings?.filter((w)=>!isLynxUnknownElementMessage(w.text));
-        if (actionableErrors?.length || actionableWarnings?.length) console.log({
-            errors: actionableErrors,
-            warnings: actionableWarnings
-        });
-        return {
-            changedOutputs,
-            inputFiles: result.referencedFiles.map((file)=>node_path.normalize(file))
-        };
-    };
-    const coordinator = createAngularRebuildCoordinator({
-        compile: compileAngular
-    });
-    const compilersByEnvironment = new Map();
-    api.onAfterCreateCompiler(({ compiler })=>{
-        const compilers = 'compilers' in compiler ? compiler.compilers : [
-            compiler
-        ];
-        for (const environmentCompiler of compilers)if (environmentCompiler.name) compilersByEnvironment.set(environmentCompiler.name, environmentCompiler);
-    });
-    let compilationClosed = false;
-    api.onBeforeEnvironmentCompile(async ({ environment, isWatch })=>{
-        const compiler = compilersByEnvironment.get(environment.name);
-        const outdatedFiles = await coordinator.prepare(environment.name, [
-            ...compiler?.modifiedFiles ?? [],
-            ...compiler?.removedFiles ?? []
-        ]);
-        if (compiler && outdatedFiles.size > 0) compiler.modifiedFiles = new Set([
-            ...compiler.modifiedFiles ?? [],
-            ...outdatedFiles
-        ]);
-        if (!isWatch && !compilationClosed) {
-            compilationClosed = true;
-            await compilation.close?.();
+            source = node_fs.readFileSync(filePath, 'utf-8');
+        } catch  {
+            continue;
         }
-    });
-    api.transform({
-        test: /\.[cm]?[jt]sx?$/
-    }, async (context)=>{
-        const isJs = /\.[cm]?js$/.test(context.resourcePath);
-        if (isJs) {
-            const contents = await javascriptTransformer.transformData(context.resourcePath, context.code, {
-                skipLinker: false,
-                sideEffects: ()=>Promise.resolve(false)
+        if (source.includes('ViewEncapsulation.ShadowDom')) {
+            const fileName = node_path.relative(process.cwd(), filePath);
+            diagnostics.push({
+                file: filePath,
+                message: `${fileName}: ViewEncapsulation.ShadowDom is not supported in Lynx (falls back to None). Use Emulated instead.`,
+                category: 'structural'
             });
-            return {
-                code: transformWorklets(Buffer.from(contents).toString(), context.resourcePath)
-            };
         }
-        const content = typeScriptFileCache.get(context.resourcePath);
-        if (!content) throw new Error(`No compiled output found for ${context.resourcePath}`);
-        for (const dependency of componentResourceDependencies.get(context.resourcePath) ?? [])context.addDependency(dependency);
-        const code = 'string' == typeof content ? content : Buffer.from(content).toString();
-        return {
-            code: buildTransformedCode({
-                code,
-                resourcePath: context.resourcePath,
-                componentStyles: componentStylesCache.get(context.resourcePath),
-                scopeInfo: componentScopeIds.get(context.resourcePath)
-            })
-        };
-    });
-};
-const LAYERS = {
-    BACKGROUND: 'background',
-    MAIN_THREAD: 'main'
+    }
+    return diagnostics;
 };
-const applyLayers = (api)=>{
-    api.modifyBundlerChain((chain)=>{
-        chain.module.rule("typescript").oneOf(LAYERS.BACKGROUND).layer(LAYERS.BACKGROUND).test(/\.[cm]?[jt]sx?$/).use('builtin:swc-loader').loader('builtin:swc-loader').options({
-            jsc: {
-                target: 'es2015',
-                parser: {
-                    syntax: "typescript"
-                }
-            }
-        }).end();
-        chain.module.rule("typescript").oneOf(LAYERS.MAIN_THREAD).layer(LAYERS.MAIN_THREAD).test(/\.[cm]?[jt]sx?$/).use('builtin:swc-loader').loader('builtin:swc-loader').options({
-            jsc: {
-                target: 'es2019',
-                parser: {
-                    syntax: "typescript"
-                }
-            }
-        }).end();
-    });
+const scanCompiledOutputForStructuralIssues = (fileCache)=>{
+    const diagnostics = [];
+    for (const [file, contents] of fileCache){
+        if (file.includes('node_modules')) continue;
+        const code = 'string' == typeof contents ? contents : Buffer.from(contents).toString();
+        const tags = collectElementTags(code);
+        const fileName = node_path.relative(process.cwd(), file);
+        if (tags.has('list-item') && !tags.has('list')) diagnostics.push({
+            file,
+            message: `${fileName}: <list-item> used without a <list> parent. Wrap list items in a <list> element.`,
+            category: 'structural'
+        });
+    }
+    return diagnostics;
 };
-const applyCSS = (api, options)=>{
-    const { enableRemoveCSSScope, enableCSSSelector, enableCSSInvalidation, targetSdkVersion } = options;
-    api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>mergeRsbuildConfig(config, {
-            output: {
-                injectStyles: false
-            }
-        }));
-    const __dirname = node_path.dirname(fileURLToPath(import.meta.url));
-    api.modifyBundlerChain(async (chain, { CHAIN_ID, environment })=>{
-        const { CssExtractRspackPlugin } = await import("@lynx-js/css-extract-webpack-plugin");
-        const removeLightningCSS = (rule)=>{
-            if (rule.uses.has(CHAIN_ID.USE.LIGHTNINGCSS) && 'lynx' === environment.name) rule.uses.delete(CHAIN_ID.USE.LIGHTNINGCSS);
-        };
-        const cssRules = [
-            CHAIN_ID.RULE.CSS,
-            CHAIN_ID.RULE.SASS,
-            CHAIN_ID.RULE.LESS,
-            CHAIN_ID.RULE.STYLUS
-        ];
-        for (const ruleName of cssRules.filter((rule)=>chain.module.rules.has(rule))){
-            const rule = chain.module.rule(ruleName);
-            const mainRuleName = ruleName === CHAIN_ID.RULE.CSS ? CHAIN_ID.ONE_OF.CSS_MAIN : ruleName;
-            const mainRule = rule.oneOf(mainRuleName);
-            const parentRuleEntries = rule.entries();
-            removeLightningCSS(mainRule);
-            mainRule.issuerLayer(LAYERS.BACKGROUND).use(CHAIN_ID.USE.MINI_CSS_EXTRACT).loader(CssExtractRspackPlugin.loader).end();
-            const uses = mainRule.uses.entries() ?? {};
-            const ruleEntries = mainRule.entries();
-            const cssLoader = uses[CHAIN_ID.USE.CSS];
-            if (!cssLoader) continue;
-            const cssLoaderRule = cssLoader.entries();
-            const mainThreadLayerRule = chain.module.rule(`${ruleName}:${LAYERS.MAIN_THREAD}`).test(parentRuleEntries.test).merge(ruleEntries).issuerLayer(LAYERS.MAIN_THREAD);
-            if (void 0 !== parentRuleEntries.dependency) mainThreadLayerRule.merge({
-                dependency: parentRuleEntries.dependency
-            });
-            mainThreadLayerRule.use(CHAIN_ID.USE.IGNORE_CSS).loader(node_path.resolve(__dirname, './loaders/ignore-css-loader')).end().uses.merge(uses).delete(CHAIN_ID.USE.MINI_CSS_EXTRACT).delete(CHAIN_ID.USE.LIGHTNINGCSS).delete(CHAIN_ID.USE.CSS).end().use(CHAIN_ID.USE.CSS).after(CHAIN_ID.USE.IGNORE_CSS).merge(cssLoaderRule).options(normalizeCssLoaderOptions(cssLoaderRule.options, true)).end();
+const scanSourcesForUnsupportedCss = (fileNames)=>{
+    const diagnostics = [];
+    for (const filePath of fileNames){
+        if (filePath.includes('node_modules')) continue;
+        let source;
+        try {
+            source = node_fs.readFileSync(filePath, 'utf-8');
+        } catch  {
+            continue;
         }
-        for (const ruleName of cssRules.filter((rule)=>chain.module.rules.has(rule))){
-            const inlineRuleName = ruleName === CHAIN_ID.RULE.CSS ? CHAIN_ID.ONE_OF.CSS_INLINE : `${ruleName}-inline`;
-            removeLightningCSS(chain.module.rule(ruleName).oneOf(inlineRuleName));
+        if (!source.includes('@Component')) continue;
+        const cssChunks = [];
+        const stylesBlockMatch = source.match(/styles\s*:\s*\[([\s\S]*?)\]/);
+        if (stylesBlockMatch) {
+            for (const m of stylesBlockMatch[1].matchAll(/`([\s\S]*?)`/g))cssChunks.push(m[1]);
+            if (0 === cssChunks.length) for (const m of stylesBlockMatch[1].matchAll(/(['"])([\s\S]*?)\1/g))cssChunks.push(m[2]);
         }
-        if ('lynx' === environment.name && chain.module.rules.has(CHAIN_ID.RULE.FONT)) {
-            const fontRule = chain.module.rule(CHAIN_ID.RULE.FONT);
-            fontRule.oneOfs.clear();
-            fontRule.type('asset/inline');
+        const styleUrlsMatch = source.match(/styleUrls?\s*:\s*\[([\s\S]*?)\]/);
+        if (styleUrlsMatch) for (const m of styleUrlsMatch[1].matchAll(/['"]([^'"]+)['"]/g)){
+            const stylePath = node_path.resolve(node_path.dirname(filePath), m[1]);
+            try {
+                cssChunks.push(node_fs.readFileSync(stylePath, 'utf-8'));
+            } catch  {}
         }
-        chain.plugin(CHAIN_ID.PLUGIN.MINI_CSS_EXTRACT).tap(([options])=>[
-                {
-                    ...options,
-                    enableRemoveCSSScope,
-                    enableCSSSelector,
-                    enableCSSInvalidation,
-                    targetSdkVersion,
-                    cssPlugins: [
-                        CSSPlugins.parserPlugins.removeFunctionWhiteSpace()
-                    ]
-                }
-            ]).init((_, args)=>new CssExtractRspackPlugin(...args)).end().end();
-        chain.module.when(void 0 === enableRemoveCSSScope, (module)=>module.rule('lynx.css.scoped').test(/\.css$/).resourceQuery({
-                and: [
-                    /cssId/,
-                    {
-                        not: /common/
-                    }
-                ]
-            }).sideEffects(false));
-    });
+        const seen = new Set();
+        const fileName = node_path.relative(process.cwd(), filePath);
+        for (const css of cssChunks){
+            const withoutComments = css.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*/g, '');
+            const propertyPattern = /(?:^|[{;])\s*([a-z-]+)\s*:/gm;
+            let match;
+            while(null !== (match = propertyPattern.exec(withoutComments))){
+                const property = match[1];
+                if (UNSUPPORTED_CSS[property] && !seen.has(property)) {
+                    seen.add(property);
+                    diagnostics.push({
+                        file: filePath,
+                        message: `${fileName}: '${property}' — ${UNSUPPORTED_CSS[property]}.`,
+                        category: 'css'
+                    });
+                }
+            }
+        }
+    }
+    return diagnostics;
 };
-const normalizeCssLoaderOptions = (options, exportOnlyLocals)=>{
-    if (options.modules && exportOnlyLocals) {
-        let { modules } = options;
-        modules = true === modules ? {
-            exportOnlyLocals: true
-        } : 'string' == typeof modules ? {
-            mode: modules,
-            exportOnlyLocals: true
-        } : {
-            ...modules,
-            exportOnlyLocals: true
-        };
-        return {
-            ...options,
-            modules
-        };
+const reportLynxDiagnostics = (diagnostics)=>{
+    if (0 === diagnostics.length) return;
+    const htmlWarnings = diagnostics.filter((d)=>'html-element' === d.category);
+    const structuralWarnings = diagnostics.filter((d)=>'structural' === d.category);
+    const cssWarnings = diagnostics.filter((d)=>'css' === d.category);
+    if (htmlWarnings.length > 0) {
+        console.warn('[Lynx] HTML elements detected in templates:');
+        for (const w of htmlWarnings)console.warn(`  ${w.message}`);
+    }
+    if (structuralWarnings.length > 0) {
+        console.warn('[Lynx] Structural issues:');
+        for (const w of structuralWarnings)console.warn(`  ${w.message}`);
+    }
+    if (cssWarnings.length > 0) {
+        console.warn('[Lynx] Unsupported CSS properties:');
+        for (const w of cssWarnings)console.warn(`  ${w.message}`);
     }
-    return options;
 };
-const createLynxProcessEvalResultRuntimeModule = (webpack)=>class extends webpack.RuntimeModule {
-        constructor(){
-            super('Lynx process eval result', webpack.RuntimeModule.STAGE_ATTACH);
-        }
-        generate() {
-            const chunk = this.chunk;
-            const compilation = this.compilation;
-            if (!chunk || !compilation) return '';
-            const chunkGroup = chunk._groupsIterable?.[0];
-            const modules = compilation.chunkGraph?.getChunkModules(chunk) ?? [];
-            modules.sort((a, b)=>{
-                const aIdx = chunkGroup?.getModulePreOrderIndex(a) ?? 0;
-                const bIdx = chunkGroup?.getModulePreOrderIndex(b) ?? 0;
-                return aIdx - bIdx;
-            });
-            const sortedIds = modules.map((m)=>compilation.chunkGraph.getModuleId(m)).filter((id)=>null != id);
-            const moduleOrder = JSON.stringify(sortedIds);
-            return `
-${RuntimeGlobals.lynxProcessEvalResult} = function (result, schema) {
-  var chunk = result && result(schema);
-  if (chunk && chunk.ids && chunk.modules) {
-    ${webpack.RuntimeGlobals.externalInstallChunk}(chunk);
-    var moduleOrder = ${moduleOrder};
-    for (var i = 0; i < moduleOrder.length; i++) {
-      if (chunk.modules[moduleOrder[i]]) {
-        ${webpack.RuntimeGlobals.require}(moduleOrder[i]);
-      }
+const applyAngularRules = async (api, pluginOptions)=>{
+    const cli = getAngularCliContext(api);
+    const { basePath, workspace } = await getAngularWorkspace(cli?.workspaceRoot);
+    if (pluginOptions.pages) {
+        const pages = resolvePages(workspace, basePath, pluginOptions.pages);
+        api.modifyRsbuildConfig((config)=>{
+            config.source ??= {};
+            config.source.entry = Object.fromEntries(pages.map((page)=>[
+                    page.name,
+                    page.browser
+                ]));
+        });
     }
-    return chunk;
-  }
-  return chunk
-}
-`;
-        }
+    const { buildOptions } = await resolvePrimaryBuild({
+        workspace,
+        basePath,
+        pages: pluginOptions.pages,
+        cli
+    });
+    applyAngularConfig(api, buildOptions);
+    const componentStyleSizes = new Map();
+    applyBudgets(api, {
+        budgets: buildOptions.budgets,
+        componentStyleSizes,
+        underAngularCli: void 0 !== cli
+    });
+    const sourcemap = !!(!!buildOptions.sourcemapOptions.scripts && (buildOptions.sourcemapOptions.hidden ? 'external' : true));
+    const thirdPartySourcemaps = buildOptions.sourcemapOptions.vendor;
+    const advancedOptimizations = buildOptions.advancedOptimizations;
+    const aot = buildOptions.aot;
+    const javascriptTransformer = new JavaScriptTransformer({
+        sourcemap,
+        thirdPartySourcemaps,
+        advancedOptimizations,
+        jit: !aot,
+        maxConcurrency: maxWorkers
+    }, void 0);
+    const tsconfig = buildOptions.tsconfig;
+    const compilation = await createAngularCompilation(false, aot);
+    const typeScriptFileCache = new Map();
+    const scopedCssCacheDir = node_path.join(basePath, 'node_modules', '.cache', 'angular-lynx-css');
+    node_fs.mkdirSync(scopedCssCacheDir, {
+        recursive: true
+    });
+    const componentStylesCache = new Map();
+    const componentScopeIds = new Map();
+    let componentResourceDependencies = new Map();
+    const writtenStylesheets = new Set();
+    let knownSourceFiles = new Set();
+    let angularDiagnostics = {
+        errors: [],
+        warnings: []
     };
-class AngularWebpackPlugin {
-    options;
-    constructor(options){
-        this.options = options;
-    }
-    static defaultOptions = Object.freeze({
-        disableCreateSelectorQueryIncompatibleWarning: false,
-        firstScreenSyncTiming: 'immediately',
-        enableSSR: false,
-        isWeb: false,
-        mainThreadChunks: [],
-        extractStr: false,
-        experimental_isLazyBundle: false
+    const transformStylesheet = createTransformStylesheet({
+        basePath,
+        scopedCssCacheDir,
+        componentStylesCache,
+        componentScopeIds,
+        onStylesheetWritten: (filePath)=>writtenStylesheets.add(filePath),
+        componentStyleSizes
     });
-    apply(compiler) {
-        const options = Object.assign({}, AngularWebpackPlugin.defaultOptions, this.options);
-        if (options.enableSSR && 'jsReady' !== options.firstScreenSyncTiming) options.firstScreenSyncTiming = 'jsReady';
-        const { DefinePlugin, EnvironmentPlugin } = compiler.webpack;
-        new EnvironmentPlugin({
-            DEBUG: null
-        }).apply(compiler);
-        new DefinePlugin({
-            __DEV__: JSON.stringify('development' === compiler.options.mode),
-            __PROFILE__: JSON.stringify('development' === compiler.options.mode),
-            __EXTRACT_STR__: JSON.stringify(Boolean(options.extractStr)),
-            __FIRST_SCREEN_SYNC_TIMING__: JSON.stringify(options.firstScreenSyncTiming),
-            __ENABLE_SSR__: JSON.stringify(options.enableSSR),
-            __WEB__: JSON.stringify(Boolean(options.isWeb)),
-            __DISABLE_CREATE_SELECTOR_QUERY_INCOMPATIBLE_WARNING__: JSON.stringify(options.disableCreateSelectorQueryIncompatibleWarning)
-        }).apply(compiler);
-        compiler.hooks.thisCompilation.tap(this.constructor.name, (compilation)=>{
-            const onceForChunkSet = new WeakSet();
-            compilation.hooks.runtimeRequirementInTree.for(compiler.webpack.RuntimeGlobals.ensureChunkHandlers).tap('VanillaWebpackPlugin', (chunk, runtimeRequirements)=>{
-                runtimeRequirements.add(RuntimeGlobals.lynxProcessEvalResult);
-            });
-            compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.lynxProcessEvalResult).tap('VanillaWebpackPlugin', (chunk)=>{
-                if (onceForChunkSet.has(chunk)) return;
-                onceForChunkSet.add(chunk);
-                const LynxProcessEvalResultRuntimeModule = createLynxProcessEvalResultRuntimeModule(compiler.webpack);
-                compilation.addRuntimeModule(chunk, new LynxProcessEvalResultRuntimeModule());
-            });
-            compilation.hooks.processAssets.tap({
-                name: this.constructor.name,
-                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
-            }, ()=>{
-                for (const name of options.mainThreadChunks ?? [])this.#updateMainThreadInfo(compilation, name);
-                for (const cg of compilation.chunkGroups.filter((cg)=>!cg.isInitial()).filter((cg)=>cg.origins.every((origin)=>origin.module?.layer === LAYERS.MAIN_THREAD))){
-                    const files = cg.getFiles();
-                    for (const name of files.filter((name)=>name.endsWith('.js')))this.#updateMainThreadInfo(compilation, name);
-                }
+    const compileAngular = async (changedFiles)=>{
+        const { sourceFileCache, fileNames } = buildLynxSchemaSourceFileCache(tsconfig, changedFiles && ((file)=>changedFiles.has(node_path.normalize(file)) || !knownSourceFiles.has(file)));
+        knownSourceFiles = new Set(fileNames);
+        if (changedFiles) await compilation.update?.(new Set(changedFiles));
+        const seeded = seedCompilationSourceFiles(compilation, sourceFileCache);
+        const seededFiles = new Set(seeded ? [
+            ...sourceFileCache.keys()
+        ].map((file)=>node_path.normalize(file)) : []);
+        writtenStylesheets.clear();
+        let result;
+        try {
+            result = await compilation.initialize(tsconfig, {
+                processWebWorker: (workerFile, _containingFile)=>workerFile,
+                transformStylesheet,
+                modifiedFiles: changedFiles && new Set([
+                    ...changedFiles
+                ].filter((file)=>!seededFiles.has(file)))
+            }, {
+                sourcemap: !!sourcemap,
+                preserveSymlinks: false
             });
-            {
-                const { ConcatSource } = compiler.webpack.sources;
-                const mainThreadChunkSet = new Set(options.mainThreadChunks ?? []);
-                compilation.hooks.processAssets.tap({
-                    name: `${this.constructor.name}:threadGlobals`,
-                    stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
-                }, ()=>{
-                    for (const [name] of Object.entries(compilation.assets).filter(([n])=>n.endsWith('.js'))){
-                        const isMainThread = mainThreadChunkSet.has(name);
-                        const prefix = `globalThis["__MAIN_THREAD__"]=${isMainThread};`;
-                        compilation.updateAsset(name, (old)=>new ConcatSource(prefix, old));
-                    }
-                    if (!options.experimental_isLazyBundle) for (const name of options.mainThreadChunks ?? []){
-                        const asset = compilation.getAsset(name);
-                        if (!asset) continue;
-                        const source = asset.source.source().toString();
-                        const useStrictPrefix = /^(['"])use strict\1;?/.test(source) ? "'use strict';" : '';
-                        compilation.updateAsset(name, (old)=>new ConcatSource(`${useStrictPrefix}var globDynamicComponentEntry=globDynamicComponentEntry||'__Card__';`, old));
-                    }
-                });
+        } catch (error) {
+            throw new Error(`Angular compilation failed to initialize for "${tsconfig}". This often means a compiler worker crashed under resource pressure — lower NG_BUILD_MAX_WORKERS or reduce parallel build concurrency. Original error: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+        }
+        componentResourceDependencies = new Map([
+            ...result.componentResourcesDependencies ?? []
+        ].map(([file, dependencies])=>[
+                node_path.normalize(file),
+                dependencies.map((dependency)=>node_path.normalize(dependency))
+            ]));
+        const changedOutputs = new Set();
+        try {
+            for (const { filename, contents } of (await compilation.emitAffectedFiles())){
+                const file = node_path.normalize(filename);
+                if (typeScriptFileCache.get(file) !== contents) changedOutputs.add(file);
+                typeScriptFileCache.set(file, contents);
             }
-            const hooks = LynxTemplatePlugin.getLynxTemplatePluginHooks(compilation);
-            const { ConcatSource } = compiler.webpack.sources;
-            hooks.beforeEncode.tap(this.constructor.name, (args)=>{
-                const { encodeData } = args;
-                encodeData.sourceContent.config = {
-                    ...encodeData.sourceContent.config,
-                    enableCSSInlineVariables: true
-                };
-                if (!encodeData.lepusCode.root) return args;
-                if ('card' === encodeData.sourceContent.appType) return args;
-                compilation.updateAsset(encodeData.lepusCode.root.name, (old)=>new ConcatSource(`\
-(function (globDynamicComponentEntry) {
-  const module = { exports: {} }
-  const exports = module.exports
-`, old, `
-  ;return module.exports
-})`));
-                return args;
-            });
-        });
-    }
-    #updateMainThreadInfo(compilation, name) {
-        const asset = compilation.getAsset(name);
-        tiny_invariant(asset, `Should have main thread asset ${name}`);
-        compilation.updateAsset(asset.name, asset.source, {
-            ...asset.info,
-            'lynx:main-thread': true
+        } catch (error) {
+            throw new Error(`Angular failed to emit compiled output for "${tsconfig}". Original error: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+        }
+        for (const file of writtenStylesheets)changedOutputs.add(file);
+        for (const file of changedFiles ?? [])if (!node_fs.existsSync(file)) {
+            typeScriptFileCache.delete(file);
+            forgetComponentStyleSizes(componentStyleSizes, file);
+        }
+        reportLynxDiagnostics([
+            ...scanCompiledOutputForHtmlElements(typeScriptFileCache),
+            ...scanCompiledOutputForStructuralIssues(typeScriptFileCache),
+            ...scanSourcesForUnsupportedPatterns(fileNames),
+            ...scanSourcesForUnsupportedCss(fileNames)
+        ]);
+        angularDiagnostics = filterAngularDiagnostics(await compilation.diagnoseFiles(useTypeChecking ? DiagnosticModes.All : DiagnosticModes.All & ~DiagnosticModes.Semantic));
+        return {
+            changedOutputs,
+            inputFiles: result.referencedFiles.map((file)=>node_path.normalize(file))
+        };
+    };
+    const coordinator = createAngularRebuildCoordinator({
+        compile: compileAngular
+    });
+    const compilersByEnvironment = new Map();
+    api.onAfterCreateCompiler(({ compiler })=>{
+        const compilers = 'compilers' in compiler ? compiler.compilers : [
+            compiler
+        ];
+        for (const environmentCompiler of compilers)if (environmentCompiler.name) compilersByEnvironment.set(environmentCompiler.name, environmentCompiler);
+        compilers[0]?.hooks.thisCompilation.tap('lynx:angular:diagnostics', (rspackCompilation)=>{
+            rspackCompilation.errors.push(...angularDiagnostics.errors.map((message)=>toAngularDiagnosticError(message, 'error')));
+            rspackCompilation.warnings.push(...angularDiagnostics.warnings.map((message)=>toAngularDiagnosticError(message, 'warning')));
         });
-    }
-}
-const S_LYNX_CONFIG = Symbol.for('@lynx-js/rsbuild-plugin:config');
-const PLUGIN_NAME_TEMPLATE = 'lynx:template';
-const PLUGIN_NAME_RUNTIME_WRAPPER = 'lynx:runtime-wrapper';
-const PLUGIN_NAME_ANGULAR = 'lynx:angular';
-const applyEntry = (api, options)=>{
-    const { customCSSInheritanceList, debugInfoOutside, defaultDisplayLinear, enableAccessibilityElement, enableCSSInheritance, enableCSSInvalidation, enableCSSSelector, enableNewGesture, enableRemoveCSSScope, removeDescendantSelectorScope, targetSdkVersion } = options;
-    api.modifyBundlerChain((chain, { environment, isDev })=>{
-        const lynxConfig = api.useExposed(S_LYNX_CONFIG);
-        if (!lynxConfig) throw new Error('No Lynx config exposed. `pluginLynx` has to be applied for the Lynx build engine to be configured.');
-        const isLynx = 'lynx' === environment.name;
-        const isWeb = 'web' === environment.name;
-        const { hmr, liveReload } = environment.config.dev ?? {};
-        const enabledHMR = isDev && !isWeb && false !== hmr;
-        const enabledLiveReload = isDev && !isWeb && false !== liveReload;
-        const entries = chain.entryPoints.entries() ?? {};
-        chain.entryPoints.clear();
-        const mainThreadChunks = [];
-        for (const [entryName, entryPoint] of Object.entries(entries)){
-            const { imports } = getChunks(entryName, entryPoint.values());
-            const templateFilename = lynxConfig.resolveBundleFilename({
-                entryName,
-                platform: environment.name
+    });
+    let compilationClosed = false;
+    api.onBeforeEnvironmentCompile(async ({ environment, isWatch })=>{
+        const compiler = compilersByEnvironment.get(environment.name);
+        const outdatedFiles = await coordinator.prepare(environment.name, [
+            ...compiler?.modifiedFiles ?? [],
+            ...compiler?.removedFiles ?? []
+        ]);
+        if (compiler && outdatedFiles.size > 0) compiler.modifiedFiles = new Set([
+            ...compiler.modifiedFiles ?? [],
+            ...outdatedFiles
+        ]);
+        if (!isWatch && !compilationClosed) {
+            compilationClosed = true;
+            await compilation.close?.();
+        }
+    });
+    api.transform({
+        test: /\.[cm]?[jt]sx?$/
+    }, async (context)=>{
+        const isJs = /\.[cm]?js$/.test(context.resourcePath);
+        if (isJs) {
+            const contents = await javascriptTransformer.transformData(context.resourcePath, context.code, {
+                skipLinker: false,
+                sideEffects: ()=>Promise.resolve(false)
             });
-            const mainThreadEntry = `${entryName}__main-thread`;
-            const mainThreadName = node_path.posix.join(`${entryName}/main-thread.js`);
-            const backgroundEntry = entryName;
-            const backgroundThreadName = node_path.posix.join(`${entryName}/background-thread.js`);
-            mainThreadChunks.push(mainThreadName);
-            chain.entry(mainThreadEntry).add({
-                layer: LAYERS.MAIN_THREAD,
-                import: imports,
-                filename: mainThreadName
-            }).end();
-            chain.entry(backgroundEntry).add({
-                layer: LAYERS.BACKGROUND,
-                import: imports,
-                filename: backgroundThreadName
-            }).when(enabledHMR, (entry)=>{
-                entry.prepend({
-                    layer: LAYERS.BACKGROUND,
-                    import: '@rspack/core/hot/dev-server'
-                });
-            }).when(enabledHMR || enabledLiveReload, (entry)=>{
-                entry.prepend({
-                    layer: LAYERS.BACKGROUND,
-                    import: '@lynx-js/webpack-dev-transport/client'
-                });
-            }).end();
-            chain.plugin(`${PLUGIN_NAME_TEMPLATE}-${entryName}`).use(LynxTemplatePlugin, [
-                {
-                    filename: templateFilename,
-                    intermediate: lynxConfig.resolveIntermediateDir({
-                        entryName
-                    }),
-                    chunks: [
-                        mainThreadEntry,
-                        backgroundEntry
-                    ],
-                    cssPlugins: [
-                        CSSPlugins.parserPlugins.removeFunctionWhiteSpace()
-                    ],
-                    customCSSInheritanceList,
-                    debugInfoOutside,
-                    defaultDisplayLinear,
-                    enableAccessibilityElement,
-                    enableCSSInheritance,
-                    enableCSSInvalidation,
-                    enableCSSSelector,
-                    enableNewGesture,
-                    enableRemoveCSSScope,
-                    removeDescendantSelectorScope,
-                    targetSdkVersion,
-                    enableA11y: true
-                }
-            ]).end();
+            return {
+                code: transformWorklets(Buffer.from(contents).toString(), context.resourcePath)
+            };
         }
-        if (isLynx) {
-            chain.plugin(PLUGIN_NAME_RUNTIME_WRAPPER).use(RuntimeWrapperWebpackPlugin, [
+        const content = typeScriptFileCache.get(context.resourcePath);
+        if (!content) throw new Error(`No compiled output found for ${context.resourcePath}`);
+        for (const dependency of componentResourceDependencies.get(context.resourcePath) ?? [])context.addDependency(dependency);
+        const code = 'string' == typeof content ? content : Buffer.from(content).toString();
+        return {
+            code: buildTransformedCode({
+                code,
+                resourcePath: context.resourcePath,
+                componentStyles: componentStylesCache.get(context.resourcePath),
+                scopeInfo: componentScopeIds.get(context.resourcePath)
+            })
+        };
+    });
+};
+const applyCSS = (api, options)=>{
+    const { enableRemoveCSSScope, enableCSSSelector, enableCSSInvalidation, targetSdkVersion } = options;
+    api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>mergeRsbuildConfig(config, {
+            output: {
+                injectStyles: false
+            }
+        }));
+    const __dirname = node_path.dirname(fileURLToPath(import.meta.url));
+    api.modifyBundlerChain(async (chain, { CHAIN_ID, environment })=>{
+        const { CssExtractRspackPlugin } = await import("@lynx-js/css-extract-webpack-plugin");
+        const removeLightningCSS = (rule)=>{
+            if (rule.uses.has(CHAIN_ID.USE.LIGHTNINGCSS) && 'lynx' === environment.name) rule.uses.delete(CHAIN_ID.USE.LIGHTNINGCSS);
+        };
+        const cssRules = [
+            CHAIN_ID.RULE.CSS,
+            CHAIN_ID.RULE.SASS,
+            CHAIN_ID.RULE.LESS,
+            CHAIN_ID.RULE.STYLUS
+        ];
+        for (const ruleName of cssRules.filter((rule)=>chain.module.rules.has(rule))){
+            const rule = chain.module.rule(ruleName);
+            const mainRuleName = ruleName === CHAIN_ID.RULE.CSS ? CHAIN_ID.ONE_OF.CSS_MAIN : ruleName;
+            const mainRule = rule.oneOf(mainRuleName);
+            const parentRuleEntries = rule.entries();
+            removeLightningCSS(mainRule);
+            mainRule.issuerLayer(LAYERS.BACKGROUND).use(CHAIN_ID.USE.MINI_CSS_EXTRACT).loader(CssExtractRspackPlugin.loader).end();
+            const uses = mainRule.uses.entries() ?? {};
+            const ruleEntries = mainRule.entries();
+            const cssLoader = uses[CHAIN_ID.USE.CSS];
+            if (!cssLoader) continue;
+            const cssLoaderRule = cssLoader.entries();
+            const mainThreadLayerRule = chain.module.rule(`${ruleName}:${LAYERS.MAIN_THREAD}`).test(parentRuleEntries.test).merge(ruleEntries).issuerLayer(LAYERS.MAIN_THREAD);
+            if (void 0 !== parentRuleEntries.dependency) mainThreadLayerRule.merge({
+                dependency: parentRuleEntries.dependency
+            });
+            mainThreadLayerRule.use(CHAIN_ID.USE.IGNORE_CSS).loader(node_path.resolve(__dirname, './loaders/ignore-css-loader')).end().uses.merge(uses).delete(CHAIN_ID.USE.MINI_CSS_EXTRACT).delete(CHAIN_ID.USE.LIGHTNINGCSS).delete(CHAIN_ID.USE.CSS).end().use(CHAIN_ID.USE.CSS).after(CHAIN_ID.USE.IGNORE_CSS).merge(cssLoaderRule).options(normalizeCssLoaderOptions(cssLoaderRule.options, true)).end();
+        }
+        for (const ruleName of cssRules.filter((rule)=>chain.module.rules.has(rule))){
+            const inlineRuleName = ruleName === CHAIN_ID.RULE.CSS ? CHAIN_ID.ONE_OF.CSS_INLINE : `${ruleName}-inline`;
+            removeLightningCSS(chain.module.rule(ruleName).oneOf(inlineRuleName));
+        }
+        if ('lynx' === environment.name && chain.module.rules.has(CHAIN_ID.RULE.FONT)) {
+            const fontRule = chain.module.rule(CHAIN_ID.RULE.FONT);
+            fontRule.oneOfs.clear();
+            fontRule.type('asset/inline');
+        }
+        chain.plugin(CHAIN_ID.PLUGIN.MINI_CSS_EXTRACT).tap(([options])=>[
                 {
-                    injectVars (vars) {
-                        return vars.map((name)=>{
-                            if ('Component' === name) return '__Component';
-                            return name;
-                        });
-                    },
+                    ...options,
+                    enableRemoveCSSScope,
+                    enableCSSSelector,
+                    enableCSSInvalidation,
                     targetSdkVersion,
-                    test: /^(?!.*main-thread(?:\.[A-Fa-f0-9]*)?\.js$).*\.js$/
+                    cssPlugins: [
+                        CSSPlugins.parserPlugins.removeFunctionWhiteSpace()
+                    ]
                 }
-            ]).end();
-            chain.plugin(`${LynxEncodePlugin.name}`).use(LynxEncodePlugin, [
-                {}
-            ]).end();
-        }
-        if (isWeb) chain.plugin(`${WebEncodePlugin.name}`).use(WebEncodePlugin, []).end();
-        chain.plugin(PLUGIN_NAME_ANGULAR).after(PLUGIN_NAME_TEMPLATE).use(AngularWebpackPlugin, [
-            {
-                mainThreadChunks,
-                enableSSR: options.enableSSR,
-                isWeb
-            }
-        ]);
+            ]).init((_, args)=>new CssExtractRspackPlugin(...args)).end().end();
+        chain.module.when(void 0 === enableRemoveCSSScope, (module)=>module.rule('lynx.css.scoped').test(/\.css$/).resourceQuery({
+                and: [
+                    /cssId/,
+                    {
+                        not: /common/
+                    }
+                ]
+            }).sideEffects(false));
     });
 };
-const getChunks = (entryName, entryValue)=>{
-    const chunks = [
-        entryName
-    ];
-    const imports = [];
-    for (const item of entryValue){
-        if ('string' == typeof item) {
-            imports.push(item);
-            continue;
-        }
-        if (Array.isArray(item)) {
-            imports.push(...imports);
-            continue;
-        }
-        const { dependOn } = item;
-        if (Array.isArray(item.import)) imports.push(...item.import);
-        else imports.push(item.import);
-        if (dependOn) if ('string' == typeof dependOn) chunks.unshift(dependOn);
-        else chunks.unshift(...dependOn);
+const normalizeCssLoaderOptions = (options, exportOnlyLocals)=>{
+    if (options.modules && exportOnlyLocals) {
+        let { modules } = options;
+        modules = true === modules ? {
+            exportOnlyLocals: true
+        } : 'string' == typeof modules ? {
+            mode: modules,
+            exportOnlyLocals: true
+        } : {
+            ...modules,
+            exportOnlyLocals: true
+        };
+        return {
+            ...options,
+            modules
+        };
     }
-    return {
-        chunks,
-        imports
-    };
+    return options;
 };
 const applyGenerator = (api)=>{
     api.modifyBundlerChain({
@@ -1432,8 +1738,7 @@ const applySplitChunksRule = (api, options)=>{
         });
         return config;
     });
-    api.modifyRspackConfig((rspackConfig, { environment })=>{
-        if ('lynx' !== environment.name) return rspackConfig;
+    api.modifyRspackConfig((rspackConfig)=>{
         rspackConfig.output = rspackConfig.output ?? {};
         if (!options.experimental_isLazyBundle) rspackConfig.output.asyncChunks = false;
         if (!rspackConfig.optimization) return rspackConfig;
@@ -1492,7 +1797,8 @@ const normalizeOptions = (options)=>{
 const pluginAngularLynx = (options)=>({
         name: 'lynx:angular',
         pre: [
-            'lynx:rsbuild:plugin-api'
+            'lynx:rsbuild:plugin-api',
+            ANGULAR_CLI_CONTEXT_PLUGIN_NAME
         ],
         setup: async (api)=>{
             const normalizedOptions = normalizeOptions(options);
@@ -1507,4 +1813,4 @@ const pluginAngularLynx = (options)=>({
             await angularRules;
         }
     });
-export { pluginAngularLynx };
+export { pluginAngularCliContext, pluginAngularLynx };