@esmx/rspack 3.0.0-rc.77 → 3.0.0-rc.78

package/dist/module-link/apply-chain-config.d.ts

@@ -0,0 +1,3 @@
+import type RspackChain from 'rspack-chain';
+import type { ParsedModuleLinkPluginOptions } from './types';
+export declare function applyChainConfig(chain: RspackChain, opts: ParsedModuleLinkPluginOptions): void;

package/dist/module-link/apply-chain-config.mjs

@@ -0,0 +1,114 @@
+export function applyChainConfig(chain, opts) {
+  const isProduction = chain.get("mode") === "production";
+  chain.output.set("module", true).set("chunkFormat", "module").set("chunkLoading", "import").set("workerChunkLoading", "import");
+  chain.experiments({
+    ...chain.get("experiments"),
+    outputModule: true
+  });
+  if (isProduction) {
+    chain.output.library({
+      type: "modern-module"
+    });
+    chain.optimization.set("avoidEntryIife", true);
+  } else {
+    chain.output.library({
+      type: "module"
+    });
+  }
+  applyEntryConfig(chain, opts);
+  applyExternalsConfig(chain, opts);
+}
+function applyEntryConfig(chain, opts) {
+  if (chain.entryPoints.has("main")) {
+    const mainEntry = chain.entry("main");
+    if (mainEntry.values().length === 0) {
+      chain.entryPoints.clear();
+    }
+  }
+  for (const value of Object.values(opts.exports)) {
+    if (value.file) {
+      const entry = chain.entry(value.name);
+      for (const preEntry of opts.preEntries) {
+        entry.add(preEntry);
+      }
+      entry.add(value.file);
+    }
+  }
+}
+function applyExternalsConfig(chain, opts) {
+  const existingExternals = chain.get("externals") || [];
+  const externals = Array.isArray(existingExternals) ? [...existingExternals] : [existingExternals];
+  const compilerContext = chain.get("context") ?? process.cwd();
+  const externalFunc = createExternalsFunction(opts, compilerContext);
+  externals.push(externalFunc);
+  chain.externals(externals);
+}
+function createExternalsFunction(opts, compilerContext) {
+  const importMap = /* @__PURE__ */ new Map();
+  let initPromise = null;
+  const init = (resolvePath) => {
+    if (initPromise) return initPromise;
+    initPromise = (async () => {
+      await Promise.all(
+        Object.values(opts.exports).map(async (value) => {
+          const identifier = value.pkg ? value.name : value.identifier;
+          importMap.set(identifier, identifier);
+          importMap.set(value.name, identifier);
+          const resolvedPath = await resolvePath(value.file);
+          if (resolvedPath) {
+            importMap.set(resolvedPath, identifier);
+          }
+        })
+      );
+      for (const key of Object.keys(opts.imports)) {
+        importMap.set(key, key);
+      }
+    })();
+    return initPromise;
+  };
+  const match = async (request, context, resolvePath) => {
+    if (!request) return null;
+    if (opts.deps.length > 0) {
+      const matchedDep = opts.deps.find(
+        (dep) => request === dep || request.startsWith(`${dep}/`)
+      );
+      if (matchedDep) {
+        return request;
+      }
+    }
+    let importName = importMap.get(request);
+    if (!importName) {
+      const resolvedPath = await resolvePath(request, context);
+      if (resolvedPath) {
+        importName = importMap.get(resolvedPath);
+      }
+    }
+    return importName || null;
+  };
+  const FILE_EXT_REGEX = /\.worker\.(js|mjs|cjs|jsx|mjsx|cjsx|ts|mts|cts|tsx|mtsx|ctsx)$/i;
+  return async (data) => {
+    if (!data.request || !data.context || !data.contextInfo?.issuer || FILE_EXT_REGEX.test(data.contextInfo.issuer))
+      return;
+    const defaultContext = compilerContext;
+    const resolvePath = async (request, context = defaultContext) => {
+      if (!data.getResolve) {
+        return null;
+      }
+      const resolveFunc = data.getResolve();
+      return new Promise((resolve) => {
+        resolveFunc(context, request, (err, res) => {
+          resolve(typeof res === "string" ? res : null);
+        });
+      });
+    };
+    await init(resolvePath);
+    const matchedIdentifier = await match(
+      data.request,
+      data.context,
+      resolvePath
+    );
+    if (matchedIdentifier) {
+      return `module-import ${matchedIdentifier}`;
+    }
+  };
+}

package/dist/module-link/index.d.ts

@@ -0,0 +1,4 @@
+import type RspackChain from 'rspack-chain';
+import type { ModuleLinkPluginOptions } from './types';
+export declare function initModuleLink(chain: RspackChain, options: ModuleLinkPluginOptions): void;
+export type { ModuleLinkPluginOptions } from './types';

package/dist/module-link/index.mjs

@@ -0,0 +1,8 @@
+import { applyChainConfig } from "./apply-chain-config.mjs";
+import { ManifestPlugin } from "./manifest-plugin.mjs";
+import { parseOptions } from "./parse.mjs";
+export function initModuleLink(chain, options) {
+  const opts = parseOptions(options);
+  applyChainConfig(chain, opts);
+  chain.plugin("module-link-manifest").use(ManifestPlugin, [opts]);
+}

package/dist/module-link/manifest-plugin.d.ts

@@ -0,0 +1,14 @@
+import type { Compiler, StatsCompilation } from '@rspack/core';
+import type { ManifestJsonExports, ParsedModuleLinkPluginOptions } from './types';
+export declare const RSPACK_PLUGIN_NAME = "rspack-module-link-plugin";
+export declare class ManifestPlugin {
+    private opts;
+    constructor(opts: ParsedModuleLinkPluginOptions);
+    apply(compiler: Compiler): void;
+}
+export declare function getExports(opts: ParsedModuleLinkPluginOptions, stats: StatsCompilation): ManifestJsonExports;
+export declare function generateIdentifier({ root, name, filePath }: {
+    root: string;
+    name: string;
+    filePath: string;
+}): string;

package/dist/module-link/manifest-plugin.mjs

@@ -0,0 +1,141 @@
+import upath from "upath";
+export const RSPACK_PLUGIN_NAME = "rspack-module-link-plugin";
+export class ManifestPlugin {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  apply(compiler) {
+    const opts = this.opts;
+    const { Compilation } = compiler.rspack;
+    compiler.hooks.thisCompilation.tap(
+      RSPACK_PLUGIN_NAME,
+      (compilation) => {
+        let manifestJson = {
+          name: opts.name,
+          exports: {},
+          scopes: opts.scopes,
+          files: [],
+          chunks: {}
+        };
+        compilation.hooks.processAssets.tap(
+          {
+            name: RSPACK_PLUGIN_NAME,
+            stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
+          },
+          (assets) => {
+            const stats = compilation.getStats().toJson({
+              hash: true,
+              entrypoints: true
+            });
+            const exports = getExports(opts, stats);
+            const resources = Object.keys(assets).map(transFileName).filter((file) => !file.includes("hot-update"));
+            manifestJson = {
+              name: opts.name,
+              exports,
+              scopes: opts.scopes,
+              files: resources,
+              chunks: getChunks(opts, compilation)
+            };
+            const { RawSource } = compiler.rspack.sources;
+            compilation.emitAsset(
+              "manifest.json",
+              new RawSource(JSON.stringify(manifestJson, null, 4))
+            );
+          }
+        );
+        if (opts.injectChunkName) {
+          compilation.hooks.processAssets.tap(
+            {
+              name: RSPACK_PLUGIN_NAME,
+              stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+            },
+            (assets) => {
+              const { RawSource } = compiler.rspack.sources;
+              for (const [key, value] of Object.entries(
+                manifestJson.chunks
+              )) {
+                const asset = assets[value.js];
+                if (!asset) {
+                  return;
+                }
+                const source = new RawSource(
+                  `import.meta.chunkName = import.meta.chunkName ?? ${JSON.stringify(key)};
+${asset.source()}`
+                );
+                compilation.updateAsset(value.js, source);
+              }
+            }
+          );
+        }
+      }
+    );
+  }
+}
+function transFileName(fileName) {
+  return fileName.replace(/^.\//, "");
+}
+export function getExports(opts, stats) {
+  const entrypoints = stats.entrypoints || {};
+  const exports = {};
+  for (const [key, value] of Object.entries(entrypoints)) {
+    const asset = value.assets?.find((item) => {
+      return item.name.endsWith(opts.ext) && !item.name.includes("hot-update");
+    });
+    if (!asset) continue;
+    if (key in opts.exports) {
+      exports[key] = {
+        ...opts.exports[key],
+        file: asset.name
+      };
+    }
+  }
+  return exports;
+}
+function getChunks(opts, compilation) {
+  const stats = compilation.getStats().toJson({
+    all: false,
+    chunks: true,
+    modules: true,
+    chunkModules: true,
+    ids: true
+  });
+  const buildChunks = {};
+  if (!stats.chunks) return buildChunks;
+  for (const chunk of stats.chunks) {
+    const module = chunk.modules?.sort((a, b) => {
+      return (a.index ?? -1) - (b?.index ?? -1);
+    })?.find((module2) => {
+      return module2.moduleType?.includes("javascript/");
+    });
+    if (!module?.nameForCondition) continue;
+    const js = chunk.files?.find((file) => file.endsWith(opts.ext));
+    if (!js) continue;
+    const root = compilation.options.context ?? process.cwd();
+    const name = generateIdentifier({
+      root,
+      name: opts.name,
+      filePath: module.nameForCondition
+    });
+    const css = chunk.files?.filter((file) => file.endsWith(".css")) ?? [];
+    const resources = chunk.auxiliaryFiles ?? [];
+    buildChunks[name] = {
+      name,
+      js,
+      css,
+      resources
+    };
+  }
+  return buildChunks;
+}
+export function generateIdentifier({
+  root,
+  name,
+  filePath
+}) {
+  const unixFilePath = upath.toUnix(filePath);
+  if (!root) {
+    return `${name}@${unixFilePath}`;
+  }
+  const file = upath.relative(upath.toUnix(root), unixFilePath);
+  return `${name}@${file}`;
+}

package/dist/module-link/parse.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleLinkPluginOptions, ParsedModuleLinkPluginOptions } from './types';
+export declare function parseOptions(options: ModuleLinkPluginOptions): ParsedModuleLinkPluginOptions;

package/dist/module-link/parse.mjs

@@ -0,0 +1,24 @@
+export function parseOptions(options) {
+  const exports = {};
+  if (options.exports) {
+    for (const [name, item] of Object.entries(options.exports)) {
+      exports[name] = {
+        name,
+        pkg: !!item.pkg,
+        file: item.file,
+        identifier: `${options.name}/${name}`
+      };
+    }
+  }
+  const deps = (options.deps ?? []).filter((name) => name !== options.name);
+  return {
+    name: options.name,
+    ext: options.ext ? `.${options.ext}` : ".mjs",
+    exports,
+    imports: options.imports ?? {},
+    scopes: options.scopes ?? {},
+    injectChunkName: options.injectChunkName ?? false,
+    preEntries: options.preEntries ?? [],
+    deps
+  };
+}

package/dist/module-link/types.d.ts

@@ -0,0 +1,25 @@
+import type { ManifestJsonExports } from '@esmx/core';
+export type { ManifestJson, ManifestJsonChunks, ManifestJsonChunk, ManifestJsonExport, ManifestJsonExports } from '@esmx/core';
+export interface ModuleLinkPluginOptions {
+    name: string;
+    ext?: string;
+    imports?: Record<string, string>;
+    scopes?: Record<string, Record<string, string>>;
+    exports?: Record<string, {
+        pkg?: boolean;
+        file: string;
+    }>;
+    injectChunkName?: boolean;
+    preEntries?: string[];
+    deps?: string[];
+}
+export interface ParsedModuleLinkPluginOptions {
+    name: string;
+    ext: string;
+    exports: ManifestJsonExports;
+    imports: Record<string, string>;
+    scopes: Record<string, Record<string, string>>;
+    injectChunkName: boolean;
+    preEntries: string[];
+    deps: string[];
+}

package/dist/rspack/app.mjs

@@ -58,14 +58,7 @@ function rewriteRender(esmx) {
     const module = await vmImport(
       `${esmx.name}/src/entry.server`,
       import.meta.url,
-      {
-        console,
-        setTimeout,
-        clearTimeout,
-        process,
-        URL,
-        global
-      }
+      global
     );
     const serverRender = module[rc.entryName];
     if (typeof serverRender === "function") {
@@ -100,6 +93,8 @@ async function start() {
 start();
 `.trim()
     );
+    console.log("\n");
+    console.log(esmx.generateSizeReport().text);
     return pack(esmx);
   };
 }

package/dist/rspack/chain-config.mjs

@@ -1,9 +1,7 @@
-import {
-  moduleLinkPlugin
-} from "@esmx/rspack-module-link-plugin";
 import { rspack } from "@rspack/core";
 import RspackChain from "rspack-chain";
 import nodeExternals from "webpack-node-externals";
+import { initModuleLink } from "../module-link/index.mjs";
 export function createChainConfig(esmx, buildTarget, options) {
   const isHot = buildTarget === "client" && !esmx.isProd;
   const isClient = buildTarget === "client";
@@ -35,12 +33,13 @@ export function createChainConfig(esmx, buildTarget, options) {
       prefix: buildTarget
     }
   ]);
-  config.plugin("module-link").use(moduleLinkPlugin, [createModuleLinkConfig(esmx, buildTarget)]);
   if (isHot) {
     config.plugin("hmr").use(rspack.HotModuleReplacementPlugin);
   }
   config.module.parser.set("javascript", {
-    url: isClient ? true : "relative"
+    url: isClient ? true : "relative",
+    importMeta: false,
+    strictExportPresence: true
   });
   config.module.generator.set("asset", {
     emit: isClient
@@ -65,8 +64,12 @@ export function createChainConfig(esmx, buildTarget, options) {
     ]);
   }
   config.experiments({
-    nativeWatcher: true
+    nativeWatcher: true,
+    rspackFuture: {
+      bundlerInfo: { force: false }
+    }
   });
+  initModuleLink(config, createModuleLinkConfig(esmx, buildTarget));
   return config;
 }
 function createModuleLinkConfig(esmx, buildTarget) {

package/package.json

@@ -63,8 +63,7 @@
         }
     },
     "dependencies": {
-        "@esmx/import": "3.0.0-rc.77",
-        "@esmx/rspack-module-link-plugin": "3.0.0-rc.77",
+        "@esmx/import": "3.0.0-rc.78",
         "@npmcli/arborist": "^9.1.6",
         "@rspack/core": "1.6.5",
         "css-loader": "^7.1.2",
@@ -74,13 +73,14 @@
         "rspack-chain": "^1.4.1",
         "style-loader": "^4.0.0",
         "style-resources-loader": "^1.5.0",
+        "upath": "^2.0.1",
         "webpack-hot-middleware": "^2.26.1",
         "webpack-node-externals": "~3.0.0",
         "worker-rspack-loader": "^3.1.2"
     },
     "devDependencies": {
         "@biomejs/biome": "2.3.4",
-        "@esmx/core": "3.0.0-rc.77",
+        "@esmx/core": "3.0.0-rc.78",
         "@types/node": "^24.10.0",
         "@types/npmcli__arborist": "^6.3.1",
         "@types/pacote": "^11.1.8",
@@ -91,7 +91,7 @@
         "unbuild": "3.6.1",
         "vitest": "3.2.4"
     },
-    "version": "3.0.0-rc.77",
+    "version": "3.0.0-rc.78",
     "type": "module",
     "private": false,
     "exports": {
@@ -110,5 +110,5 @@
         "template",
         "public"
     ],
-    "gitHead": "c56120965914f33eca4b21336f705b3cb5fc7f93"
+    "gitHead": "aa44e33ab3e05817977c0fda6148abff8351651f"
 }

package/src/module-link/apply-chain-config.ts

@@ -0,0 +1,180 @@
+import type { ExternalItem, ExternalItemFunctionData } from '@rspack/core';
+import type RspackChain from 'rspack-chain';
+import type { ParsedModuleLinkPluginOptions } from './types';
+
+type ResolvePath = (
+    request: string,
+    context?: string
+) => Promise<string | null>;
+
+export function applyChainConfig(
+    chain: RspackChain,
+    opts: ParsedModuleLinkPluginOptions
+): void {
+    const isProduction = chain.get('mode') === 'production';
+
+    chain.output
+        .set('module', true)
+        .set('chunkFormat', 'module')
+        .set('chunkLoading', 'import')
+        .set('workerChunkLoading', 'import');
+    chain.experiments({
+        ...chain.get('experiments'),
+        outputModule: true
+    });
+
+    if (isProduction) {
+        chain.output.library({
+            type: 'modern-module'
+        });
+        chain.optimization.set('avoidEntryIife', true);
+    } else {
+        chain.output.library({
+            type: 'module'
+        });
+    }
+
+    applyEntryConfig(chain, opts);
+
+    applyExternalsConfig(chain, opts);
+}
+
+function applyEntryConfig(
+    chain: RspackChain,
+    opts: ParsedModuleLinkPluginOptions
+): void {
+    if (chain.entryPoints.has('main')) {
+        const mainEntry = chain.entry('main');
+        if (mainEntry.values().length === 0) {
+            chain.entryPoints.clear();
+        }
+    }
+
+    for (const value of Object.values(opts.exports)) {
+        if (value.file) {
+            const entry = chain.entry(value.name);
+            for (const preEntry of opts.preEntries) {
+                entry.add(preEntry);
+            }
+            entry.add(value.file);
+        }
+    }
+}
+
+function applyExternalsConfig(
+    chain: RspackChain,
+    opts: ParsedModuleLinkPluginOptions
+): void {
+    const existingExternals = chain.get('externals') || [];
+    const externals: ExternalItem[] = Array.isArray(existingExternals)
+        ? [...existingExternals]
+        : [existingExternals];
+
+    const compilerContext = chain.get('context') ?? process.cwd();
+    const externalFunc = createExternalsFunction(opts, compilerContext);
+    externals.push(externalFunc);
+
+    chain.externals(externals);
+}
+
+function createExternalsFunction(
+    opts: ParsedModuleLinkPluginOptions,
+    compilerContext: string
+) {
+    const importMap = new Map<string, string>();
+    let initPromise: Promise<void> | null = null;
+
+    const init = (resolvePath: ResolvePath): Promise<void> => {
+        if (initPromise) return initPromise;
+
+        initPromise = (async () => {
+            await Promise.all(
+                Object.values(opts.exports).map(async (value) => {
+                    const identifier = value.pkg
+                        ? value.name
+                        : value.identifier;
+                    importMap.set(identifier, identifier);
+                    importMap.set(value.name, identifier);
+
+                    const resolvedPath = await resolvePath(value.file);
+                    if (resolvedPath) {
+                        importMap.set(resolvedPath, identifier);
+                    }
+                })
+            );
+
+            for (const key of Object.keys(opts.imports)) {
+                importMap.set(key, key);
+            }
+        })();
+
+        return initPromise;
+    };
+
+    const match = async (
+        request: string,
+        context: string,
+        resolvePath: ResolvePath
+    ): Promise<string | null> => {
+        if (!request) return null;
+
+        if (opts.deps.length > 0) {
+            const matchedDep = opts.deps.find(
+                (dep) => request === dep || request.startsWith(`${dep}/`)
+            );
+            if (matchedDep) {
+                return request;
+            }
+        }
+
+        let importName = importMap.get(request);
+        if (!importName) {
+            const resolvedPath = await resolvePath(request, context);
+            if (resolvedPath) {
+                importName = importMap.get(resolvedPath);
+            }
+        }
+
+        return importName || null;
+    };
+
+    const FILE_EXT_REGEX =
+        /\.worker\.(js|mjs|cjs|jsx|mjsx|cjsx|ts|mts|cts|tsx|mtsx|ctsx)$/i;
+
+    return async (data: ExternalItemFunctionData) => {
+        if (
+            !data.request ||
+            !data.context ||
+            !data.contextInfo?.issuer ||
+            FILE_EXT_REGEX.test(data.contextInfo.issuer)
+        )
+            return;
+
+        const defaultContext = compilerContext;
+        const resolvePath: ResolvePath = async (
+            request: string,
+            context = defaultContext
+        ): Promise<string | null> => {
+            if (!data.getResolve) {
+                return null;
+            }
+            const resolveFunc = data.getResolve();
+            return new Promise<string | null>((resolve) => {
+                resolveFunc(context, request, (err, res) => {
+                    resolve(typeof res === 'string' ? res : null);
+                });
+            });
+        };
+
+        await init(resolvePath);
+        const matchedIdentifier = await match(
+            data.request,
+            data.context,
+            resolvePath
+        );
+
+        if (matchedIdentifier) {
+            return `module-import ${matchedIdentifier}`;
+        }
+    };
+}

package/src/module-link/index.ts

@@ -0,0 +1,18 @@
+import type RspackChain from 'rspack-chain';
+import { applyChainConfig } from './apply-chain-config';
+import { ManifestPlugin } from './manifest-plugin';
+import { parseOptions } from './parse';
+import type { ModuleLinkPluginOptions } from './types';
+
+export function initModuleLink(
+    chain: RspackChain,
+    options: ModuleLinkPluginOptions
+): void {
+    const opts = parseOptions(options);
+
+    applyChainConfig(chain, opts);
+
+    chain.plugin('module-link-manifest').use(ManifestPlugin, [opts]);
+}
+
+export type { ModuleLinkPluginOptions } from './types';

package/src/module-link/manifest-plugin.ts

@@ -0,0 +1,175 @@
+import type { Compilation, Compiler, StatsCompilation } from '@rspack/core';
+import upath from 'upath';
+import type {
+    ManifestJson,
+    ManifestJsonChunks,
+    ManifestJsonExports,
+    ParsedModuleLinkPluginOptions
+} from './types';
+
+export const RSPACK_PLUGIN_NAME = 'rspack-module-link-plugin';
+
+export class ManifestPlugin {
+    constructor(private opts: ParsedModuleLinkPluginOptions) {}
+
+    apply(compiler: Compiler) {
+        const opts = this.opts;
+        const { Compilation } = compiler.rspack;
+        compiler.hooks.thisCompilation.tap(
+            RSPACK_PLUGIN_NAME,
+            (compilation) => {
+                let manifestJson: ManifestJson = {
+                    name: opts.name,
+                    exports: {},
+                    scopes: opts.scopes,
+                    files: [],
+                    chunks: {}
+                };
+
+                compilation.hooks.processAssets.tap(
+                    {
+                        name: RSPACK_PLUGIN_NAME,
+                        stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
+                    },
+                    (assets) => {
+                        const stats = compilation.getStats().toJson({
+                            hash: true,
+                            entrypoints: true
+                        });
+
+                        const exports = getExports(opts, stats);
+                        const resources = Object.keys(assets)
+                            .map(transFileName)
+                            .filter((file) => !file.includes('hot-update'));
+                        manifestJson = {
+                            name: opts.name,
+                            exports: exports,
+                            scopes: opts.scopes,
+                            files: resources,
+                            chunks: getChunks(opts, compilation)
+                        };
+                        const { RawSource } = compiler.rspack.sources;
+
+                        compilation.emitAsset(
+                            'manifest.json',
+                            new RawSource(JSON.stringify(manifestJson, null, 4))
+                        );
+                    }
+                );
+
+                if (opts.injectChunkName) {
+                    compilation.hooks.processAssets.tap(
+                        {
+                            name: RSPACK_PLUGIN_NAME,
+                            stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+                        },
+                        (assets) => {
+                            const { RawSource } = compiler.rspack.sources;
+                            for (const [key, value] of Object.entries(
+                                manifestJson.chunks
+                            )) {
+                                const asset = assets[value.js];
+                                if (!asset) {
+                                    return;
+                                }
+                                const source = new RawSource(
+                                    `import.meta.chunkName = import.meta.chunkName ?? ${JSON.stringify(key)};\n${asset.source()}`
+                                );
+
+                                compilation.updateAsset(value.js, source);
+                            }
+                        }
+                    );
+                }
+            }
+        );
+    }
+}
+
+function transFileName(fileName: string): string {
+    return fileName.replace(/^.\//, '');
+}
+
+export function getExports(
+    opts: ParsedModuleLinkPluginOptions,
+    stats: StatsCompilation
+): ManifestJsonExports {
+    const entrypoints = stats.entrypoints || {};
+    const exports: ManifestJsonExports = {};
+
+    for (const [key, value] of Object.entries(entrypoints)) {
+        const asset = value.assets?.find((item) => {
+            return (
+                item.name.endsWith(opts.ext) &&
+                !item.name.includes('hot-update')
+            );
+        });
+        if (!asset) continue;
+        if (key in opts.exports) {
+            exports[key] = {
+                ...opts.exports[key],
+                file: asset.name
+            };
+        }
+    }
+    return exports;
+}
+
+function getChunks(
+    opts: ParsedModuleLinkPluginOptions,
+    compilation: Compilation
+) {
+    const stats = compilation.getStats().toJson({
+        all: false,
+        chunks: true,
+        modules: true,
+        chunkModules: true,
+        ids: true
+    });
+    const buildChunks: ManifestJsonChunks = {};
+    if (!stats.chunks) return buildChunks;
+
+    for (const chunk of stats.chunks) {
+        const module = chunk.modules
+            ?.sort((a, b) => {
+                return (a.index ?? -1) - (b?.index ?? -1);
+            })
+            ?.find((module) => {
+                return module.moduleType?.includes('javascript/');
+            });
+        if (!module?.nameForCondition) continue;
+
+        const js = chunk.files?.find((file) => file.endsWith(opts.ext));
+        if (!js) continue;
+
+        const root = compilation.options.context ?? process.cwd();
+        const name = generateIdentifier({
+            root,
+            name: opts.name,
+            filePath: module.nameForCondition
+        });
+
+        const css = chunk.files?.filter((file) => file.endsWith('.css')) ?? [];
+        const resources = chunk.auxiliaryFiles ?? [];
+        buildChunks[name] = {
+            name,
+            js,
+            css,
+            resources
+        };
+    }
+    return buildChunks;
+}
+
+export function generateIdentifier({
+    root,
+    name,
+    filePath
+}: { root: string; name: string; filePath: string }) {
+    const unixFilePath = upath.toUnix(filePath);
+    if (!root) {
+        return `${name}@${unixFilePath}`;
+    }
+    const file = upath.relative(upath.toUnix(root), unixFilePath);
+    return `${name}@${file}`;
+}

package/src/module-link/parse.ts

@@ -0,0 +1,31 @@
+import type {
+    ModuleLinkPluginOptions,
+    ParsedModuleLinkPluginOptions
+} from './types';
+
+export function parseOptions(
+    options: ModuleLinkPluginOptions
+): ParsedModuleLinkPluginOptions {
+    const exports: ParsedModuleLinkPluginOptions['exports'] = {};
+    if (options.exports) {
+        for (const [name, item] of Object.entries(options.exports)) {
+            exports[name] = {
+                name,
+                pkg: !!item.pkg,
+                file: item.file,
+                identifier: `${options.name}/${name}`
+            };
+        }
+    }
+    const deps = (options.deps ?? []).filter((name) => name !== options.name);
+    return {
+        name: options.name,
+        ext: options.ext ? `.${options.ext}` : '.mjs',
+        exports,
+        imports: options.imports ?? {},
+        scopes: options.scopes ?? {},
+        injectChunkName: options.injectChunkName ?? false,
+        preEntries: options.preEntries ?? [],
+        deps
+    };
+}

package/src/module-link/types.ts

@@ -0,0 +1,31 @@
+import type { ManifestJsonExports } from '@esmx/core';
+
+export type {
+    ManifestJson,
+    ManifestJsonChunks,
+    ManifestJsonChunk,
+    ManifestJsonExport,
+    ManifestJsonExports
+} from '@esmx/core';
+
+export interface ModuleLinkPluginOptions {
+    name: string;
+    ext?: string;
+    imports?: Record<string, string>;
+    scopes?: Record<string, Record<string, string>>;
+    exports?: Record<string, { pkg?: boolean; file: string }>;
+    injectChunkName?: boolean;
+    preEntries?: string[];
+    deps?: string[];
+}
+
+export interface ParsedModuleLinkPluginOptions {
+    name: string;
+    ext: string;
+    exports: ManifestJsonExports;
+    imports: Record<string, string>;
+    scopes: Record<string, Record<string, string>>;
+    injectChunkName: boolean;
+    preEntries: string[];
+    deps: string[];
+}

package/src/rspack/app.ts

@@ -271,14 +271,7 @@ function rewriteRender(esmx: Esmx) {
         const module = await vmImport(
             `${esmx.name}/src/entry.server`,
             import.meta.url,
-            {
-                console,
-                setTimeout,
-                clearTimeout,
-                process,
-                URL,
-                global
-            }
+            global
         );
         const serverRender: ServerRenderHandle = module[rc.entryName];
         if (typeof serverRender === 'function') {
@@ -314,6 +307,8 @@ async function start() {
 start();
 `.trim()
         );
+        console.log('\n');
+        console.log(esmx.generateSizeReport().text);
         return pack(esmx);
     };
 }

package/src/rspack/chain-config.ts

@@ -1,12 +1,10 @@
 import type { Esmx } from '@esmx/core';
-import {
-    type ModuleLinkPluginOptions,
-    moduleLinkPlugin
-} from '@esmx/rspack-module-link-plugin';
 import { rspack } from '@rspack/core';
 import type { RspackOptions } from '@rspack/core';
 import RspackChain from 'rspack-chain';
 import nodeExternals from 'webpack-node-externals';
+import type { ModuleLinkPluginOptions } from '../module-link';
+import { initModuleLink } from '../module-link';
 import type { RspackAppOptions } from './app';
 import type { BuildTarget } from './build-target';
 
@@ -61,16 +59,14 @@ export function createChainConfig(
         }
     ]);
 
-    config
-        .plugin('module-link')
-        .use(moduleLinkPlugin, [createModuleLinkConfig(esmx, buildTarget)]);
-
     if (isHot) {
         config.plugin('hmr').use(rspack.HotModuleReplacementPlugin);
     }
 
     config.module.parser.set('javascript', {
-        url: isClient ? true : 'relative'
+        url: isClient ? true : 'relative',
+        importMeta: false,
+        strictExportPresence: true
     });
 
     config.module.generator.set('asset', {
@@ -103,9 +99,14 @@ export function createChainConfig(
         ]);
     }
     config.experiments({
-        nativeWatcher: true
+        nativeWatcher: true,
+        rspackFuture: {
+            bundlerInfo: { force: false }
+        }
     });
 
+    initModuleLink(config, createModuleLinkConfig(esmx, buildTarget));
+
     return config;
 }