@aiot-toolkit/aiotpack 2.1.0-prender.16 → 2.1.0-prender.18

package/lib/afterCompile/ux/UxAfterCompile.js

@@ -32,7 +32,21 @@ class UxAfterCompile {
       compilerOption,
       onLog
     } = params;
-    return new _ViteCompiler.default(context, onLog).compile({
+    // The legacy format needs the rspack pipeline: its page JS carries the template
+    // and style inline (`$app_template$`/`$app_style$`) instead of the separate
+    // template.json/css.json the Vite pipeline emits. Required lazily so a
+    // default build never loads rspack's native binding (~180ms, ~47MB RSS), and
+    // so rspack only has to be installed by projects that ask for this format.
+    let Compiler = _ViteCompiler.default;
+    if (compilerOption?.legacy) {
+      try {
+        Compiler = require('../../compiler/javascript/JavascriptCompiler').default;
+      } catch (e) {
+        if (!/@rspack\/core/.test(e?.message ?? '')) throw e;
+        throw new Error(`--legacy needs @rspack/core, which is not installed. ` + `Run \`npm i @rspack/core\`, or drop --legacy to build the default format.`);
+      }
+    }
+    return new Compiler(context, onLog).compile({
       projectPath: _path.default.join(context.projectPath, context.output),
       mode: _CompileMode.default.DEVELOPMENT,
       devtool: false,
@@ -101,9 +115,9 @@ class UxAfterCompile {
     } = params;
     if (compilerOption) {
       const buildPath = _path.default.join(context.projectPath, context.output, compilerOption.outputPath);
-      _Jsc.default.wrapAllJsWithIife(buildPath);
+      _Jsc.default.wrapAllJsWithIife(buildPath, compilerOption.legacy);
       if (compilerOption.enableJsc === true) {
-        return new _Jsc.default(context.projectPath, buildPath).jsc();
+        return new _Jsc.default(context.projectPath, buildPath, compilerOption.legacy).jsc();
       }
     }
   };
@@ -353,6 +367,9 @@ class UxAfterCompile {
       onLog
     } = params;
     if (!compilerOption) return;
+    // Moving the icon to the build root is part of the new format; the legacy
+    // format keeps it where manifest.icon points.
+    if (compilerOption.legacy) return;
     const {
       projectPath,
       outputPath

package/lib/compiler/javascript/JavascriptCompiler.js

@@ -135,13 +135,18 @@ class JavascriptCompiler {
     let result = {
       context: projectPath,
       mode,
-      devtool: devtool || false,
+      // `devtool: 'none'` is the webpack 4 spelling for "no source map" and still
+      // appears in project configs; rspack rejects it, so normalize to false.
+      devtool: (devtool === 'none' ? false : devtool) || false,
       output: {
         globalObject: 'global',
         filename: '[name].js',
         publicPath: './',
         path: buildPath,
-        iife: false,
+        // The legacy wrapper emits `return <bundle>`, so the bundle has to be an
+        // expression. Without this rspack emits a bare `var __webpack_exports__ = {}`
+        // statement and the wrapper becomes `return var ...`, a syntax error.
+        iife: Boolean(param.legacy),
         library: {
           type: 'commonjs2'
         }

package/lib/compiler/javascript/ViteCompiler.d.ts

@@ -19,6 +19,14 @@ declare function resolveImportSrc(fromUxFile: string, src: string): string | nul
  * can open.
  */
 declare function collectReachableUx(entryUxFiles: string[]): Set<string>;
+/**
+ * The e2e test entry `.ux` that `--enable-e2e` turns into `router.entry`.
+ *
+ * It is absent from the source manifest — UxAfterCompile registers it only
+ * after compilation — so route-based reachability cannot see it and would skip
+ * it, leaving `router.entry` pointing at a page the package does not contain.
+ */
+declare function resolveE2eEntryUx(param: IJavascriptCompileOption, originalProjectPath: string): string | null;
 /**
  * Relative ESM imports a sub-component declares that nothing downstream can
  * resolve: `.ux` imports are loader-generated and dropped later, and
@@ -79,6 +87,29 @@ declare function stripDeadDefProp(code: string): string;
  */
 declare function dropUnusedUxImports(code: string): string;
 declare function buildComponentJs(compCode: string, compName: string, compSid: number, relPath: string): string;
+/**
+ * Normalize rolldown output: drop its region markers and runtime helpers, and
+ * turn surviving `require("@system.*")` calls into `$app_require$`.
+ */
+declare function stripRolldownArtifacts(code: string): string;
+/**
+ * Move synthesized namespace objects to the top of the flattened scope.
+ *
+ * The `import * as ns` interop bridge reads `ns_exports` from a top-level statement,
+ * so with an import cycle DFS post-order can leave the bridge ahead of the object:
+ * `var` assignment is not hoisted, so it reads undefined and throws before any
+ * `$app_define$` runs. Only getter-only literals move — they have no side effects and
+ * resolve lazily, so relocating one cannot snapshot an undefined or reorder an effect.
+ */
+declare function hoistNamespaceObjects(code: string): string;
+/** Calls through a surviving thunk table are silently dropped, so refuse to emit one. */
+declare function assertNamespaceObjectsInlined(code: string): void;
+/**
+ * Reject a top-level `var` whose eager initializer reads an identifier assigned by a
+ * later top-level `var` — the read yields undefined, which is how an import cycle
+ * surfaces once module bodies are flattened into one scope.
+ */
+declare function assertNoEagerForwardRead(code: string): void;
 declare function mergeStyleSheets(app: any, page: any): any;
 export declare const __test: {
     stripDeadDefProp: typeof stripDeadDefProp;
@@ -89,5 +120,10 @@ export declare const __test: {
     resolveImportSrc: typeof resolveImportSrc;
     findUnbundledRelativeImports: typeof findUnbundledRelativeImports;
     bundleComponentCode: typeof bundleComponentCode;
+    stripRolldownArtifacts: typeof stripRolldownArtifacts;
+    hoistNamespaceObjects: typeof hoistNamespaceObjects;
+    assertNamespaceObjectsInlined: typeof assertNamespaceObjectsInlined;
+    assertNoEagerForwardRead: typeof assertNoEagerForwardRead;
+    resolveE2eEntryUx: typeof resolveE2eEntryUx;
 };
 export default ViteCompiler;

package/lib/compiler/javascript/ViteCompiler.js

@@ -267,6 +267,27 @@ function collectReachableUx(entryUxFiles) {
   }
   return reachable;
 }
+
+/**
+ * The e2e test entry `.ux` that `--enable-e2e` turns into `router.entry`.
+ *
+ * It is absent from the source manifest — UxAfterCompile registers it only
+ * after compilation — so route-based reachability cannot see it and would skip
+ * it, leaving `router.entry` pointing at a page the package does not contain.
+ */
+function resolveE2eEntryUx(param, originalProjectPath) {
+  if (!param.enableE2e || !param.e2eConfigPath) return null;
+  try {
+    const UxUtil = require('@aiot-toolkit/parser/lib/ux/utils/UxUtil').default;
+    const cfg = UxUtil.getE2eConfig({
+      projectPath: originalProjectPath,
+      e2eConfigPath: param.e2eConfigPath
+    });
+    return _path.default.resolve(cfg.dir, `${cfg.entry.path}.ux`);
+  } catch {
+    return null;
+  }
+}
 function extractAppStyleLiteral(code) {
   const m = code.match(/var\s+\$app_style\$\s*=\s*\[/);
   if (!m) return null;
@@ -755,7 +776,8 @@ class ViteCompiler {
     };
     findUx(srcPath);
     const compiledEntries = new Set(Object.values(entries).map(v => _path.default.resolve(originalProjectPath, v.split('?')[0])));
-    const reachableUx = collectReachableUx([...compiledEntries]);
+    const e2eEntryUx = resolveE2eEntryUx(param, originalProjectPath);
+    const reachableUx = collectReachableUx([...compiledEntries, ...(e2eEntryUx ? [e2eEntryUx] : [])]);
     const skippedUx = [];
     for (const uxFile of allUxFiles) {
       if (compiledEntries.has(uxFile)) continue; // already compiled as entry
@@ -838,6 +860,12 @@ class ViteCompiler {
         console.warn(`vite: failed to emit component ${relPath}:`, e?.message ?? e);
       }
     }
+    if (e2eEntryUx) {
+      const e2eOutJs = _path.default.join(buildPath, `${_path.default.relative(srcPath, e2eEntryUx).replace(/\.ux$/, '')}.js`);
+      if (!_fsExtra.default.existsSync(e2eOutJs)) {
+        throw new Error(`[e2e] --enable-e2e makes ${_path.default.relative(originalProjectPath, e2eEntryUx)} the app entry, ` + `but it produced no output at ${_path.default.relative(buildPath, e2eOutJs)}. ` + `Check that the entry path in ${param.e2eConfigPath} resolves to a .ux under the source root.`);
+      }
+    }
     if (skippedUx.length) {
       this.onLog?.([{
         level: 3,
@@ -962,8 +990,11 @@ function stripRolldownArtifacts(code) {
   // Inline __exportAll calls: __exportAll({key: () => value, ...}) -> {key: value, ...}
   // Match __exportAll(...) or /* @__PURE__ */ __exportAll(...)
   code = code.replace(/(?:\/\* @__PURE__ \*\/\s*)?__exportAll\(\s*\{([\s\S]*?)\}\s*\)/g, (_match, body) => {
-    // Replace each "key: () => value" with "get key() { return value }" for proper live binding
-    const inlined = body.replace(/(\w+)\s*:\s*\(\)\s*=>\s*([^,\n}]+?)([,\n])/g, 'get $1() { return $2; }$3');
+    // A surviving thunk is not a live binding but a function returning one, so
+    // `ns.fn(arg)` drops the argument and returns `fn`. The lookahead (rather than
+    // consuming the separator) is what converts the last property, which is followed
+    // by the closing brace.
+    const inlined = body.replace(/(\w+)\s*:\s*\(\)\s*=>\s*([^,\n}]+?)\s*(?=[,\n]|$)/g, 'get $1() { return $2; }');
     return `{${inlined}}`;
   });
   // Remove Object.defineProperty for Symbol.toStringTag
@@ -991,8 +1022,177 @@ function stripRolldownArtifacts(code) {
   if (!/\b__require\b/.test(code)) {
     code = code.replace(/var __require\s*=\s*\/\*[^*]*\*\/\s*\(\(x\)\s*=>[\s\S]*?}\);\n?/g, '');
   }
+  assertNamespaceObjectsInlined(code);
+  code = hoistNamespaceObjects(code);
+  assertNoEagerForwardRead(code);
   return code;
 }
+
+/** A getter-only object literal: `{ get a() { return a; }, get b() { return b; }}`. */
+function isGetterOnlyLiteral(literal) {
+  const inner = literal.slice(1, -1).trim();
+  if (!inner) return false;
+  return inner.split(/,\s*(?=get\s)/).every(p => /^get\s+\w+\s*\(\)\s*\{\s*return\s+[^;{}]+;?\s*\}\s*,?$/.test(p.trim()));
+}
+
+/**
+ * Move synthesized namespace objects to the top of the flattened scope.
+ *
+ * The `import * as ns` interop bridge reads `ns_exports` from a top-level statement,
+ * so with an import cycle DFS post-order can leave the bridge ahead of the object:
+ * `var` assignment is not hoisted, so it reads undefined and throws before any
+ * `$app_define$` runs. Only getter-only literals move — they have no side effects and
+ * resolve lazily, so relocating one cannot snapshot an undefined or reorder an effect.
+ */
+function hoistNamespaceObjects(code) {
+  const hoisted = [];
+  const out = code.replace(/^[ \t]*var\s+(\w+)\s*=\s*(\{[\s\S]*?\});[ \t]*$\n?/gm, (stmt, name, literal) => {
+    if (!isGetterOnlyLiteral(literal)) return stmt;
+    hoisted.push(`var ${name} = ${literal};`);
+    return '';
+  });
+  return hoisted.length ? `${hoisted.join('\n')}\n${out}` : out;
+}
+
+/** Calls through a surviving thunk table are silently dropped, so refuse to emit one. */
+function assertNamespaceObjectsInlined(code) {
+  if (/\b__exportAll\s*\(/.test(code)) {
+    throw new Error(`[js] a namespace object was emitted through the __exportAll helper instead of being ` + `inlined as getters. Calls through it are silently dropped. Offending code:\n` + code.match(/[^\n]*__exportAll\s*\([^\n]*/)[0]);
+  }
+  const thunk = code.match(/^[ \t]*var\s+\w+_exports\s*=\s*\{[^{}]*?\w+\s*:\s*\(\)\s*=>[^\n]*$/m);
+  if (thunk) {
+    throw new Error(`[js] namespace object still holds a thunk property instead of a getter; calls ` + `through it are silently dropped. Offending code:\n${thunk[0]}`);
+  }
+}
+
+/**
+ * Reject a top-level `var` whose eager initializer reads an identifier assigned by a
+ * later top-level `var` — the read yields undefined, which is how an import cycle
+ * surfaces once module bodies are flattened into one scope.
+ */
+function assertNoEagerForwardRead(code) {
+  const stmts = topLevelVarStatements(code);
+  const assignedAt = new Map();
+  for (const s of stmts) if (!assignedAt.has(s.name)) assignedAt.set(s.name, s.at);
+  for (const {
+    name,
+    init,
+    at
+  } of stmts) {
+    if (isLazyInitializer(init)) continue;
+    for (const ref of maskNonReferences(init).matchAll(/[A-Za-z_$][\w$]*/g)) {
+      const refAt = assignedAt.get(ref[0]);
+      if (ref[0] !== name && refAt !== undefined && refAt > at) {
+        throw new Error(`[js] top-level \`var ${name}\` is evaluated before \`${ref[0]}\` is assigned ` + `(assignment appears later in the flattened scope), so it reads undefined. ` + `This is a module ordering bug, usually an import cycle.\n  var ${name} = ${init};`);
+      }
+    }
+  }
+}
+function isLazyInitializer(init) {
+  // A `{` means a block or object literal, where the name may sit in a method or getter
+  // body that runs later — or be a property key, which is no reference at all. Skipping
+  // those trades coverage inside object literals for freedom from false positives.
+  return init.includes('{') || /\bfunction\b|=>|\bclass\b/.test(init);
+}
+
+/** Blank out what looks like an identifier but cannot be a binding reference. */
+function maskNonReferences(src) {
+  return src.replace(/'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"|`(?:\\.|[^`\\])*`/g, '""').replace(/\.\s*[A-Za-z_$][\w$]*/g, '');
+}
+
+/**
+ * Split top-level `var NAME = INIT;` statements.
+ *
+ * Needs a real scan rather than a per-line regex: initializers do span lines in bundler
+ * output (array literals, multi-line template literals), and a line-based split would
+ * read template-literal text as identifiers.
+ */
+function topLevelVarStatements(code) {
+  const out = [];
+  let depth = 0;
+  let i = 0;
+  while (i < code.length) {
+    const c = code[i];
+    if (c === '{' || c === '(' || c === '[') {
+      depth++;
+      i++;
+      continue;
+    }
+    if (c === '}' || c === ')' || c === ']') {
+      depth--;
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === '`') {
+      i = skipString(code, i);
+      continue;
+    }
+    if (c === '/' && code[i + 1] === '/') {
+      i = code.indexOf('\n', i);
+      if (i === -1) break;
+      continue;
+    }
+    if (c === '/' && code[i + 1] === '*') {
+      i = code.indexOf('*/', i);
+      if (i === -1) break;
+      i += 2;
+      continue;
+    }
+    if (depth === 0 && code.startsWith('var ', i) && (i === 0 || /[\s;}]/.test(code[i - 1]))) {
+      const m = /^var\s+([\w$]+)\s*=\s*/.exec(code.slice(i));
+      if (m) {
+        const initStart = i + m[0].length;
+        const end = findStatementEnd(code, initStart);
+        out.push({
+          name: m[1],
+          init: code.slice(initStart, end).trim(),
+          at: i
+        });
+        i = end;
+        continue;
+      }
+    }
+    i++;
+  }
+  return out;
+}
+function skipString(code, start) {
+  const quote = code[start];
+  let i = start + 1;
+  while (i < code.length) {
+    if (code[i] === '\\') {
+      i += 2;
+      continue;
+    }
+    if (code[i] === quote) return i + 1;
+    i++;
+  }
+  return i;
+}
+function findStatementEnd(code, start) {
+  let depth = 0;
+  let i = start;
+  while (i < code.length) {
+    const c = code[i];
+    if (c === '{' || c === '(' || c === '[') {
+      depth++;
+      i++;
+      continue;
+    }
+    if (c === '}' || c === ')' || c === ']') {
+      depth--;
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === '`') {
+      i = skipString(code, i);
+      continue;
+    }
+    if (depth === 0 && (c === ';' || c === '\n')) return i;
+    i++;
+  }
+  return i;
+}
 function wrapOutput(code, entryName, isApp) {
   const componentName = _path.default.parse(entryName).name;
   const defineId = isApp ? '@app-component/app' : `@app-component/${componentName}`;
@@ -1084,6 +1284,11 @@ const __test = exports.__test = {
   collectReachableUx,
   resolveImportSrc,
   findUnbundledRelativeImports,
-  bundleComponentCode
+  bundleComponentCode,
+  stripRolldownArtifacts,
+  hoistNamespaceObjects,
+  assertNamespaceObjectsInlined,
+  assertNoEagerForwardRead,
+  resolveE2eEntryUx
 };
 var _default = exports.default = ViteCompiler;

package/lib/compiler/javascript/interface/IJavascriptCompileOption.d.ts

@@ -44,6 +44,10 @@ interface IJavascriptCompileOption extends ICompileParam {
      * 启用 VRU 包装格式（release 模式生成 manifest+CERT+inner-vru 的双层 RPK）
      */
     enableVru?: boolean;
+    /**
+     * 输出旧包格式：模板与样式内联进 webpack 打包的 JS，不生成 template.json / css.json
+     */
+    legacy?: boolean;
     /**
      * 启用 protobuf
      */

package/lib/compiler/javascript/vela/plugin/WrapPlugin.d.ts

@@ -14,6 +14,13 @@ declare class WrapPlugin {
      * Clean a module body into blueos-pack format component block
      */
     private buildBlock;
+    /**
+     * The legacy entry wrapper: a plain IIFE that hands the runtime globals to the
+     * bundle. It performs no rewriting of the bundle body, so the inlined
+     * `$app_template$`/`$app_style$` and the `module.exports` the page script relies
+     * on survive — which is exactly what the legacy format needs.
+     */
+    private wrapLegacy;
     private wrap;
 }
 export default WrapPlugin;

package/lib/compiler/javascript/vela/plugin/WrapPlugin.js

@@ -178,7 +178,47 @@ class WrapPlugin {
     const lines = [`let $style$${styleId} = {"@info":{"styleObjectId":${styleId}}};`, `const $app_style$${styleId} = $style$${styleId};`, ...(s.trim() ? [s.trim()] : []), ...(templateCode ? [templateCode] : []), `const $app_script$${styleId} = ${obj};`, `$app_define$("${defineId}", [], function($app_require$, $app_exports$, $app_module$) {`, `  $app_module$.exports = $app_script$${styleId}.default || $app_script$${styleId};`, `  $app_module$.exports.style = $app_style$${styleId};`, ...(templateCode ? [`  $app_module$.exports.template = $app_template$;`] : []), `});`];
     return lines.join('\n');
   }
+  /**
+   * The legacy entry wrapper: a plain IIFE that hands the runtime globals to the
+   * bundle. It performs no rewriting of the bundle body, so the inlined
+   * `$app_template$`/`$app_style$` and the `module.exports` the page script relies
+   * on survive — which is exactly what the legacy format needs.
+   */
+  wrapLegacy(compilation) {
+    const {
+      enableE2e
+    } = this.compilerOption;
+    const entrys = Object.keys(compilation.options.entry).map(item => `${item}.js`);
+    entrys.forEach(entry => {
+      if (!compilation.assets[entry]) return;
+      const source = compilation.assets[entry];
+      const isApp = entry === 'app.js';
+      const createFuncnName = isApp ? 'createAppHandler' : 'createPageHandler';
+      compilation.assets[entry] = new _webpackSources.ConcatSource(`export default function(global, globalThis, window, $app_exports$, $app_evaluate$){
+          var org_app_require = $app_require$;
+        
+          (function(global, globalThis, window, $app_exports$, $app_evaluate$){
+            var setTimeout = global.setTimeout;
+            var setInterval = global.setInterval;
+            var clearTimeout = global.clearTimeout;
+            var clearInterval = global.clearInterval;
+            var $app_require$ = global.$app_require$ || org_app_require
+
+            ${enableE2e ? `globalThis = undefined; \n global = typeof window === "undefined" ? global.__proto__  : window;` : ''}
+            var ${createFuncnName} = function() {
+              return `, source, `
+            }
+        
+            return ${createFuncnName}();
+          })(global, globalThis, window, $app_exports$, $app_evaluate$)
+        }`);
+    });
+  }
   wrap(compilation) {
+    if (this.compilerOption.legacy) {
+      this.wrapLegacy(compilation);
+      return;
+    }
     const entrys = Object.keys(compilation.options.entry).map(item => `${item}.js`);
     entrys.forEach(entry => {
       if (!compilation.assets[entry]) return;

package/lib/compiler/javascript/vela/utils/Jsc.d.ts

@@ -1,13 +1,17 @@
 declare class Jsc {
     readonly projectPath: string;
     readonly buildPath: string;
-    constructor(projectPath: string, buildPath: string);
+    /** The legacy format carries its own entry wrapper from WrapPlugin. */
+    readonly legacy: boolean;
+    constructor(projectPath: string, buildPath: string, 
+    /** The legacy format carries its own entry wrapper from WrapPlugin. */
+    legacy?: boolean);
     jsc(deleteJs?: boolean): Promise<boolean>;
     private logBeforeInvoke;
     private logAfterInvoke;
     private static listFiles;
     private assertJscVersion;
-    static wrapAllJsWithIife(buildPath: string): void;
+    static wrapAllJsWithIife(buildPath: string, legacy?: boolean): void;
     private static assertLegacyGlobalBinding;
     private static compareSemver;
 }

package/lib/compiler/javascript/vela/utils/Jsc.js

@@ -9,7 +9,7 @@ var path = _interopRequireWildcard(require("path"));
 var _sharedUtils = require("@aiot-toolkit/shared-utils");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-const REQUIRED_JSC_VERSION = '1.0.9';
+const REQUIRED_JSC_VERSION = '1.0.10';
 
 // `__ctx` is the page scope whose prototype is `ferryGlobal` (where the runtime
 // registers `runGC` and friends). A bare `global` in legacy page source resolves
@@ -28,8 +28,10 @@ const IIFE_WRAP_SUFFIX = '\n});\n';
 const JSC_ARGS = ['-s'];
 class Jsc {
   constructor(projectPath, buildPath) {
+    let legacy = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     this.projectPath = projectPath;
     this.buildPath = buildPath;
+    this.legacy = legacy;
   }
   jsc() {
     let deleteJs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
@@ -41,7 +43,7 @@ class Jsc {
     return _sharedUtils.CommonUtil.requireNodeModule(projectPath, `@aiot-toolkit/jsc`).then(async module => {
       this.logBeforeInvoke();
       this.assertJscVersion();
-      Jsc.wrapAllJsWithIife(buildPath);
+      Jsc.wrapAllJsWithIife(buildPath, this.legacy);
       const start = Date.now();
       const msg = await module.default(buildPath, JSC_ARGS);
       const elapsed = Date.now() - start;
@@ -158,6 +160,10 @@ class Jsc {
     }
   }
   static wrapAllJsWithIife(buildPath) {
+    let legacy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    // The legacy format is already wrapped by WrapPlugin into the
+    // `export default function(global, globalThis, window, ...)` entry shape.
+    if (legacy) return;
     for (const {
       rel
     } of Jsc.listFiles(buildPath, '.js')) {

package/lib/compiler/javascript/vela/utils/ZipUtil.js

@@ -394,7 +394,11 @@ class ZipUtil {
       platform: process.platform,
       arch: process.arch,
       component: true,
-      json: true
+      // Runtimes pick the package format from this marker: `json=true` selects the
+      // JSON-template pipeline, its absence the legacy one.
+      ...(param.legacy ? {} : {
+        json: true
+      })
     };
     return obj;
   }

package/lib/utils/ux/UxLoaderUtils.js

@@ -120,7 +120,9 @@ class UxLoaderUtils {
     if (_fsExtra.default.existsSync(manifestPath)) {
       manifestContent = _fsExtra.default.readFileSync(manifestPath, 'utf-8').trim();
     }
-    const manifestJson = `JSON.parse('${manifestContent.replace(/'/g, "\\'").replace(/\n/g, '')}')`;
+    // webpack resolves the require; rolldown cannot, so the Vite pipeline inlines
+    // the parsed content instead.
+    const manifestJson = compilerOption.legacy ? `require('./manifest.json')` : `JSON.parse('${manifestContent.replace(/'/g, "\\'").replace(/\n/g, '')}')`;
     function translateStyleFunc() {
       return `
   var $translateStyle$ = function (value) {
@@ -159,9 +161,15 @@ class UxLoaderUtils {
 
       // script代码放在第三个位置不能变化，影响更新source map
       const createAppWrapper = () => {
+        if (compilerOption.legacy) {
+          return [`${appImport.join('\n')}`, `var $app_style$ = ${UxLoaderUtils.wrapStyle(appStyleTree, file, compilerOption)}`, hasScript ? `var $app_script$ = ${UxLoaderUtils.wrapScript(false, appScriptTree)}` : '', hasScript ? `$app_script$({}, $app_exports$, $app_require$);` : `$app_exports$.default = {}`, `$app_exports$.default.style = $app_style$;`, `$app_exports$.default.manifest = ${manifestJson}`, translateStyleFunc()];
+        }
         return [`${appImport.join('\n')}`, `var $app_style$ = ${UxLoaderUtils.wrapStyle(appStyleTree, file, compilerOption)}`, hasScript ? appScriptTree.getFullText() : 'export default {};'];
       };
       const createComponentWrapper = () => {
+        if (compilerOption.legacy) {
+          return [`${appImport.join('\n')}`, `var $app_style$ = ${UxLoaderUtils.wrapStyle(appStyleTree, file, compilerOption)}`, hasScript ? `var $app_script$ = ${UxLoaderUtils.wrapScript(isPageUx, appScriptTree)}` : '', `var $app_template$ = ${UxLoaderUtils.wrapTempalte(appTemplateTree, file, compilerOption)}`, `${UxLoaderUtils.getReturnType(isPageUx)} function ($app_exports$) {`, hasScript ? `$app_script$({}, $app_exports$, $app_require$);` : `$app_exports$.default = {}`, `$app_exports$.default.template = $app_template$;`, `$app_exports$.default.style = $app_style$;`, `}`];
+        }
         return [`${appImport.join('\n')}`, `var $app_style$ = ${UxLoaderUtils.wrapStyle(appStyleTree, file, compilerOption)}`, hasScript ? appScriptTree.getFullText() : 'export default {};'];
       };
       if (isAppUx) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiot-toolkit/aiotpack",
-  "version": "2.1.0-prender.16",
+  "version": "2.1.0-prender.18",
   "description": "The process tool for packaging aiot projects.",
   "keywords": [
     "aiotpack"
@@ -19,16 +19,15 @@
     "test": "node ./__tests__/aiotpack.test.js"
   },
   "dependencies": {
-    "@aiot-toolkit/generator": "2.1.0-prender.16",
-    "@aiot-toolkit/parser": "2.1.0-prender.16",
-    "@aiot-toolkit/shared-utils": "2.1.0-prender.16",
+    "@aiot-toolkit/generator": "2.1.0-prender.18",
+    "@aiot-toolkit/parser": "2.1.0-prender.18",
+    "@aiot-toolkit/shared-utils": "2.1.0-prender.18",
     "@hap-toolkit/aaptjs": "^2.0.0",
-    "@rspack/core": "^1.3.9",
     "acorn": "^8.16.0",
     "aiot-parse5": "^1.0.2",
     "astring": "^1.9.0",
     "babel-loader": "^9.1.3",
-    "file-lane": "2.1.0-prender.16",
+    "file-lane": "2.1.0-prender.18",
     "file-loader": "^6.2.0",
     "fs-extra": "^11.2.0",
     "jsrsasign": "^11.1.0",
@@ -40,6 +39,14 @@
     "webpack-bundle-analyzer": "^4.10.2",
     "webpack-sources": "^3.2.3"
   },
+  "peerDependencies": {
+    "@rspack/core": "^1.3.9"
+  },
+  "peerDependenciesMeta": {
+    "@rspack/core": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/jsrsasign": "^10.5.12",