@esmx/rspack 3.0.0-rc.117 → 3.0.0-rc.119

package/src/module-link/types.ts

@@ -17,6 +17,15 @@ export interface ModuleLinkPluginOptions {
     injectChunkName?: boolean;
     preEntries?: string[];
     deps?: string[];
+    /**
+     * Absolute paths of pkg-export wrapper files (one per pkg export). When
+     * the externals function sees an import whose issuer is one of these
+     * wrappers, it skips externalization — the wrapper IS the federation
+     * chunk for that package, so externalizing its inner
+     * `import __m from '<pkg-path>'` would route back to the wrapper itself
+     * (cyclic).
+     */
+    wrapperFiles?: string[];
 }
 
 export interface ParsedModuleLinkPluginOptions {
@@ -28,4 +37,5 @@ export interface ParsedModuleLinkPluginOptions {
     injectChunkName: boolean;
     preEntries: string[];
     deps: string[];
+    wrapperFiles: string[];
 }

package/src/rspack/app.ts

@@ -1,3 +1,6 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import {
     type App,
@@ -98,7 +101,7 @@ export interface RspackAppChainContext {
      * rspack-chain configuration object.
      * You can use the chain API in chain hooks to modify the configuration.
      */
-    chain: import('rspack-chain').default;
+    chain: import('rspack-chain').RspackChain;
 
     /**
      * Options object passed when creating the application.
@@ -153,7 +156,7 @@ export interface RspackAppOptions {
 
     /**
      * Uses rspack-chain to provide chained configuration method, allowing more flexible modification of Rspack configuration.
-     * Called after the config hook, if chain hook exists, chained configuration is preferred.
+     * Called before the config hook: the chain is applied first, then `chain.toConfig()` produces the final RspackOptions which the config hook may still mutate.
      *
      * @param context - Configuration context, containing framework instance, build target, and chain configuration object
      */
@@ -233,10 +236,12 @@ async function createMiddleware(
     if (esmx.command !== esmx.COMMAND.dev) {
         return [];
     }
-    const rsBuild = createRsBuild([
-        generateBuildConfig(esmx, options, 'client'),
-        generateBuildConfig(esmx, options, 'server')
-    ]);
+    const rsBuild = createRsBuild(
+        await Promise.all([
+            generateBuildConfig(esmx, options, 'client'),
+            generateBuildConfig(esmx, options, 'server')
+        ])
+    );
     rsBuild.watch();
 
     // @ts-expect-error
@@ -254,11 +259,11 @@ async function createMiddleware(
     ];
 }
 
-function generateBuildConfig(
+async function generateBuildConfig(
     esmx: Esmx,
     options: RspackAppOptions,
     buildTarget: BuildTarget
-): RspackOptions {
+): Promise<RspackOptions> {
     return createRspackConfig(esmx, buildTarget, options);
 }
 
@@ -288,11 +293,21 @@ function rewriteBuild(esmx: Esmx, options: RspackAppOptions = {}) {
     }
     return async (): Promise<boolean> => {
         const ok = await createRsBuild(
-            targets.map((target) => generateBuildConfig(esmx, options, target))
+            await Promise.all(
+                targets.map((target) =>
+                    generateBuildConfig(esmx, options, target)
+                )
+            )
         ).build();
         if (!ok) {
             return false;
         }
+
+        // Update manifest with integrity hashes after all optimizations
+        if (esmx.isProd) {
+            await updateManifestIntegrity(esmx);
+        }
+
         esmx.writeSync(
             esmx.resolvePath('dist/index.mjs'),
             `
@@ -314,3 +329,67 @@ start();
         return pack(esmx);
     };
 }
+
+/**
+ * Computes SHA-384 Subresource Integrity hashes for every JS chunk under
+ * `dist/client` and records them in the client manifest's `integrity` field.
+ *
+ * Only invoked for production builds. If the client manifest is absent (e.g. a
+ * build that produced no client output) the step is skipped with a warning;
+ * any other failure (read/hash/write error) is propagated so the build fails
+ * loudly rather than silently shipping resources without integrity hashes.
+ */
+async function updateManifestIntegrity(esmx: Esmx): Promise<void> {
+    const clientDir = esmx.resolvePath('dist/client');
+    const manifestPath = path.join(clientDir, 'manifest.json');
+
+    const manifestExists = await fs
+        .access(manifestPath)
+        .then(() => true)
+        .catch(() => false);
+    if (!manifestExists) {
+        console.warn(
+            `SRI generation skipped: client manifest not found at ${manifestPath}`
+        );
+        return;
+    }
+
+    const manifestContent = await fs.readFile(manifestPath, 'utf-8');
+    const manifest = JSON.parse(manifestContent);
+
+    const integrity: Record<string, string> = {};
+
+    async function walkDir(dir: string, relativeDir = ''): Promise<void> {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = relativeDir
+                ? `${relativeDir}/${entry.name}`
+                : entry.name;
+
+            if (entry.isDirectory()) {
+                await walkDir(fullPath, relativePath);
+            } else if (
+                entry.isFile() &&
+                (entry.name.endsWith('.mjs') || entry.name.endsWith('.js')) &&
+                !entry.name.includes('hot-update') &&
+                entry.name !== 'manifest.json'
+            ) {
+                const content = await fs.readFile(fullPath);
+                const hash = crypto
+                    .createHash('sha384')
+                    .update(content)
+                    .digest('base64');
+                integrity[relativePath] = `sha384-${hash}`;
+            }
+        }
+    }
+
+    await walkDir(clientDir);
+
+    if (Object.keys(integrity).length > 0) {
+        manifest.integrity = integrity;
+        await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 4));
+    }
+}

package/src/rspack/chain-config.ts

@@ -1,18 +1,21 @@
+import path from 'node:path';
 import type { Esmx } from '@esmx/core';
+import { buildPkgWrapper } from '@esmx/pkg-wrapper';
 import type { RspackOptions } from '@rspack/core';
 import { rspack } from '@rspack/core';
-import RspackChain from 'rspack-chain';
+import { RspackChain } from 'rspack-chain';
+import RspackVirtualModulePlugin from 'rspack-plugin-virtual-module';
 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';
 
-export function createChainConfig(
+export async function createChainConfig(
     esmx: Esmx,
     buildTarget: BuildTarget,
     options: RspackAppOptions
-): RspackChain {
+): Promise<RspackChain> {
     const isHot = buildTarget === 'client' && !esmx.isProd;
     const isClient = buildTarget === 'client';
     const isServer = buildTarget === 'server';
@@ -65,8 +68,7 @@ export function createChainConfig(
 
     chain.module.parser.set('javascript', {
         url: isClient ? true : 'relative',
-        importMeta: false,
-        strictExportPresence: true
+        importMeta: false
     });
 
     chain.module.generator.set('asset', {
@@ -81,7 +83,8 @@ export function createChainConfig(
 
     chain.optimization
         .minimize(options.minimize ?? esmx.isProd)
-        .emitOnErrors(true);
+        .emitOnErrors(true)
+        .runtimeChunk('single');
 
     chain.externalsPresets({
         web: isClient,
@@ -100,39 +103,65 @@ export function createChainConfig(
         ]);
     }
 
-    chain.experiments({
-        ...(chain.get('experiments') || {}),
-        outputModule: true,
-        nativeWatcher: true,
-        rspackFuture: {
-            bundlerInfo: { force: false }
-        }
-    });
+    chain.output.set('module', true);
+    chain.output.bundlerInfo({ force: false });
+    chain.set('nativeWatcher', true);
 
     chain.set('lazyCompilation', false);
 
-    initModuleLink(chain, createModuleLinkConfig(esmx, buildTarget));
+    const { linkOpts, virtualModules } = await createModuleLinkConfig(
+        esmx,
+        buildTarget
+    );
+
+    // Install pkg-export wrappers as VIRTUAL MODULES. Each `pkg:react`
+    // becomes a virtual file under `<cwd>/node_modules/.esmx-virtual/<remote>/`
+    // whose source is the generated re-export wrapper. The federation entry
+    // points at this virtual file; the wrapper internally does
+    // `import * as __ns from 'react'` so the bundler's resolver / aliases
+    // still apply to the real package. Same mental model as Vite's
+    // `esmx://react` virtual id pattern, realized through
+    // `rspack-plugin-virtual-module` here.
+    if (Object.keys(virtualModules).length > 0) {
+        chain
+            .plugin('esmx-pkg-virtual-modules')
+            .use(RspackVirtualModulePlugin, [
+                virtualModules,
+                `.esmx-virtual-${esmx.name}`
+            ]);
+    }
+
+    initModuleLink(chain, linkOpts, esmx.isProd);
 
     return chain;
 }
 
-function createModuleLinkConfig(
+interface ModuleLinkBundle {
+    linkOpts: ModuleLinkPluginOptions;
+    /** Virtual module map: pseudo-path → wrapper source (empty for node). */
+    virtualModules: Record<string, string>;
+}
+
+async function createModuleLinkConfig(
     esmx: Esmx,
     buildTarget: BuildTarget
-): ModuleLinkPluginOptions {
+): Promise<ModuleLinkBundle> {
     const isClient = buildTarget === 'client';
     const isServer = buildTarget === 'server';
     const isNode = buildTarget === 'node';
 
     if (isNode) {
         return {
-            name: esmx.name,
-            exports: {
-                'src/entry.node': {
-                    pkg: false,
-                    file: './src/entry.node'
+            linkOpts: {
+                name: esmx.name,
+                exports: {
+                    'src/entry.node': {
+                        pkg: false,
+                        file: './src/entry.node'
+                    }
                 }
-            }
+            },
+            virtualModules: {}
         };
     }
 
@@ -143,21 +172,63 @@ function createModuleLinkConfig(
         );
     }
 
+    // Compute pkg-export wrappers as VIRTUAL MODULES (see installation site
+    // in createChainConfig). The wrapper imports the real package by its
+    // ORIGINAL bare specifier so the bundler's resolver / aliases still
+    // apply; we only add static named-export plumbing on top.
+    const env = esmx.moduleConfig.environments[buildTarget];
+    const patchedExports: typeof env.exports = {};
+    const virtualModules: Record<string, string> = {};
+    const wrapperFiles: string[] = [];
+    // The virtual modules plugin writes its files into a temp dir under
+    // node_modules (see RspackVirtualModulePlugin instantiation above) — we
+    // anchor on the same path so the federation entry (and externals
+    // wrapper-skip check) sees the real on-disk path the bundler will report
+    // as the chunk's issuer.
+    const virtualBaseDir = path.join(
+        esmx.root,
+        'node_modules',
+        `.esmx-virtual-${esmx.name}`
+    );
+    for (const [name, exp] of Object.entries(env.exports)) {
+        if (exp.pkg && exp.file) {
+            const { source } = await buildPkgWrapper({
+                root: esmx.root,
+                spec: exp.file
+            });
+            const safeName = `${exp.file.replace(/[^A-Za-z0-9_-]/g, '_')}.mjs`;
+            // Key passed to the plugin is a SIMPLE filename — it gets joined
+            // under the plugin's tempDir. The resulting actual on-disk path
+            // is what rspack reports as the chunk's issuer.
+            virtualModules[safeName] = source;
+            const actualPath = path.join(virtualBaseDir, safeName);
+            wrapperFiles.push(actualPath);
+            patchedExports[name] = { ...exp, file: actualPath };
+        } else {
+            patchedExports[name] = exp;
+        }
+    }
+
     return {
-        ...esmx.moduleConfig.environments[buildTarget],
-        name: esmx.name,
-        injectChunkName: isServer,
-        deps: Object.keys(esmx.moduleConfig.links),
-        preEntries
+        linkOpts: {
+            ...env,
+            exports: patchedExports,
+            name: esmx.name,
+            injectChunkName: isServer,
+            deps: Object.keys(esmx.moduleConfig.links),
+            preEntries,
+            wrapperFiles
+        },
+        virtualModules
     };
 }
 
-export function createRspackConfig(
+export async function createRspackConfig(
     esmx: Esmx,
     buildTarget: BuildTarget,
     options: RspackAppOptions
-): RspackOptions {
-    const chain = createChainConfig(esmx, buildTarget, options);
+): Promise<RspackOptions> {
+    const chain = await createChainConfig(esmx, buildTarget, options);
     options.chain?.({ esmx, options, buildTarget, chain });
     const config = chain.toConfig();
     options.config?.({ esmx, options, buildTarget, config });

package/src/rspack-html/index.ts

@@ -5,7 +5,7 @@ import {
     type SwcLoaderOptions
 } from '@rspack/core';
 import NodePolyfillPlugin from 'node-polyfill-webpack-plugin';
-import type RspackChain from 'rspack-chain';
+import type { RspackChain } from 'rspack-chain';
 import {
     type BuildTarget,
     createRspackApp,
@@ -341,7 +341,7 @@ function configureOptimization(
             {
                 minimizerOptions: {
                     targets: getTargetSetting(options?.target, 'client'),
-                    errorRecovery: false
+                    errorRecovery: true
                 }
             }
         ]);
@@ -457,15 +457,10 @@ function configureCssExtract(
     chain: RspackChain,
     options: RspackHtmlAppOptions
 ): void {
-    chain.set('experiments', {
-        ...(chain.get('experiments') ?? {}),
-        css: true
-    });
-
-    const experiments = chain.get('experiments');
-    if (!experiments || !experiments.css) {
-        return;
-    }
+    chain.module
+        .rule('css')
+        .test(/\.css$/)
+        .type('css/auto');
 
     const lessRule = chain.module
         .rule('less')

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 Esmx Team
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

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

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

package/dist/module-link/config2.mjs

@@ -1,17 +0,0 @@
-import { rspack } from "@rspack/core";
-import {
-  applyEntryConfig,
-  applyExternalsConfig,
-  applyModuleConfig
-} from "./config.mjs";
-export function applyChainConfig2(chain, opts) {
-  applyEntryConfig(chain, opts);
-  applyExternalsConfig(chain, opts);
-  if (chain.get("mode") === "production") {
-    chain.output.set("module", true);
-    chain.plugin("esm-library").use(new rspack.experiments.EsmLibraryPlugin());
-    chain.optimization.set("runtimeChunk", "single");
-  } else {
-    applyModuleConfig(chain);
-  }
-}

package/src/module-link/config2.ts

@@ -1,28 +0,0 @@
-import { rspack } from '@rspack/core';
-import type RspackChain from 'rspack-chain';
-import {
-    applyEntryConfig,
-    applyExternalsConfig,
-    applyModuleConfig
-} from './config';
-import type { ParsedModuleLinkPluginOptions } from './types';
-
-export function applyChainConfig2(
-    chain: RspackChain,
-    opts: ParsedModuleLinkPluginOptions
-): void {
-    applyEntryConfig(chain, opts);
-    applyExternalsConfig(chain, opts);
-
-    // Set module compilation configuration
-    if (chain.get('mode') === 'production') {
-        chain.output.set('module', true);
-
-        chain
-            .plugin('esm-library')
-            .use(new rspack.experiments.EsmLibraryPlugin());
-        chain.optimization.set('runtimeChunk', 'single');
-    } else {
-        applyModuleConfig(chain);
-    }
-}