@aiot-toolkit/aiotpack 2.1.0-prender.15 → 2.1.0-prender.17

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

@@ -3,6 +3,48 @@ import ICompileParam from '../interface/ICompileParam';
 import ICompiler from '../interface/ICompiler';
 import { ILog } from '@aiot-toolkit/shared-utils';
 import { IFileLaneContext } from 'file-lane';
+/**
+ * Resolve an `<import src>` value to an absolute `.ux` path, accepting the
+ * extensionless and directory forms the loader also accepts.
+ */
+declare function resolveImportSrc(fromUxFile: string, src: string): string | null;
+/**
+ * `.ux` files reachable from the routed pages, following `<import src>` chains.
+ *
+ * aiot-toolkit 1.x only compiled routed pages (components were bundled into the
+ * host page), so a `.ux` that no route reaches never produced output. 2.x walks
+ * every `.ux` on disk, which ships dead files and surfaces their defects as
+ * build failures — prerender-apps/idiom has an unrouted `pages/index` whose
+ * leftover `import page from './index.js'` failed the build for a page no route
+ * can open.
+ */
+declare function collectReachableUx(entryUxFiles: string[]): Set<string>;
+/**
+ * Relative ESM imports a sub-component declares that nothing downstream can
+ * resolve: `.ux` imports are loader-generated and dropped later, and
+ * `@system.*`/`@app-module` imports become `$app_require$` calls.
+ */
+declare function findUnbundledRelativeImports(code: string): string[];
+/**
+ * Inline a sub-component's relative `.js`/`.ts` dependencies.
+ *
+ * An entry page is bundled by rolldown, so `import page from './index.js'`
+ * is inlined. A sub-component was instead compiled file-by-file by
+ * `UxLoaderUtils.compileUxToJavascript` with no bundler, leaving the statement
+ * in place — fatal, because the IIFE wrapper nests it in a function body. Run
+ * the same rolldown pipeline over the compiled component so such a dependency
+ * is resolved the way a page's is.
+ *
+ * The entry is a virtual module placed in the component's own directory, so
+ * relative specifiers resolve against the component without writing to disk.
+ * Components with no such import return unchanged, keeping the common case free.
+ */
+declare function bundleComponentCode(compCode: string, uxFile: string, srcPath: string, param: IJavascriptCompileOption, userVite: {
+    define?: Record<string, string>;
+    plugins?: any[];
+    resolve?: any;
+    build?: any;
+}): Promise<string>;
 declare class ViteCompiler implements ICompiler {
     private readonly context;
     private readonly onLog?;
@@ -22,11 +64,57 @@ declare function stripDeadDefProp(code: string): string;
  * leaves `vibrator` as a free identifier, which is why the 咪咕/百度地图 keyboard
  * could no longer vibrate.
  */
+/**
+ * `<import name="comp-score" src="../Score/index.ux">` is compiled by the ux
+ * loader into `import comp_score_comp from '../Score/index.ux'`, but a
+ * sub-component is resolved purely through data: template.json carries
+ * `{type, import}` and the component's own `.js` registers
+ * `$app_define$("@app-component/<name>")`. The binding is never read, and
+ * leaving the statement in place is a hard error — the IIFE wrapper nests it
+ * inside a function body, where `import` is a syntax error.
+ *
+ * Only drop it when the binding is provably unused; a referenced binding means
+ * the loader contract changed and silently dropping it would reintroduce the
+ * free-identifier class of bug, so leave it for the caller's guard to report.
+ */
+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;
     mergeStyleSheets: typeof mergeStyleSheets;
     buildComponentJs: typeof buildComponentJs;
+    dropUnusedUxImports: typeof dropUnusedUxImports;
+    collectReachableUx: typeof collectReachableUx;
+    resolveImportSrc: typeof resolveImportSrc;
+    findUnbundledRelativeImports: typeof findUnbundledRelativeImports;
+    bundleComponentCode: typeof bundleComponentCode;
+    stripRolldownArtifacts: typeof stripRolldownArtifacts;
+    hoistNamespaceObjects: typeof hoistNamespaceObjects;
+    assertNamespaceObjectsInlined: typeof assertNamespaceObjectsInlined;
+    assertNoEagerForwardRead: typeof assertNoEagerForwardRead;
 };
 export default ViteCompiler;

package/lib/compiler/javascript/ViteCompiler.js

@@ -216,6 +216,57 @@ function extractLegacyDefinePluginEntries(projectPath, configPath, mode) {
   } catch {/* swallow config load errors */}
   return captured;
 }
+
+/**
+ * Resolve an `<import src>` value to an absolute `.ux` path, accepting the
+ * extensionless and directory forms the loader also accepts.
+ */
+function resolveImportSrc(fromUxFile, src) {
+  const base = _path.default.resolve(_path.default.dirname(fromUxFile), src);
+  for (const cand of [base, `${base}.ux`, _path.default.join(base, 'index.ux')]) {
+    if (cand.endsWith('.ux') && _fsExtra.default.existsSync(cand)) return cand;
+  }
+  return null;
+}
+
+/**
+ * `.ux` files reachable from the routed pages, following `<import src>` chains.
+ *
+ * aiot-toolkit 1.x only compiled routed pages (components were bundled into the
+ * host page), so a `.ux` that no route reaches never produced output. 2.x walks
+ * every `.ux` on disk, which ships dead files and surfaces their defects as
+ * build failures — prerender-apps/idiom has an unrouted `pages/index` whose
+ * leftover `import page from './index.js'` failed the build for a page no route
+ * can open.
+ */
+function collectReachableUx(entryUxFiles) {
+  const parse5 = require('aiot-parse5');
+  const reachable = new Set();
+  const worklist = [...entryUxFiles];
+  while (worklist.length) {
+    const uxFile = worklist.pop();
+    const key = _path.default.resolve(uxFile);
+    if (reachable.has(key)) continue;
+    if (!_fsExtra.default.existsSync(key)) continue;
+    reachable.add(key);
+    let doc;
+    try {
+      doc = parse5.parseFragment(_fsExtra.default.readFileSync(key, 'utf-8'), {
+        scriptingEnabled: false
+      });
+    } catch {
+      continue;
+    }
+    for (const node of doc.childNodes ?? []) {
+      if (node.nodeName !== 'import') continue;
+      const srcAttr = node.attrs?.find(a => a.name === 'src');
+      if (!srcAttr) continue;
+      const resolved = resolveImportSrc(key, srcAttr.value);
+      if (resolved) worklist.push(resolved);
+    }
+  }
+  return reachable;
+}
 function extractAppStyleLiteral(code) {
   const m = code.match(/var\s+\$app_style\$\s*=\s*\[/);
   if (!m) return null;
@@ -243,6 +294,161 @@ function extractAppStyleLiteral(code) {
   }
   return null;
 }
+/** Single dynamic-import site for vite, whose types this tsconfig cannot see. */
+async function loadViteBuild() {
+  const {
+    build
+  } = await import('vite');
+  return build;
+}
+
+/**
+ * Plugins shared by the page-entry build and the sub-component bundler, so a
+ * component's dependencies are transformed exactly like a page's.
+ */
+function makeSharedPlugins(srcPath) {
+  return [{
+    name: 'image-asset-string',
+    enforce: 'pre',
+    load(id) {
+      // require("./x.png") in .ux <script> must resolve to a path string,
+      // matching webpack file-loader / vivo blueos-pack semantics. Without
+      // this hook rolldown treats each image as an ES module and emits
+      // `(init_x(), __toCommonJS(x_exports))` — the site assigns
+      // `{ default: fn }` to src and runtime cannot render.
+      const match = id.match(/\.(png|jpe?g|gif|svg|webp|bmp|ico)(\?.*)?$/i);
+      if (!match) return null;
+      const filePath = id.replace(/\?.*$/, '');
+      if (!_fsExtra.default.existsSync(filePath)) return null;
+      const relFromSrc = _path.default.relative(srcPath, filePath).split(_path.default.sep).join('/');
+      // Assets outside src/ (typically node_modules) fall through to the
+      // default asset handler — the caller is responsible for their path
+      // resolution. Vivo blueos-pack + webpack file-loader use rpk-root
+      // absolute paths (`/common/...`, `/dynamicAssets/name-hash.png`);
+      // runtime <image src> resolves against the rpk root, so relative
+      // `./common/...` from a nested page directory would misdirect.
+      if (relFromSrc.startsWith('..')) return null;
+      const runtimePath = '/' + relFromSrc;
+      return `module.exports = ${JSON.stringify(runtimePath)};`;
+    }
+  }, {
+    name: "cjs-shim",
+    enforce: "pre",
+    load(id) {
+      if (id.includes('node_modules') && !id.endsWith('.ux')) {
+        const content = _fsExtra.default.readFileSync(id, 'utf-8');
+        if (content.includes('module.exports') || content.includes('exports.')) {
+          return `var module = {exports:{}}; var exports = module.exports;\n${content}\nexport default module.exports;`;
+        }
+      }
+      return null;
+    }
+  }, {
+    name: 'system-to-app-require',
+    enforce: 'pre',
+    transform(code, id) {
+      const out = rewriteSystemImports(code);
+      return out !== code ? {
+        code: out,
+        map: null
+      } : null;
+    }
+  }, {
+    name: 'namespace-preserve',
+    enforce: 'pre',
+    transform(code, id) {
+      if (!/import\s*\*\s*as\s+\w+\s+from/.test(code)) return null;
+      // Rolldown resolves `import * as L from './x'; L.foo()` at compile time —
+      // if `foo` isn't exported by `./x` the call collapses to `(void 0)()` and
+      // the source identifier is lost. Rewriting the alias to a runtime variable
+      // (with webpack-style default-interop) preserves the identifier so runtime
+      // errors point at the actual source name.
+      const out = code.replace(/import\s*\*\s*as\s+(\w+)\s+from\s+(['"][^'"]+['"])/g, (_m, local, src) => {
+        const ns = `__${local}_ns`,
+          key = `__${local}_key`;
+        return `import * as ${ns} from ${src}; const ${key} = 'default'; const ${local} = ${ns}[${key}] != null ? ${ns}[${key}] : ${ns};`;
+      });
+      return out !== code ? {
+        code: out,
+        map: null
+      } : null;
+    }
+  }];
+}
+
+/**
+ * Relative ESM imports a sub-component declares that nothing downstream can
+ * resolve: `.ux` imports are loader-generated and dropped later, and
+ * `@system.*`/`@app-module` imports become `$app_require$` calls.
+ */
+function findUnbundledRelativeImports(code) {
+  const out = [];
+  const re = /^[ \t]*import\s[^\n]*?\sfrom\s+(['"])(\.[^'"]*)\1/gm;
+  for (const m of code.matchAll(re)) {
+    if (!m[2].endsWith('.ux')) out.push(m[2]);
+  }
+  return out;
+}
+
+/**
+ * Inline a sub-component's relative `.js`/`.ts` dependencies.
+ *
+ * An entry page is bundled by rolldown, so `import page from './index.js'`
+ * is inlined. A sub-component was instead compiled file-by-file by
+ * `UxLoaderUtils.compileUxToJavascript` with no bundler, leaving the statement
+ * in place — fatal, because the IIFE wrapper nests it in a function body. Run
+ * the same rolldown pipeline over the compiled component so such a dependency
+ * is resolved the way a page's is.
+ *
+ * The entry is a virtual module placed in the component's own directory, so
+ * relative specifiers resolve against the component without writing to disk.
+ * Components with no such import return unchanged, keeping the common case free.
+ */
+async function bundleComponentCode(compCode, uxFile, srcPath, param, userVite) {
+  if (findUnbundledRelativeImports(compCode).length === 0) return compCode;
+  const virtualId = _path.default.join(_path.default.dirname(uxFile), `__component_entry__${_path.default.basename(uxFile)}.js`);
+  const build = await loadViteBuild();
+  const result = await build({
+    root: _path.default.dirname(uxFile),
+    logLevel: 'silent',
+    define: userVite.define ?? {},
+    resolve: {
+      extensions: ['.js', '.ts', '.ux', '.json'],
+      ...(userVite.resolve ?? {})
+    },
+    build: {
+      write: false,
+      lib: {
+        entry: virtualId,
+        formats: ['es'],
+        fileName: () => 'component.js'
+      },
+      rollupOptions: {
+        external: id => id.startsWith('@app-module/') || /^@(system|service|android|hap)\./.test(id)
+      },
+      commonjsOptions: {
+        transformMixedEsModules: true
+      },
+      minify: false
+    },
+    plugins: [{
+      name: 'component-virtual-entry',
+      enforce: 'pre',
+      resolveId(source) {
+        return source === virtualId ? virtualId : null;
+      },
+      load(id) {
+        return id === virtualId ? compCode : null;
+      }
+    }, ...makeSharedPlugins(srcPath), ...(userVite.plugins ?? [])]
+  });
+  const outputs = Array.isArray(result) ? result[0]?.output : result?.output;
+  const code = outputs?.[0]?.code;
+  if (!code) {
+    throw new Error(`[component] ${_path.default.relative(srcPath, uxFile)} bundling produced no output; ` + `its relative import(s) ${findUnbundledRelativeImports(compCode).join(', ')} could not be inlined.`);
+  }
+  return code;
+}
 class ViteCompiler {
   constructor(context, onLog) {
     this.context = context;
@@ -290,9 +496,7 @@ class ViteCompiler {
         entries: allEntryPaths
       };
       try {
-        const {
-          build
-        } = await import('vite');
+        const build = await loadViteBuild();
         const result = await build({
           root: originalProjectPath,
           logLevel: 'silent',
@@ -341,73 +545,7 @@ class ViteCompiler {
               }
             }
           },
-          plugins: [{
-            name: 'image-asset-string',
-            enforce: 'pre',
-            load(id) {
-              // require("./x.png") in .ux <script> must resolve to a path string,
-              // matching webpack file-loader / vivo blueos-pack semantics. Without
-              // this hook rolldown treats each image as an ES module and emits
-              // `(init_x(), __toCommonJS(x_exports))` — the site assigns
-              // `{ default: fn }` to src and runtime cannot render.
-              const match = id.match(/\.(png|jpe?g|gif|svg|webp|bmp|ico)(\?.*)?$/i);
-              if (!match) return null;
-              const filePath = id.replace(/\?.*$/, '');
-              if (!_fsExtra.default.existsSync(filePath)) return null;
-              const relFromSrc = _path.default.relative(srcPath, filePath).split(_path.default.sep).join('/');
-              // Assets outside src/ (typically node_modules) fall through to the
-              // default asset handler — the caller is responsible for their path
-              // resolution. Vivo blueos-pack + webpack file-loader use rpk-root
-              // absolute paths (`/common/...`, `/dynamicAssets/name-hash.png`);
-              // runtime <image src> resolves against the rpk root, so relative
-              // `./common/...` from a nested page directory would misdirect.
-              if (relFromSrc.startsWith('..')) return null;
-              const runtimePath = '/' + relFromSrc;
-              return `module.exports = ${JSON.stringify(runtimePath)};`;
-            }
-          }, {
-            name: "cjs-shim",
-            enforce: "pre",
-            load(id) {
-              if (id.includes('node_modules') && !id.endsWith('.ux')) {
-                const content = _fsExtra.default.readFileSync(id, 'utf-8');
-                if (content.includes('module.exports') || content.includes('exports.')) {
-                  return `var module = {exports:{}}; var exports = module.exports;\n${content}\nexport default module.exports;`;
-                }
-              }
-              return null;
-            }
-          }, {
-            name: 'system-to-app-require',
-            enforce: 'pre',
-            transform(code, id) {
-              const out = rewriteSystemImports(code);
-              return out !== code ? {
-                code: out,
-                map: null
-              } : null;
-            }
-          }, {
-            name: 'namespace-preserve',
-            enforce: 'pre',
-            transform(code, id) {
-              if (!/import\s*\*\s*as\s+\w+\s+from/.test(code)) return null;
-              // Rolldown resolves `import * as L from './x'; L.foo()` at compile time —
-              // if `foo` isn't exported by `./x` the call collapses to `(void 0)()` and
-              // the source identifier is lost. Rewriting the alias to a runtime variable
-              // (with webpack-style default-interop) preserves the identifier so runtime
-              // errors point at the actual source name.
-              const out = code.replace(/import\s*\*\s*as\s+(\w+)\s+from\s+(['"][^'"]+['"])/g, (_m, local, src) => {
-                const ns = `__${local}_ns`,
-                  key = `__${local}_key`;
-                return `import * as ${ns} from ${src}; const ${key} = 'default'; const ${local} = ${ns}[${key}] != null ? ${ns}[${key}] : ${ns};`;
-              });
-              return out !== code ? {
-                code: out,
-                map: null
-              } : null;
-            }
-          }, {
+          plugins: [...makeSharedPlugins(srcPath), {
             name: 'ux-loader',
             resolveId(source, importer) {
               if (source.endsWith('.ux')) {
@@ -554,7 +692,9 @@ class ViteCompiler {
                       spaces: 2
                     });
                     const compJsPath = _path.default.join(buildPath, `${compPath}.js`);
-                    _fsExtra.default.writeFileSync(compJsPath, buildComponentJs(compCode, compName, compSid, compPath));
+                    // Style data was already read off the unbundled code above.
+                    const compBundled = await bundleComponentCode(compCode, compUxPath, srcPath, param, userVite);
+                    _fsExtra.default.writeFileSync(compJsPath, buildComponentJs(compBundled, compName, compSid, compPath));
                   }
                 }
               }
@@ -615,9 +755,15 @@ 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 skippedUx = [];
     for (const uxFile of allUxFiles) {
       if (compiledEntries.has(uxFile)) continue; // already compiled as entry
       if (uxFile.replace(/\\/g, '/').endsWith('/app.ux')) continue; // app.ux handled separately
+      if (!reachableUx.has(_path.default.resolve(uxFile))) {
+        skippedUx.push(_path.default.relative(srcPath, uxFile).replace(/\\/g, '/'));
+        continue;
+      }
       const relPath = _path.default.relative(srcPath, uxFile).replace(/\.ux$/, '');
       const outputJs = _path.default.join(buildPath, `${relPath}.js`);
       const outputTpl = _path.default.join(buildPath, `${relPath}.template.json`);
@@ -683,7 +829,8 @@ class ViteCompiler {
         // Generate js
         const compName = _path.default.basename(relPath).toLowerCase();
         _fsExtra.default.ensureDirSync(_path.default.dirname(outputJs));
-        _fsExtra.default.writeFileSync(outputJs, buildComponentJs(compCode, compName, sid, relPath));
+        const bundled = await bundleComponentCode(compCode, uxFile, srcPath, param, userVite);
+        _fsExtra.default.writeFileSync(outputJs, buildComponentJs(bundled, compName, sid, relPath));
       } catch (e) {
         // A component that fails to emit renders but has no behaviour, so don't
         // swallow the guard errors that report exactly why.
@@ -691,6 +838,12 @@ class ViteCompiler {
         console.warn(`vite: failed to emit component ${relPath}:`, e?.message ?? e);
       }
     }
+    if (skippedUx.length) {
+      this.onLog?.([{
+        level: 3,
+        message: [`Skipped ${skippedUx.length} .ux file(s) not reachable from any route or <import> chain ` + `(matches aiot-toolkit 1.x, which only compiled routed pages): ${skippedUx.join(', ')}. ` + `If one of these is opened by a dynamic router call, add it to manifest.json router.pages.`]
+      }]);
+    }
   }
   async clean(param) {
     const {
@@ -717,6 +870,27 @@ function stripDeadDefProp(code) {
  * leaves `vibrator` as a free identifier, which is why the 咪咕/百度地图 keyboard
  * could no longer vibrate.
  */
+/**
+ * `<import name="comp-score" src="../Score/index.ux">` is compiled by the ux
+ * loader into `import comp_score_comp from '../Score/index.ux'`, but a
+ * sub-component is resolved purely through data: template.json carries
+ * `{type, import}` and the component's own `.js` registers
+ * `$app_define$("@app-component/<name>")`. The binding is never read, and
+ * leaving the statement in place is a hard error — the IIFE wrapper nests it
+ * inside a function body, where `import` is a syntax error.
+ *
+ * Only drop it when the binding is provably unused; a referenced binding means
+ * the loader contract changed and silently dropping it would reintroduce the
+ * free-identifier class of bug, so leave it for the caller's guard to report.
+ */
+function dropUnusedUxImports(code) {
+  const uxImport = /^[ \t]*import\s+(\w+)\s+from\s+(['"])([^'"]*\.ux)\2[ \t]*;?[ \t]*$\n?/gm;
+  return code.replace(uxImport, (stmt, binding) => {
+    const rest = code.replace(stmt, '');
+    const used = new RegExp(`\\b${binding}\\b`).test(rest);
+    return used ? stmt : '';
+  });
+}
 function buildComponentJs(compCode, compName, compSid, relPath) {
   let code = compCode;
   // The raw `var $app_style$ = [...]` array is superseded by the $app_style$<sid>
@@ -733,7 +907,22 @@ function buildComponentJs(compCode, compName, compSid, relPath) {
   }
   // Turn @system.*/@app-module imports into $app_require$ calls, same as entries.
   code = rewriteSystemImports(code);
-  let defaultExpr = '{}';
+  const hadDefault = /export\s+default\s|\bas\s+(?:default\b|["']default["'])/.test(code);
+  // Bundled components come straight from rolldown, which leaves region markers
+  // and runtime helpers behind and re-exports the default as
+  // `export { X as default }` rather than `export default`.
+  code = stripRolldownArtifacts(code);
+  // Must run before the `export default` expression is sliced off, otherwise a
+  // binding referenced only inside that expression reads as unused.
+  code = dropUnusedUxImports(code);
+  let defaultExpr = null;
+  const asDefault = code.match(/export\s*\{\s*(\w+)\s+as\s+default\s*(?:,[^}]*)?\}\s*;?/);
+  if (asDefault) {
+    defaultExpr = asDefault[1];
+    code = code.replace(asDefault[0], '');
+  }
+  // Remaining named exports have no consumer in a $app_define$ module.
+  code = code.replace(/^[ \t]*export\s*\{[^}]*\}\s*;?[ \t]*$\n?/gm, '');
   const edIdx = code.search(/export\s+default\s+/);
   if (edIdx !== -1) {
     const kw = code.slice(edIdx).match(/^export\s+default\s+/);
@@ -746,37 +935,22 @@ function buildComponentJs(compCode, compName, compSid, relPath) {
   if (leftoverImport) {
     throw new Error(`[component] ${relPath} has an unresolved ESM import that cannot be emitted into a ` + `standalone $app_define$ module: ${leftoverImport[0].trim()}\n` + `Only @system.*/@service.*/@android.*/@hap.*/@app-module imports are rewritten to ` + `$app_require$. Inline the dependency into the component or move it behind a feature module.`);
   }
+  if (hadDefault && defaultExpr === null) {
+    // An unrecognized default-export shape would register an empty component:
+    // it renders but has no data, props or handlers.
+    throw new Error(`[component] ${relPath} declares a default export but none was extracted, ` + `which would register an empty component.`);
+  }
   const varName = compName.replace(/-/g, '_') + '_default';
   const moduleCode = code.trim();
-  return [`let $style$${compSid} = {"@info":{"styleObjectId":${compSid}}};`, `const $app_style$${compSid} = $style$${compSid};`, ...(moduleCode ? [moduleCode] : []), `var ${varName} = ${defaultExpr};`, `$app_define$("@app-component/${compName}", [], function($app_require$, $app_exports$, $app_module$) {`, `  $app_module$.exports = ${varName}.default || ${varName};`, `  $app_module$.exports.style = $app_style$${compSid};`, `});`, ''].join('\n');
+  const emittedDefault = defaultExpr ?? '{}';
+  return [`let $style$${compSid} = {"@info":{"styleObjectId":${compSid}}};`, `const $app_style$${compSid} = $style$${compSid};`, ...(moduleCode ? [moduleCode] : []), `var ${varName} = ${emittedDefault};`, `$app_define$("@app-component/${compName}", [], function($app_require$, $app_exports$, $app_module$) {`, `  $app_module$.exports = ${varName}.default || ${varName};`, `  $app_module$.exports.style = $app_style$${compSid};`, `});`, ''].join('\n');
 }
-function wrapOutput(code, entryName, isApp) {
-  const componentName = _path.default.parse(entryName).name;
-  const defineId = isApp ? '@app-component/app' : `@app-component/${componentName}`;
-  const bootstrapId = isApp ? '@app-application/app' : `@app-component/${componentName}`;
-  // Remove IIFE wrapper: var _page_ = (function(...) { ... return xxx; })(...);
-  // Only remove the FIRST line and the LAST return+closing
-  if (code.startsWith('var _page_')) {
-    // Remove first line (the IIFE opening)
-    const firstNewline = code.indexOf('\n');
-    code = code.slice(firstNewline + 1);
-    // Remove the last return statement and closing })();
-    const lastReturn = code.lastIndexOf('\treturn ');
-    if (lastReturn !== -1) {
-      const afterReturn = code.indexOf('\n', lastReturn);
-      code = code.slice(0, lastReturn) + code.slice(afterReturn + 1);
-    }
-    // Remove the closing })(); or })(...)
-    const lastClose = code.lastIndexOf('})();');
-    if (lastClose !== -1) {
-      code = code.slice(0, lastClose);
-    } else {
-      const lastClose2 = code.lastIndexOf('})(');
-      if (lastClose2 !== -1) {
-        code = code.slice(0, lastClose2);
-      }
-    }
-  }
+
+/**
+ * Normalize rolldown output: drop its region markers and runtime helpers, and
+ * turn surviving `require("@system.*")` calls into `$app_require$`.
+ */
+function stripRolldownArtifacts(code) {
   // Remove rolldown region comments
   code = code.replace(/\/\/#region[^\n]*\n/g, '');
   code = code.replace(/\/\/#endregion[^\n]*/g, '');
@@ -788,8 +962,11 @@ function wrapOutput(code, entryName, isApp) {
   // 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
@@ -817,6 +994,205 @@ function wrapOutput(code, entryName, isApp) {
   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}`;
+  const bootstrapId = isApp ? '@app-application/app' : `@app-component/${componentName}`;
+  // Remove IIFE wrapper: var _page_ = (function(...) { ... return xxx; })(...);
+  // Only remove the FIRST line and the LAST return+closing
+  if (code.startsWith('var _page_')) {
+    // Remove first line (the IIFE opening)
+    const firstNewline = code.indexOf('\n');
+    code = code.slice(firstNewline + 1);
+    // Remove the last return statement and closing })();
+    const lastReturn = code.lastIndexOf('\treturn ');
+    if (lastReturn !== -1) {
+      const afterReturn = code.indexOf('\n', lastReturn);
+      code = code.slice(0, lastReturn) + code.slice(afterReturn + 1);
+    }
+    // Remove the closing })(); or })(...)
+    const lastClose = code.lastIndexOf('})();');
+    if (lastClose !== -1) {
+      code = code.slice(0, lastClose);
+    } else {
+      const lastClose2 = code.lastIndexOf('})(');
+      if (lastClose2 !== -1) {
+        code = code.slice(0, lastClose2);
+      }
+    }
+  }
+  code = stripRolldownArtifacts(code);
   // Extract the default export variable
   let exportVar = '_default';
   const m1 = code.match(/export\s*\{\s*(\w+)\s+as\s+default\s*\}/);
@@ -875,6 +1251,15 @@ function mergeStyleSheets(app, page) {
 const __test = exports.__test = {
   stripDeadDefProp,
   mergeStyleSheets,
-  buildComponentJs
+  buildComponentJs,
+  dropUnusedUxImports,
+  collectReachableUx,
+  resolveImportSrc,
+  findUnbundledRelativeImports,
+  bundleComponentCode,
+  stripRolldownArtifacts,
+  hoistNamespaceObjects,
+  assertNamespaceObjectsInlined,
+  assertNoEagerForwardRead
 };
 var _default = exports.default = ViteCompiler;

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

@@ -20,6 +20,12 @@ const REQUIRED_JSC_VERSION = '1.0.9';
 // not `global` — after the rebind `global.console` would look up ferryGlobal.
 const IIFE_WRAP_PREFIX = 'export default (function (__ctx) {\n' + '  const global = __ctx, window = __ctx, self = __ctx;\n' + '  let { requireModule, unRequireModule, $app_define$, $app_bootstrap$, $app_require$,\n' + '        console = globalThis.console } = __ctx;\n' + '  let { setTimeout, clearTimeout, setInterval, clearInterval } = __ctx;\n\n';
 const IIFE_WRAP_SUFFIX = '\n});\n';
+
+// `-s` strips debug info. `-m` (force module) is deliberately omitted: aiotjsc
+// autodetects module-ness and the IIFE wrapper's `export default` already makes
+// it detect module. Passing an explicit array also suppresses jsc's own
+// `undefined → ["-ms"]` fallback, so this list is the full flag set.
+const JSC_ARGS = ['-s'];
 class Jsc {
   constructor(projectPath, buildPath) {
     this.projectPath = projectPath;
@@ -37,7 +43,7 @@ class Jsc {
       this.assertJscVersion();
       Jsc.wrapAllJsWithIife(buildPath);
       const start = Date.now();
-      const msg = await module.default(buildPath, []);
+      const msg = await module.default(buildPath, JSC_ARGS);
       const elapsed = Date.now() - start;
       if (msg) {
         _sharedUtils.ColorConsole.success({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiot-toolkit/aiotpack",
-  "version": "2.1.0-prender.15",
+  "version": "2.1.0-prender.17",
   "description": "The process tool for packaging aiot projects.",
   "keywords": [
     "aiotpack"
@@ -19,16 +19,16 @@
     "test": "node ./__tests__/aiotpack.test.js"
   },
   "dependencies": {
-    "@aiot-toolkit/generator": "2.1.0-prender.15",
-    "@aiot-toolkit/parser": "2.1.0-prender.15",
-    "@aiot-toolkit/shared-utils": "2.1.0-prender.15",
+    "@aiot-toolkit/generator": "2.1.0-prender.17",
+    "@aiot-toolkit/parser": "2.1.0-prender.17",
+    "@aiot-toolkit/shared-utils": "2.1.0-prender.17",
     "@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.15",
+    "file-lane": "2.1.0-prender.17",
     "file-loader": "^6.2.0",
     "fs-extra": "^11.2.0",
     "jsrsasign": "^11.1.0",