@blotch/rsbuild-plugin-angular-lynx 0.0.0-stage → 22.2.1

package/dist/index.js

@@ -0,0 +1,1510 @@
+/*! 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 { createHash } from "node:crypto";
+import { fileURLToPath } from "node:url";
+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 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 TYPESCRIPT_FILE = /\.[cm]?tsx?$/;
+const readFileVersion = (file)=>node_fs.statSync(file, {
+        throwIfNoEntry: false
+    })?.mtimeMs ?? null;
+const createAngularRebuildCoordinator = ({ compile, getFileVersion = readFileVersion })=>{
+    let queue = Promise.resolve();
+    let initialized = false;
+    let inputFiles = new Set();
+    const pendingFiles = new Set();
+    const compiledVersions = new Map();
+    let generation = 0;
+    const outputGenerations = new Map();
+    const environmentGenerations = new Map();
+    const isAngularInput = (file)=>TYPESCRIPT_FILE.test(file) || inputFiles.has(file);
+    const runCompile = async ()=>{
+        if (initialized && 0 === pendingFiles.size) return;
+        const changedFiles = new Set(pendingFiles);
+        pendingFiles.clear();
+        let result;
+        try {
+            result = await compile(initialized ? changedFiles : void 0);
+        } catch (error) {
+            for (const file of changedFiles){
+                pendingFiles.add(file);
+                compiledVersions.delete(file);
+            }
+            throw error;
+        }
+        inputFiles = new Set(result.inputFiles);
+        if (!initialized) {
+            initialized = true;
+            return;
+        }
+        generation++;
+        for (const file of result.changedOutputs)outputGenerations.set(file, generation);
+    };
+    return {
+        prepare: async (environmentName, changedFiles)=>{
+            for (const file of changedFiles){
+                if (!isAngularInput(file)) continue;
+                const version = getFileVersion(file);
+                if (!compiledVersions.has(file) || compiledVersions.get(file) !== version) {
+                    compiledVersions.set(file, version);
+                    pendingFiles.add(file);
+                }
+            }
+            const run = queue.then(runCompile);
+            queue = run.catch(()=>{});
+            await run;
+            const lastSeen = environmentGenerations.get(environmentName);
+            environmentGenerations.set(environmentName, generation);
+            const outdated = new Set();
+            if (void 0 === lastSeen) return outdated;
+            for (const [file, outputGeneration] of outputGenerations)if (outputGeneration > lastSeen) outdated.add(file);
+            return outdated;
+        }
+    };
+};
+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 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`);
+        }
+        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()
+        });
+    }
+    __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 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 VERSION = '0.0.0-PLACEHOLDER';
+const hasCacheMetadata = (value)=>!!value && 'object' == typeof value && 'cli' in value && !!value.cli && 'object' == typeof value.cli && 'cache' in value.cli;
+const normalizeCacheOptions = (projectMetadata, workspaceRoot)=>{
+    const cacheMetadata = hasCacheMetadata(projectMetadata) ? projectMetadata.cli.cache : {};
+    const { enabled = !process.versions.webcontainer, environment = 'local', path = '.angular/cache' } = cacheMetadata;
+    const isCI = '1' === process.env.CI || process.env.CI?.toLowerCase() === 'true';
+    let cacheEnabled = enabled;
+    if (cacheEnabled) switch(environment){
+        case 'ci':
+            cacheEnabled = isCI;
+            break;
+        case 'local':
+            cacheEnabled = !isCI;
+            break;
+    }
+    const cacheBasePath = resolve(workspaceRoot, path);
+    return {
+        enabled: cacheEnabled,
+        basePath: cacheBasePath,
+        path: join(cacheBasePath, VERSION)
+    };
+};
+const normalizeSourceMaps = (sourceMap)=>{
+    const scripts = 'object' == typeof sourceMap ? sourceMap.scripts : sourceMap;
+    const styles = 'object' == typeof sourceMap ? sourceMap.styles : sourceMap;
+    const hidden = 'object' == typeof sourceMap && sourceMap.hidden || false;
+    const vendor = 'object' == typeof sourceMap && sourceMap.vendor || false;
+    return {
+        vendor,
+        hidden,
+        scripts,
+        styles
+    };
+};
+const normalizeOptimization = (optimization = true)=>{
+    if ('object' == typeof optimization) {
+        const styleOptimization = !!optimization.styles;
+        return {
+            scripts: !!optimization.scripts,
+            styles: 'object' == typeof optimization.styles ? optimization.styles : {
+                minify: styleOptimization,
+                removeSpecialComments: styleOptimization,
+                inlineCritical: styleOptimization
+            },
+            fonts: 'object' == typeof optimization.fonts ? optimization.fonts : {
+                inline: !!optimization.fonts
+            }
+        };
+    }
+    return {
+        scripts: optimization,
+        styles: {
+            minify: optimization,
+            inlineCritical: optimization,
+            removeSpecialComments: optimization
+        },
+        fonts: {
+            inline: optimization
+        }
+    };
+};
+const readTarget = (project, target = 'build')=>project.targets.get(target);
+const readBuildOptions = async (project, basePath, configurationName)=>{
+    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);
+    let polyfills = buildOptions.polyfills;
+    polyfills = void 0 === polyfills || Array.isArray(polyfills) ? polyfills : [
+        polyfills
+    ];
+    let fileReplacements;
+    const buildOptionsFileReplacements = buildOptions.fileReplacements;
+    if (buildOptionsFileReplacements) for (const replacement of buildOptionsFileReplacements){
+        const fileReplaceWith = node_path.join(workspaceRoot, replacement.with);
+        try {
+            await access(fileReplaceWith, constants.F_OK);
+        } catch  {
+            throw new Error(`The ${fileReplaceWith} path in file replacements does not exist.`);
+        }
+        fileReplacements ??= {};
+        fileReplacements[node_path.join(workspaceRoot, replacement.replace)] = fileReplaceWith;
+    }
+    const outputHashing = buildOptions.outputHashing;
+    const media = 'media';
+    const outputNames = {
+        bundles: 'all' === outputHashing || 'bundles' === outputHashing ? '[name]-[hash]' : '[name]',
+        media: media + ('all' === outputHashing || 'media' === outputHashing ? '/[name]-[hash]' : '/[name]')
+    };
+    const advancedOptimizations = !!aot && optimizationOptions.scripts;
+    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 i18n = normalizeI18nOptions(project.extensions['i18n']);
+    const i18nMissingTranslation = buildOptions.i18nMissingTranslation ?? 'warning';
+    const normalizedOptions = {
+        aot,
+        optimizationOptions,
+        advancedOptimizations,
+        index,
+        browser,
+        fileReplacements,
+        sourcemapOptions,
+        tsconfig,
+        polyfills: polyfills ?? [],
+        outputPath,
+        workspaceRoot,
+        outputNames,
+        cacheOptions,
+        inlineStyleLanguage,
+        outputHashing,
+        styles,
+        i18n,
+        i18nMissingTranslation
+    };
+    return normalizedOptions;
+};
+const normalizeI18nOptions = (raw)=>{
+    if (!raw || 'object' != typeof raw) return {
+        sourceLocale: 'en-US',
+        hasDefinedSourceLocale: false
+    };
+    const i18nConfig = raw;
+    let sourceLocale = 'en-US';
+    let hasDefinedSourceLocale = false;
+    if ('string' == typeof i18nConfig.sourceLocale) {
+        sourceLocale = i18nConfig.sourceLocale;
+        hasDefinedSourceLocale = true;
+    } else if (i18nConfig.sourceLocale && 'object' == typeof i18nConfig.sourceLocale && 'string' == typeof i18nConfig.sourceLocale.code) {
+        sourceLocale = i18nConfig.sourceLocale.code;
+        hasDefinedSourceLocale = true;
+    }
+    return {
+        sourceLocale,
+        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);
+    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;
+};
+const resolvePages = (workspace, basePath, pages)=>{
+    const projectNames = 'all' === pages ? Array.from(workspace.projects.entries()).filter(([, def])=>'application' === def.extensions['projectType']).map(([name])=>name) : pages;
+    if (0 === projectNames.length) throw new Error('all' === pages ? 'No application-type projects found in angular.json. Add at least one project with "projectType": "application".' : 'The "pages" option is an empty array. Provide at least one project name.');
+    const resolved = [];
+    const tsconfigs = new Set();
+    for (const name of projectNames){
+        const project = workspace.projects.get(name);
+        if (!project) throw new Error(`Project "${name}" not found in angular.json. Available projects: ${Array.from(workspace.projects.keys()).join(', ')}`);
+        const target = readTarget(project);
+        if (!target?.options) throw new Error(`Project "${name}" has no build target or options in angular.json. Make sure it has an architect.build.options section.`);
+        const browser = target.options['browser'];
+        if (!browser) throw new Error(`Project "${name}" has no "browser" field in its build options. Set it to the entry file path (e.g., "src/main.ts").`);
+        const tsConfig = target.options['tsConfig'];
+        if (tsConfig) tsconfigs.add(node_path.resolve(basePath, tsConfig));
+        resolved.push({
+            name,
+            browser: node_path.join(basePath, browser)
+        });
+    }
+    if (tsconfigs.size > 1) throw new Error(`Multi-page builds require all projects to share the same tsConfig. Found ${tsconfigs.size} different tsconfigs: ${Array.from(tsconfigs).join(', ')}. Consolidate your projects to use a single tsconfig.`);
+    return resolved;
+};
+const HTML_ELEMENT_SUGGESTIONS = {
+    div: 'view',
+    section: 'view',
+    article: 'view',
+    aside: 'view',
+    header: 'view',
+    footer: 'view',
+    main: 'view',
+    nav: 'view',
+    figure: 'view',
+    figcaption: 'view',
+    details: 'view',
+    summary: 'view',
+    form: 'view',
+    fieldset: 'view',
+    button: 'view',
+    span: 'text',
+    p: 'text',
+    h1: 'text',
+    h2: 'text',
+    h3: 'text',
+    h4: 'text',
+    h5: 'text',
+    h6: 'text',
+    label: 'text',
+    strong: 'text',
+    em: 'text',
+    b: 'text',
+    i: 'text',
+    small: 'text',
+    pre: 'text',
+    code: 'text',
+    blockquote: 'text',
+    legend: 'text',
+    a: 'text',
+    img: 'image',
+    ul: 'list',
+    ol: 'list',
+    li: 'list-item',
+    table: 'view',
+    thead: 'view',
+    tbody: 'view',
+    tfoot: 'view',
+    tr: 'view',
+    td: 'view',
+    th: 'view',
+    select: null,
+    option: null,
+    canvas: null,
+    video: null,
+    audio: null,
+    iframe: null,
+    br: null,
+    hr: null
+};
+const UNSUPPORTED_CSS = {
+    float: 'use flex layout',
+    clear: 'use flex layout',
+    'text-transform': 'not supported in Lynx',
+    outline: 'use border instead',
+    'outline-width': 'use border instead',
+    'outline-style': 'use border instead',
+    'outline-color': 'use border instead',
+    'outline-offset': 'use border instead',
+    'list-style': 'not supported',
+    'list-style-type': 'not supported',
+    'list-style-position': 'not supported',
+    'list-style-image': 'not supported',
+    'table-layout': 'use flex/grid layout',
+    'border-collapse': 'use flex/grid layout',
+    'border-spacing': 'use flex/grid layout',
+    'word-spacing': 'not supported',
+    resize: 'not supported',
+    content: '::before/::after not supported',
+    'scroll-behavior': 'not supported',
+    'object-fit': 'not supported for images',
+    'object-position': 'not supported for images',
+    'user-select': 'not supported',
+    'will-change': 'not supported',
+    'backdrop-filter': 'use filter instead',
+    'text-justify': 'not supported',
+    'counter-reset': 'CSS counters not supported',
+    'counter-increment': 'CSS counters not supported',
+    'writing-mode': 'use direction property',
+    'text-orientation': 'not supported',
+    'column-count': 'multi-column layout not supported',
+    'column-width': 'multi-column layout not supported',
+    'column-rule': 'multi-column layout not supported'
+};
+const collectElementTags = (code)=>{
+    const chainPattern = /ɵɵelement(?:Start)?\([^)]*\)(?:\([^)]*\))*/g;
+    const tagExtractor = /\(\d+,\s*["']([a-z][a-z0-9-]*)["']/g;
+    const repeaterPattern = /ɵɵrepeaterCreate\(\d+,\s*\w+,\s*\d+,\s*\d+,\s*["']([a-z][a-z0-9-]*)["']/g;
+    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
+            });
+        } 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);
+            }
+        } 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?.();
+        }
+    });
+    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)
+            });
+            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'
+};
+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 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])=>[
+                {
+                    ...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 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 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]);
+      }
+    }
+    return chunk;
+  }
+  return chunk
+}
+`;
+        }
+    };
+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
+    });
+    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, 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 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();
+        }
+        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 applyGenerator = (api)=>{
+    api.modifyBundlerChain({
+        order: 'pre',
+        handler: (chain)=>{
+            chain.module.rule(`json-parse:${LAYERS.MAIN_THREAD}`).issuerLayer(LAYERS.MAIN_THREAD).test(/\.json$/).type('json').generator({
+                JSONParse: false
+            });
+        }
+    });
+};
+const RESET = '\x1b[0m';
+const GRAY = '\x1b[90m';
+const RED = '\x1b[31m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const WHITE = '\x1b[37m';
+const BOLD = '\x1b[1m';
+const LEVEL_COLORS = {
+    log: WHITE,
+    warn: `${BOLD}${YELLOW}`,
+    error: `${BOLD}${RED}`,
+    info: CYAN,
+    debug: GRAY
+};
+const LEVEL_LABELS = {
+    log: 'LOG',
+    warn: 'WRN',
+    error: 'ERR',
+    info: 'INF',
+    debug: 'DBG'
+};
+const formatTimestamp = (ts)=>{
+    const d = new Date(ts);
+    const h = String(d.getHours()).padStart(2, '0');
+    const m = String(d.getMinutes()).padStart(2, '0');
+    const s = String(d.getSeconds()).padStart(2, '0');
+    const ms = String(d.getMilliseconds()).padStart(3, '0');
+    return `${h}:${m}:${s}.${ms}`;
+};
+const formatArg = (arg)=>{
+    if (null == arg) return String(arg);
+    if ('string' == typeof arg) return arg;
+    if ('object' == typeof arg && 'Error' === arg.__type) {
+        const err = arg;
+        return err.stack || `${err.name}: ${err.message}`;
+    }
+    try {
+        return JSON.stringify(arg, null, 2);
+    } catch  {
+        return String(arg);
+    }
+};
+let logFile = null;
+let logFilePath = '';
+const getLogFilePath = ()=>logFilePath;
+const ensureLogFile = ()=>{
+    if (!logFile) {
+        logFilePath = node_path.resolve(process.cwd(), '.dev-logs');
+        logFile = node_fs.createWriteStream(logFilePath, {
+            flags: 'w'
+        });
+    }
+    return logFile;
+};
+const writeLog = (entry)=>{
+    const stream = ensureLogFile();
+    const color = LEVEL_COLORS[entry.level] || WHITE;
+    const label = LEVEL_LABELS[entry.level] || entry.level.toUpperCase();
+    const time = formatTimestamp(entry.timestamp);
+    const args = entry.args.map(formatArg).join(' ');
+    stream.write(`${GRAY}${time}${RESET} ${color}${label}${RESET} ${args}\n`);
+};
+const createDevLoggerMiddleware = ()=>(req, res, next)=>{
+        if ('OPTIONS' === req.method && '/__dev_logs' === req.url) {
+            res.writeHead(204, {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type'
+            });
+            res.end();
+            return;
+        }
+        if ('POST' !== req.method || '/__dev_logs' !== req.url) return void next();
+        let body = '';
+        req.on('data', (chunk)=>{
+            body += chunk.toString();
+        });
+        req.on('end', ()=>{
+            res.writeHead(204, {
+                'Access-Control-Allow-Origin': '*'
+            });
+            res.end();
+            try {
+                const { logs } = JSON.parse(body);
+                for (const entry of logs)writeLog(entry);
+            } catch  {}
+        });
+    };
+const LOG_PORT_OFFSET = 1;
+const applyDevLogger = (api)=>{
+    api.modifyRspackConfig((rspackConfig)=>{
+        if ('development' !== rspackConfig.mode) return rspackConfig;
+        const publicPath = rspackConfig.output?.publicPath;
+        let logUrl = '';
+        if ('string' == typeof publicPath && publicPath.startsWith('http')) try {
+            const parsed = new URL(publicPath);
+            const logPort = Number(parsed.port || 80) + LOG_PORT_OFFSET;
+            logUrl = `${parsed.protocol}//${parsed.hostname}:${logPort}/__dev_logs`;
+        } catch  {}
+        if (!logUrl) logUrl = `http://localhost:${3000 + LOG_PORT_OFFSET}/__dev_logs`;
+        rspackConfig.plugins = rspackConfig.plugins || [];
+        rspackConfig.plugins.push({
+            name: 'lynx:angular:dev-logger-define',
+            apply (compiler) {
+                const { DefinePlugin } = compiler.webpack;
+                new DefinePlugin({
+                    __DEV_LOG_URL__: JSON.stringify(logUrl)
+                }).apply(compiler);
+            }
+        });
+        return rspackConfig;
+    });
+    api.onAfterStartDevServer(({ port })=>{
+        const logPort = port + LOG_PORT_OFFSET;
+        const middleware = createDevLoggerMiddleware();
+        const server = node_http.createServer((req, res)=>{
+            middleware(req, res, ()=>{
+                res.writeHead(404);
+                res.end();
+            });
+        });
+        server.listen(logPort, '0.0.0.0', ()=>{
+            console.log(`[dev-logger] Log server on :${logPort} → tail -f ${getLogFilePath()}`);
+        });
+        server.on('error', (err)=>{
+            if ('EADDRINUSE' === err.code) server.listen(logPort + 1, '0.0.0.0');
+            else console.warn('[dev-logger] Failed to start log server:', err.message);
+        });
+    });
+};
+const applySplitChunksRule = (api, options)=>{
+    api.modifyEnvironmentConfig((config, { name, mergeEnvironmentConfig })=>{
+        const userConfig = api.getRsbuildConfig('original');
+        const scoped = userConfig.environments?.[name];
+        const splitChunks = scoped?.splitChunks ?? userConfig.splitChunks;
+        const chunkSplitStrategy = scoped?.performance?.chunkSplit?.strategy ?? userConfig.performance?.chunkSplit?.strategy;
+        if (void 0 === splitChunks && (!chunkSplitStrategy || 'all-in-one' === chunkSplitStrategy)) return mergeEnvironmentConfig(config, {
+            splitChunks: false
+        });
+        return config;
+    });
+    api.modifyRspackConfig((rspackConfig, { environment })=>{
+        if ('lynx' !== environment.name) return rspackConfig;
+        rspackConfig.output = rspackConfig.output ?? {};
+        if (!options.experimental_isLazyBundle) rspackConfig.output.asyncChunks = false;
+        if (!rspackConfig.optimization) return rspackConfig;
+        if (!rspackConfig.optimization.splitChunks) return rspackConfig;
+        const originalChunks = rspackConfig.optimization.splitChunks.chunks;
+        rspackConfig.optimization.splitChunks.chunks = (chunk)=>{
+            if (chunk.name?.includes('__main-thread')) return false;
+            if ('function' == typeof originalChunks) return originalChunks(chunk);
+            if ('async' === originalChunks) return !chunk.canBeInitial();
+            if ('initial' === originalChunks) return chunk.canBeInitial();
+            return true;
+        };
+        return rspackConfig;
+    });
+};
+const TAILWIND_CONFIG_FILES = [
+    'tailwind.config.ts',
+    'tailwind.config.js',
+    'tailwind.config.mjs',
+    'tailwind.config.cjs'
+];
+const applyTailwind = (api)=>{
+    const configFile = findUp(TAILWIND_CONFIG_FILES, process.cwd());
+    if (!configFile) return;
+    pluginTailwindCSS({
+        config: configFile,
+        exclude: [
+            /[\\/]node_modules[\\/]/
+        ]
+    }).setup(api);
+};
+const normalizeOptions = (options)=>{
+    const defaultOptions = {
+        customCSSInheritanceList: void 0,
+        debugInfoOutside: true,
+        enableA11y: true,
+        enableAccessibilityElement: false,
+        enableCSSInheritance: false,
+        enableCSSInvalidation: false,
+        enableCSSSelector: true,
+        enableICU: false,
+        enableNewGesture: true,
+        enableParallelElement: true,
+        defaultDisplayLinear: true,
+        enableRemoveCSSScope: false,
+        enableSSR: false,
+        pages: void 0,
+        pipelineSchedulerConfig: 0x00010000,
+        targetSdkVersion: '3.2',
+        defaultOverflowVisible: true,
+        removeDescendantSelectorScope: false,
+        experimental_isLazyBundle: false
+    };
+    return Object.assign(defaultOptions, options);
+};
+const pluginAngularLynx = (options)=>({
+        name: 'lynx:angular',
+        pre: [
+            'lynx:rsbuild:plugin-api'
+        ],
+        setup: async (api)=>{
+            const normalizedOptions = normalizeOptions(options);
+            applyCSS(api, normalizedOptions);
+            applyTailwind(api);
+            applyEntry(api, normalizedOptions);
+            applyLayers(api);
+            const angularRules = applyAngularRules(api, normalizedOptions);
+            applyGenerator(api);
+            applySplitChunksRule(api, normalizedOptions);
+            applyDevLogger(api);
+            await angularRules;
+        }
+    });
+export { pluginAngularLynx };