@lark-apaas/fullstack-rspack-preset 1.0.32-alpha.2 → 1.0.32-alpha.21

package/lib/rspack-plugins/css-legacy-plugin.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CssLegacyPlugin = void 0;
+const lightningcss_1 = require("lightningcss");
+/**
+ * CSS Legacy Plugin
+ *
+ * 在构建完成后生成一份兼容旧浏览器的 CSS 文件（.legacy.css）
+ * 并在 HTML 中注入检测脚本，根据浏览器版本加载对应的 CSS
+ */
+class CssLegacyPlugin {
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(CssLegacyPlugin.pluginName, (compilation) => {
+            compilation.hooks.processAssets.tapPromise({
+                name: CssLegacyPlugin.pluginName,
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1,
+            }, async (assets) => {
+                const cssFiles = Object.keys(assets).filter((name) => name.endsWith('.css') && !name.endsWith('.legacy.css'));
+                for (const cssFile of cssFiles) {
+                    const asset = assets[cssFile];
+                    const source = asset.source();
+                    let cssContent = typeof source === 'string' ? source : source.toString('utf-8');
+                    try {
+                        // 1. 先用正则移除/转换 LightningCSS 不支持的特性
+                        cssContent = this.preprocessCss(cssContent);
+                        // 2. 使用 LightningCSS 转换其他现代 CSS 特性
+                        const result = (0, lightningcss_1.transform)({
+                            filename: cssFile,
+                            code: Buffer.from(cssContent),
+                            minify: true,
+                            targets: {
+                                ios_saf: (12 << 16),
+                                safari: (12 << 16),
+                                chrome: (80 << 16),
+                            },
+                            include: lightningcss_1.Features.Nesting |
+                                lightningcss_1.Features.MediaQueries |
+                                lightningcss_1.Features.Colors |
+                                lightningcss_1.Features.Selectors |
+                                lightningcss_1.Features.ColorFunction |
+                                lightningcss_1.Features.OklabColors |
+                                lightningcss_1.Features.LabColors |
+                                lightningcss_1.Features.P3Colors |
+                                lightningcss_1.Features.HexAlphaColors |
+                                lightningcss_1.Features.LightDark,
+                            errorRecovery: true,
+                        });
+                        // 3. 后处理：移除可能残留的不支持特性
+                        let legacyCss = Buffer.from(result.code).toString('utf-8');
+                        legacyCss = this.postprocessCss(legacyCss);
+                        const legacyFileName = cssFile.replace('.css', '.legacy.css');
+                        compilation.emitAsset(legacyFileName, new compiler.webpack.sources.RawSource(Buffer.from(legacyCss)));
+                        console.log(`[CssLegacyPlugin] Generated ${legacyFileName} (${Math.round(legacyCss.length / 1024)}KB)`);
+                    }
+                    catch (error) {
+                        console.error(`[CssLegacyPlugin] Failed to transform ${cssFile}:`, error);
+                    }
+                }
+            });
+            // 修改 HTML，注入 CSS 版本检测脚本
+            compilation.hooks.processAssets.tapPromise({
+                name: `${CssLegacyPlugin.pluginName}-html`,
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE + 1,
+            }, async (assets) => {
+                const htmlFiles = Object.keys(assets).filter((name) => name.endsWith('.html'));
+                for (const htmlFile of htmlFiles) {
+                    const asset = assets[htmlFile];
+                    const source = asset.source();
+                    let htmlContent = typeof source === 'string' ? source : source.toString('utf-8');
+                    const cssLinkRegex = /<link[^>]+href="([^"]+\.css)"[^>]*>/g;
+                    const cssLinks = [...htmlContent.matchAll(cssLinkRegex)];
+                    if (cssLinks.length === 0)
+                        continue;
+                    const detectionScript = this.generateDetectionScript(cssLinks);
+                    for (const match of cssLinks) {
+                        htmlContent = htmlContent.replace(match[0], '');
+                    }
+                    htmlContent = htmlContent.replace(/<head([^>]*)>/i, `<head$1>\n${detectionScript}`);
+                    compilation.updateAsset(htmlFile, new compiler.webpack.sources.RawSource(htmlContent));
+                    console.log(`[CssLegacyPlugin] Updated ${htmlFile} with CSS detection script`);
+                }
+            });
+        });
+    }
+    /**
+     * 预处理 CSS：移除/转换 LightningCSS 不支持降级的特性
+     */
+    preprocessCss(css) {
+        // 1. 移除所有 @property 规则（iOS 16.4+ 才支持）
+        css = css.replace(/@property\s+--[\w-]+\s*\{[^}]*\}/g, '');
+        // 2. 展开 @layer 规则（iOS 15.4+ 才支持）
+        // 简单处理：移除 @layer xxx { 和对应的 }，保留内部内容
+        css = this.unwrapAtLayer(css);
+        // 3. 移除 @supports 中的 color-mix 检测块（这些是渐进增强，旧浏览器不需要）
+        css = this.removeColorMixSupports(css);
+        return css;
+    }
+    /**
+     * 后处理 CSS：清理可能残留的不支持特性
+     */
+    postprocessCss(css) {
+        // 移除可能残留的 @layer
+        css = this.unwrapAtLayer(css);
+        // 移除残留的 @property
+        css = css.replace(/@property\s+--[\w-]+\s*\{[^}]*\}/g, '');
+        // 移除残留的 color-mix @supports 块
+        css = this.removeColorMixSupports(css);
+        // 移除空的 @supports 块
+        css = css.replace(/@supports\s*\([^)]*\)\s*\{\s*\}/g, '');
+        return css;
+    }
+    /**
+     * 展开 @layer 规则，保留内部样式
+     */
+    unwrapAtLayer(css) {
+        // 匹配 @layer name { ... } 结构
+        // 需要处理嵌套大括号
+        let result = css;
+        let changed = true;
+        while (changed) {
+            changed = false;
+            // 简单的 @layer 匹配（非嵌套情况）
+            const layerRegex = /@layer\s+[\w-]+\s*\{/g;
+            let match;
+            while ((match = layerRegex.exec(result)) !== null) {
+                const startIndex = match.index;
+                const contentStart = startIndex + match[0].length;
+                // 找到匹配的闭合大括号
+                let depth = 1;
+                let i = contentStart;
+                while (i < result.length && depth > 0) {
+                    if (result[i] === '{')
+                        depth++;
+                    else if (result[i] === '}')
+                        depth--;
+                    i++;
+                }
+                if (depth === 0) {
+                    // 提取 @layer 内部的内容
+                    const innerContent = result.slice(contentStart, i - 1);
+                    // 用内部内容替换整个 @layer 块
+                    result = result.slice(0, startIndex) + innerContent + result.slice(i);
+                    changed = true;
+                    break; // 重新开始匹配
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * 移除 @supports (color: color-mix(...)) 块
+     * 这些是渐进增强代码，旧浏览器可以使用 fallback
+     */
+    removeColorMixSupports(css) {
+        let result = css;
+        let changed = true;
+        while (changed) {
+            changed = false;
+            // 匹配 @supports (color:color-mix(...)) { ... }
+            const supportsRegex = /@supports\s*\(\s*color\s*:\s*color-mix\s*\([^)]+\)\s*\)\s*\{/g;
+            let match;
+            while ((match = supportsRegex.exec(result)) !== null) {
+                const startIndex = match.index;
+                const contentStart = startIndex + match[0].length;
+                // 找到匹配的闭合大括号
+                let depth = 1;
+                let i = contentStart;
+                while (i < result.length && depth > 0) {
+                    if (result[i] === '{')
+                        depth++;
+                    else if (result[i] === '}')
+                        depth--;
+                    i++;
+                }
+                if (depth === 0) {
+                    // 移除整个 @supports 块
+                    result = result.slice(0, startIndex) + result.slice(i);
+                    changed = true;
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+    generateDetectionScript(cssLinks) {
+        const cssUrls = cssLinks.map((match) => match[1]);
+        // 检测脚本 + document.write 直接写入正确的 CSS（在加载前完成检测）
+        return `<script>
+(function() {
+  var isModernBrowser = (function() {
+    try {
+      if (typeof CSS === 'undefined' || typeof CSS.supports !== 'function') return false;
+      if (!CSS.supports('selector(:has(*))')) return false;
+      if (!CSS.supports('color', 'color-mix(in srgb, red, blue)')) return false;
+      if (!CSS.supports('color', 'oklch(50% 0.1 0)')) return false;
+      return true;
+    } catch (e) {
+      return false;
+    }
+  })();
+
+  var cssUrls = ${JSON.stringify(cssUrls)};
+  var suffix = isModernBrowser ? '' : '.legacy';
+
+  cssUrls.forEach(function(url) {
+    var finalUrl = url.replace(/\\.css$/, suffix + '.css');
+    document.write('<link rel="stylesheet" href="' + finalUrl + '">');
+  });
+})();
+</script>
+<noscript>
+${cssUrls.map((url) => `  <link rel="stylesheet" href="${url}">`).join('\n')}
+</noscript>`;
+    }
+}
+exports.CssLegacyPlugin = CssLegacyPlugin;
+CssLegacyPlugin.pluginName = 'CssLegacyPlugin';
+exports.default = CssLegacyPlugin;

package/lib/rspack-plugins/polyfill-plugin.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Polyfill Plugin
+ *
+ * 使用 core-js 为旧版浏览器生成独立的 polyfill 文件
+ * 通过检测脚本按需加载，现代浏览器不会加载 polyfill
+ */
+import type { Compiler } from '@rspack/core';
+export declare class PolyfillPlugin {
+    apply(compiler: Compiler): void;
+    private generateDetectionScript;
+}
+export default PolyfillPlugin;

package/lib/rspack-plugins/polyfill-plugin.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Polyfill Plugin
+ *
+ * 使用 core-js 为旧版浏览器生成独立的 polyfill 文件
+ * 通过检测脚本按需加载，现代浏览器不会加载 polyfill
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolyfillPlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const PLUGIN_NAME = 'PolyfillPlugin';
+const POLYFILL_ENTRY = path_1.default.resolve(__dirname, '../polyfills/index');
+class PolyfillPlugin {
+    apply(compiler) {
+        // 添加 polyfills 作为单独的 entry
+        compiler.hooks.entryOption.tap(PLUGIN_NAME, (_context, entry) => {
+            if (typeof entry === 'function') {
+                return;
+            }
+            // 添加 polyfills entry，单独打包
+            entry['polyfills'] = {
+                import: [POLYFILL_ENTRY],
+                filename: 'polyfills.js',
+                // 不需要 runtime，保持文件独立
+                runtime: false,
+            };
+        });
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+            // 在 HTML 中注入检测脚本
+            compilation.hooks.processAssets.tapPromise({
+                name: `${PLUGIN_NAME}-html`,
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE,
+            }, async (assets) => {
+                const htmlFiles = Object.keys(assets).filter((name) => name.endsWith('.html'));
+                const publicPath = compilation.outputOptions.publicPath || '/';
+                for (const htmlFile of htmlFiles) {
+                    const asset = assets[htmlFile];
+                    const source = asset.source();
+                    let htmlContent = typeof source === 'string' ? source : source.toString('utf-8');
+                    const polyfillUrl = `${publicPath}polyfills.js`.replace(/\/+/g, '/').replace(':/', '://');
+                    const detectionScript = this.generateDetectionScript(polyfillUrl);
+                    // 注入到 <head> 最前面
+                    htmlContent = htmlContent.replace(/<head([^>]*)>/i, `<head$1>\n${detectionScript}`);
+                    compilation.updateAsset(htmlFile, new compiler.webpack.sources.RawSource(htmlContent));
+                    console.log(`[PolyfillPlugin] Updated ${htmlFile} with polyfill detection`);
+                }
+            });
+        });
+    }
+    generateDetectionScript(polyfillUrl) {
+        return `<script>
+(function(){
+  var needsPolyfill=(function(){
+    try{
+      if(typeof crypto==="undefined"||typeof crypto.randomUUID!=="function")return true;
+      if(typeof Object.hasOwn!=="function")return true;
+      if(typeof[].at!=="function")return true;
+      if(typeof[].findLast!=="function")return true;
+      return false;
+    }catch(e){return true}
+  })();
+  if(needsPolyfill){
+    document.write('<script src="${polyfillUrl}"><\\/script>');
+  }
+})();
+</script>`;
+    }
+}
+exports.PolyfillPlugin = PolyfillPlugin;
+exports.default = PolyfillPlugin;

package/lib/rspack-plugins/route-parser-plugin.d.ts

@@ -1,12 +1,14 @@
 interface RouteParserPluginOptions {
     appPath?: string;
     outputPath?: string;
+    basePath?: string;
 }
 declare class RouteParserPlugin {
     private options;
     private lastAppPathHash;
     private cachedRoutes;
     constructor(options?: RouteParserPluginOptions);
+    private normalizeBasePath;
     private log;
     apply(compiler: any): void;
     private shouldRegenerateRoutes;
@@ -17,4 +19,13 @@ declare class RouteParserPlugin {
     private buildFullPath;
     private evaluateTemplateLiteral;
 }
+export declare function normalizeBasePath(basePath: string): string;
+/**
+ * Parse routes from the app file at build time.
+ * @param appPath - Path to app.tsx (relative to cwd or absolute)
+ * @param basePath - Base path prefix for routes (e.g., '/my_plugin')
+ */
+export declare function parseRoutesFromFile(appPath: string, basePath: string): Array<{
+    path: string;
+}>;
 export default RouteParserPlugin;

package/lib/rspack-plugins/route-parser-plugin.js

@@ -36,6 +36,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeBasePath = normalizeBasePath;
+exports.parseRoutesFromFile = parseRoutesFromFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const crypto = __importStar(require("crypto"));
@@ -46,11 +48,27 @@ class RouteParserPlugin {
     constructor(options = {}) {
         this.lastAppPathHash = null;
         this.cachedRoutes = null;
+        // 从环境变量读取 basePath，并规范化（确保以 / 开头，不以 / 结尾）
+        const envBasePath = process.env.CLIENT_BASE_PATH || '';
+        const normalizedBasePath = this.normalizeBasePath(options.basePath ?? envBasePath);
         this.options = {
             appPath: options.appPath || './client/src/app.tsx',
             outputPath: options.outputPath || './dist/client/routes.json',
+            basePath: normalizedBasePath,
         };
     }
+    normalizeBasePath(basePath) {
+        if (!basePath || basePath === '/') {
+            return '';
+        }
+        // 确保以 / 开头
+        let normalized = basePath.startsWith('/') ? basePath : `/${basePath}`;
+        // 确保不以 / 结尾
+        if (normalized.endsWith('/')) {
+            normalized = normalized.slice(0, -1);
+        }
+        return normalized;
+    }
     log(level, message, ...args) {
         const prefix = '[route-parser]';
         const logMessage = `${prefix} ${message}`;
@@ -88,7 +106,9 @@ class RouteParserPlugin {
             }
             catch (error) {
                 this.log('warn', '⚠️ 路由解析失败，使用默认路由:', error.message);
-                const defaultRoutes = [{ path: '/' }];
+                const { basePath } = this.options;
+                const defaultPath = basePath ? `${basePath}/` : '/';
+                const defaultRoutes = [{ path: defaultPath }];
                 const routesJson = JSON.stringify(defaultRoutes, null, 2);
                 compilation.assets['routes.json'] = {
                     source: () => routesJson,
@@ -179,12 +199,19 @@ class RouteParserPlugin {
                     }
                 }
             });
-            const routes = Array.from(routeSet).map(routePath => ({ path: routePath }));
-            return routes.length > 0 ? routes : [{ path: '/' }];
+            const { basePath } = this.options;
+            const routes = Array.from(routeSet).map(routePath => ({
+                path: basePath ? `${basePath}${routePath}` : routePath,
+            }));
+            // 默认路由也需要加上 basePath
+            const defaultPath = basePath ? `${basePath}/` : '/';
+            return routes.length > 0 ? routes : [{ path: defaultPath }];
         }
         catch (error) {
             this.log('warn', '⚠️ 路由解析失败，使用默认路由:', error.message);
-            return [{ path: '/' }];
+            const { basePath } = this.options;
+            const defaultPath = basePath ? `${basePath}/` : '/';
+            return [{ path: defaultPath }];
         }
     }
     isRouteComponent(openingElement) {
@@ -266,4 +293,161 @@ class RouteParserPlugin {
         return quasis.map((q) => q.value.raw).join('');
     }
 }
+// Standalone module-level helpers (mirroring private class methods) for external callers
+function normalizeBasePath(basePath) {
+    if (!basePath || basePath === '/') {
+        return '';
+    }
+    let normalized = basePath.startsWith('/') ? basePath : `/${basePath}`;
+    if (normalized.endsWith('/')) {
+        normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+}
+function _isRouteComponent(openingElement) {
+    return (t.isJSXIdentifier(openingElement.name) &&
+        openingElement.name.name === 'Route');
+}
+function _evaluateTemplateLiteral(templateLiteral) {
+    const quasis = templateLiteral.quasis;
+    const expressions = templateLiteral.expressions;
+    if (quasis.length === 1 && expressions.length === 0) {
+        return quasis[0].value.raw;
+    }
+    return quasis.map((q) => q.value.raw).join('');
+}
+function _extractRouteInfo(openingElement) {
+    const routeInfo = {};
+    openingElement.attributes.forEach((attr) => {
+        if (t.isJSXAttribute(attr)) {
+            const name = attr.name.name;
+            let value;
+            if (attr.value) {
+                if (t.isStringLiteral(attr.value)) {
+                    value = attr.value.value;
+                }
+                else if (t.isJSXExpressionContainer(attr.value)) {
+                    const expression = attr.value.expression;
+                    if (t.isStringLiteral(expression)) {
+                        value = expression.value;
+                    }
+                    else if (t.isTemplateLiteral(expression)) {
+                        value = _evaluateTemplateLiteral(expression);
+                    }
+                    else {
+                        value = true;
+                    }
+                }
+            }
+            else {
+                value = true;
+            }
+            routeInfo[name] = value;
+        }
+    });
+    return routeInfo;
+}
+function _buildFullPath(routeStack, currentRoute) {
+    let fullPath = '';
+    for (let i = 0; i < routeStack.length; i++) {
+        if (routeStack[i].path) {
+            let parentPath = routeStack[i].path;
+            if (!parentPath.startsWith('/'))
+                parentPath = `/${parentPath}`;
+            if (parentPath.endsWith('/') && parentPath !== '/') {
+                parentPath = parentPath.slice(0, -1);
+            }
+            fullPath += parentPath === '/' ? '' : parentPath;
+        }
+    }
+    if (currentRoute.index) {
+        return fullPath || '/';
+    }
+    else if (currentRoute.path) {
+        const routePath = currentRoute.path;
+        if (routePath === '*') {
+            return null;
+        }
+        if (!routePath.startsWith('/')) {
+            fullPath = `${fullPath}/${routePath}`;
+        }
+        else {
+            fullPath = routePath;
+        }
+        if (fullPath === '')
+            fullPath = '/';
+        if (!fullPath.startsWith('/'))
+            fullPath = `/${fullPath}`;
+        return fullPath;
+    }
+    return null;
+}
+/**
+ * Parse routes from the app file at build time.
+ * @param appPath - Path to app.tsx (relative to cwd or absolute)
+ * @param basePath - Base path prefix for routes (e.g., '/my_plugin')
+ */
+function parseRoutesFromFile(appPath, basePath) {
+    const prefix = '[route-parser]';
+    const defaultPath = basePath ? `${basePath}/` : '/';
+    try {
+        const appFilePath = path.resolve(process.cwd(), appPath);
+        if (!fs.existsSync(appFilePath)) {
+            throw new Error(`App.tsx file does not exist: ${appFilePath}`);
+        }
+        const sourceCode = fs.readFileSync(appFilePath, 'utf-8');
+        const ast = (0, parser_1.parse)(sourceCode, {
+            sourceType: 'module',
+            plugins: [
+                'jsx',
+                'typescript',
+                'decorators-legacy',
+                'classProperties',
+                'objectRestSpread',
+                'functionBind',
+                'exportDefaultFrom',
+                'exportNamespaceFrom',
+                'dynamicImport',
+                'nullishCoalescingOperator',
+                'optionalChaining'
+            ]
+        });
+        const routeSet = new Set();
+        const routeStack = [];
+        (0, traverse_1.default)(ast, {
+            JSXElement: {
+                enter(nodePath) {
+                    const { openingElement } = nodePath.node;
+                    if (_isRouteComponent(openingElement)) {
+                        const routeInfo = _extractRouteInfo(openingElement);
+                        routeStack.push(routeInfo);
+                    }
+                },
+                exit(nodePath) {
+                    const { openingElement } = nodePath.node;
+                    if (_isRouteComponent(openingElement)) {
+                        const currentRoute = routeStack.pop();
+                        if (currentRoute && currentRoute.path === '*') {
+                            return;
+                        }
+                        if (currentRoute && (currentRoute.path || currentRoute.index)) {
+                            const fullPath = _buildFullPath(routeStack, currentRoute);
+                            if (fullPath) {
+                                routeSet.add(fullPath);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        const routes = Array.from(routeSet).map(routePath => ({
+            path: basePath ? `${basePath}${routePath}` : routePath,
+        }));
+        return routes.length > 0 ? routes : [{ path: defaultPath }];
+    }
+    catch (error) {
+        console.warn(`${prefix} Route parsing failed, using default routes:`, error.message);
+        return [{ path: defaultPath }];
+    }
+}
 exports.default = RouteParserPlugin;

package/lib/rspack-plugins/runtime-injection-plugin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Runtime Injection Plugin
+ *
+ * 在编译时自动将 @lark-apaas/client-toolkit/runtime 注入到所有入口之前
+ * 支持 extends 配置方式
+ *
+ * 原理：在 entryOption hook 中原地修改 entry 配置，将 runtime 注入到每个入口的最前面
+ */
+import type { Compiler } from '@rspack/core';
+export declare class RuntimeInjectionPlugin {
+    apply(compiler: Compiler): void;
+}
+export default RuntimeInjectionPlugin;

package/lib/rspack-plugins/runtime-injection-plugin.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Runtime Injection Plugin
+ *
+ * 在编译时自动将 @lark-apaas/client-toolkit/runtime 注入到所有入口之前
+ * 支持 extends 配置方式
+ *
+ * 原理：在 entryOption hook 中原地修改 entry 配置，将 runtime 注入到每个入口的最前面
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeInjectionPlugin = void 0;
+const RUNTIME_MODULE = '@lark-apaas/client-toolkit/runtime';
+const PLUGIN_NAME = 'RuntimeInjectionPlugin';
+class RuntimeInjectionPlugin {
+    apply(compiler) {
+        // entryOption hook 在配置合并完成后、处理 entry 之前触发
+        compiler.hooks.entryOption.tap(PLUGIN_NAME, (_context, entry) => {
+            // 跳过动态 entry（函数形式）
+            if (typeof entry === 'function') {
+                return;
+            }
+            // 原地修改 entry 对象，将 runtime 注入到每个入口的最前面
+            for (const name of Object.keys(entry)) {
+                const descriptor = entry[name];
+                const imports = descriptor.import || [];
+                // 检查是否已经包含 runtime
+                if (imports.includes(RUNTIME_MODULE)) {
+                    continue;
+                }
+                // 原地修改 import 数组，将 runtime 插入到最前面
+                descriptor.import = [RUNTIME_MODULE, ...imports];
+            }
+            // 不返回 true，让 rspack 继续正常处理 entry
+        });
+    }
+}
+exports.RuntimeInjectionPlugin = RuntimeInjectionPlugin;
+exports.default = RuntimeInjectionPlugin;

package/lib/rspack-plugins/slardar-performance-monitor-plugin.js

@@ -106,10 +106,14 @@ function getSlardarScriptContent(option = {}) {
         slardarScript.onload = function() {
           // 脚本加载完成后执行初始化
           if (window.${globalName}) {
+            window.${globalName}('context.merge', {
+              tenantId: window.tenantId ?? '',
+              appId: window.appId ?? '',
+            });
             window.${globalName}('init', {
               bid: '${bid}',
-              // 四种类型：dev/boe/pre/online
-              env: 'online',
+              env: window.ENVIRONMENT || 'online',
+              userId: window.userId ?? '',
             });
             window.${globalName}('start');
           }

package/lib/rspack-plugins/source-map-upload-plugin.js

@@ -63,9 +63,14 @@ class SourceMapUploadPlugin {
             const outputBaseDir = path.basename(outputPath); // e.g., 'client'
             const sourcemapTargetDir = path.join(this.options.outputDir, outputBaseDir); // e.g., 'dist/sourcemaps/client'
             for (const sourceMap of sourceMaps) {
-                const assetName = sourceMap.name;
+                let assetName = sourceMap.name;
+                // Align with Vite's output structure by adding 'assets' and removing 'chunks'
+                if (assetName.startsWith('chunks/')) {
+                    assetName = assetName.substring('chunks/'.length);
+                }
+                assetName = path.join('assets', assetName);
                 const destinationPath = path.join(sourcemapTargetDir, assetName);
-                const originalPath = path.join(outputPath, assetName);
+                const originalPath = path.join(outputPath, sourceMap.name);
                 try {
                     // Ensure the destination directory for the specific file exists.
                     const destinationDir = path.dirname(destinationPath);