@mfeflow/rsbuild 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sanjeev Sharma
+
+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/README.md

@@ -1,3 +1,44 @@
-# Temporary Holding Version
+# @mfeflow/rsbuild
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Rsbuild presets for Module Federation 2.0 micro-frontends. `createShellConfig` and `createRemoteConfig` return an Rsbuild config with React, the shared singletons, the manifest, generated types and the ESM Module Federation runtime already set up.
+
+## Install
+
+```sh
+pnpm add -D @mfeflow/rsbuild @rsbuild/core
+```
+
+`@rsbuild/core` (^2.0.0) is a peer dependency.
+
+## Usage
+
+```ts
+// rsbuild.config.ts of a remote
+import { createRemoteConfig } from '@mfeflow/rsbuild';
+
+export default createRemoteConfig({
+  name: 'cart',
+  port: 4312,
+  exposes: { './App': './src/exposed/App.tsx' },
+});
+```
+
+```ts
+// rsbuild.config.ts of the shell
+import { createShellConfig } from '@mfeflow/rsbuild';
+
+export default createShellConfig({ name: 'storefront', port: 4300 });
+```
+
+Merge extra settings with `mergeRsbuildConfig` from `@rsbuild/core`. `shared: ['some-lib']` adds more singletons. With `eager: false` the shell entry must only `import('./bootstrap')`, and the preset throws if it does not.
+
+## Module Federation sharing
+
+Bucket: **config**. Used at build, lint or test time only, never shipped to the browser, so it is not shared through Module Federation.
+
+## Links
+
+- [mfeflow repository](https://github.com/mfeflow/mfeflow) and its README
+- [Documentation](https://mfeflow.github.io/mfeflow/)
+
+MIT licensed.

package/dist/esm-runtime.d.ts

@@ -0,0 +1,19 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+/** True for a CommonJS build inside an `@module-federation/*` package's `dist`. */
+export declare function isMfCjs(file: string): boolean;
+/** `value` with the first `from` replaced by `to`, taken literally (no `$&` or `$1` expansion). */
+export declare function swapPath(value: string, from: string, to: string): string;
+/**
+ * The ESM twin of a Module Federation `.cjs` file: the same name ending in
+ * `.js` or `.mjs` in the same directory. Throws if there is none, so a new
+ * Module Federation release that drops the twin fails the build instead of
+ * quietly shipping the CommonJS runtime again.
+ */
+export declare function esmTwin(file: string, exists?: (f: string) => boolean): string;
+/**
+ * Rspack resolves the Module Federation runtime with `require.resolve`, which
+ * bundles the CommonJS builds of sdk, runtime-core and bundler-runtime. Nothing
+ * in those tree-shakes (spike: shell 34.9 → 29.4 KB gzip, remote entry 13.7 →
+ * 7.7 KB). This plugin points them at their ESM twins.
+ */
+export declare function pluginMfEsmRuntime(): RsbuildPlugin;

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+import type { RsbuildConfig } from '@rsbuild/core';
+import { type SharedConfig } from './shared.js';
+export { esmTwin, isMfCjs, pluginMfEsmRuntime } from './esm-runtime.js';
+export { RUNTIME_CONFIG_URL, runtimeConfigEnv, runtimeConfigEnvs, runtimeConfigHandler, runtimeConfigSetup, } from './runtime-config.js';
+export { DEFAULT_SINGLETONS, installedVersionFrom, packageNameOf, resolvableFrom, sharedSingletons, type SharedConfig, } from './shared.js';
+export interface RemoteOptions {
+    /** Module Federation name, e.g. `cart`. */
+    name: string;
+    /** `{ './App': './src/exposed/App.tsx' }`. */
+    exposes: Readonly<Record<string, string>>;
+    port?: number;
+    /** Extra packages to share as singletons. */
+    shared?: readonly string[];
+    /** Generate types for the shell (`@mf-types.zip`). Default true. */
+    types?: boolean;
+    /**
+     * Set when this remote loads other remotes. By default remote code for
+     * consuming remotes is stripped from the build (smaller entry).
+     */
+    consumesRemotes?: boolean;
+    /** Swap the CommonJS Module Federation runtime for its ESM build. Default true. */
+    esmRuntime?: boolean;
+    /** App directory. Default `process.cwd()`. */
+    cwd?: string;
+}
+export interface FederationOptimization {
+    disableRemote?: true;
+    disableSnapshot?: true;
+    target?: 'web';
+}
+export interface FederationOptions {
+    name: string;
+    exposes?: Record<string, string>;
+    remotes?: Record<string, string>;
+    shared: Record<string, SharedConfig>;
+    manifest: boolean;
+    dts: false | {
+        generateTypes: boolean;
+        consumeTypes: false | {
+            typesOnBuild: true;
+            abortOnError: boolean;
+        };
+    };
+    runtimePlugins?: string[];
+    experiments: {
+        externalRuntime?: true;
+        provideExternalRuntime?: true;
+        optimization: FederationOptimization;
+    };
+}
+/** Module Federation options for a remote. Exported for tests and custom setups. */
+export declare function remoteFederationOptions(o: RemoteOptions, canResolve: (s: string) => boolean, versionOf?: (s: string) => string | undefined): FederationOptions;
+/** Rsbuild config for a remote. `rsbuild.config.ts`: `export default createRemoteConfig({ name, exposes })`. */
+export declare function createRemoteConfig(o: RemoteOptions): RsbuildConfig;
+export interface ShellOptions {
+    name: string;
+    port?: number;
+    shared?: readonly string[];
+    /**
+     * Remotes whose types the shell typechecks against, as `{ cart: 'https://…/mf-manifest.json' }`.
+     * Used only when `MFEFLOW_TYPES=1` is set (types-only builds); normal builds
+     * register remotes at runtime from the registry index.
+     */
+    typesFrom?: Readonly<Record<string, string>>;
+    /** More Module Federation runtime plugins (absolute paths). Must not import shared modules. */
+    runtimePlugins?: readonly string[];
+    /** Swap the CommonJS Module Federation runtime for its ESM build. Default true. */
+    esmRuntime?: boolean;
+    /**
+     * Ship shared singletons in the initial chunk so the shell needs no async
+     * bootstrap boundary. Default true. With `false` the singletons load
+     * asynchronously, so the entry (`src/index.ts`) must only `import('./bootstrap')`;
+     * a synchronous bootstrap fails at runtime with "Shared module is not available
+     * for eager consumption". `createShellConfig` throws when the entry has no
+     * dynamic `import()`.
+     */
+    eager?: boolean;
+    /**
+     * Keep the manifest/snapshot loader. Default: only in non-production builds,
+     * where dev overrides point at a local remote's manifest. Production shells
+     * register remote entry URLs and need no snapshot code, so the runtime
+     * refuses (and reports `MFE_NO_REMOTE_ENTRY` for) a registry entry that has
+     * only a manifest URL. Pass `snapshot: true` while publishing does not yet
+     * write `remoteEntry`.
+     */
+    snapshot?: boolean;
+    cwd?: string;
+    env?: Readonly<Record<string, string | undefined>>;
+}
+/** Whether the shell keeps the manifest/snapshot loader. */
+export declare function snapshotEnabled(o: Pick<ShellOptions, 'snapshot' | 'env'>): boolean;
+/** Module Federation options for a shell. Exported for tests and custom setups. */
+export declare function shellFederationOptions(o: ShellOptions, canResolve: (s: string) => boolean, resolvePath: (s: string) => string, versionOf?: (s: string) => string | undefined): FederationOptions;
+/**
+ * Throws when a shell built with `eager: false` has an entry that never calls
+ * `import()`: its shared singletons would not be ready when the entry runs.
+ * An entry file that does not exist is left for the bundler to report.
+ */
+export declare function assertAsyncBoundary(entryFile: string, read?: (file: string) => string | undefined): void;
+/** The `version` of the app's `package.json`, or `0.0.0` when it has none. */
+export declare function appVersion(cwd: string): string;
+/** Rsbuild config for the shell (host). */
+export declare function createShellConfig(o: ShellOptions): RsbuildConfig;

package/dist/index.js

@@ -0,0 +1,337 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { createRequire } from "node:module";
+import { parse } from "es-module-lexer/js";
+import { pluginReact } from "@rsbuild/plugin-react";
+import { pluginModuleFederation } from "@module-federation/rsbuild-plugin";
+const CJS_FILE = /\.cjs$/;
+const PATH_REQUEST = /^(?:\.\.?(?:[\\/]|$)|[\\/]|[A-Za-z]:[\\/])/;
+const MF_DIST = /[\\/]@module-federation[\\/][^\\/]+[\\/]dist[\\/]/;
+function isMfCjs(file) {
+    return CJS_FILE.test(file) && MF_DIST.test(file);
+}
+function swapPath(value, from, to) {
+    return value.replace(from, ()=>to);
+}
+function esmTwin(file, exists = node_fs.existsSync) {
+    const twin = [
+        file.replace(/\.cjs$/, '.js'),
+        file.replace(/\.cjs$/, '.mjs')
+    ].find((f)=>exists(f));
+    if (void 0 === twin) throw new Error(`@mfeflow/rsbuild: no ESM build next to ${file}. Set esmRuntime: false to keep the CommonJS runtime.`);
+    return twin;
+}
+function pluginMfEsmRuntime() {
+    return {
+        name: 'mfeflow:mf-esm-runtime',
+        setup (api) {
+            api.modifyRspackConfig((config, { rspack })=>{
+                config.module ??= {};
+                config.module.rules ??= [];
+                config.module.rules.push({
+                    test: CJS_FILE,
+                    include: MF_DIST,
+                    type: "javascript/auto"
+                });
+                config.plugins ??= [];
+                config.plugins.push(new rspack.NormalModuleReplacementPlugin(CJS_FILE, (data)=>{
+                    const created = data.createData;
+                    if (created?.resource !== void 0 && isMfCjs(created.resource)) {
+                        const cjs = created.resource;
+                        const esm = esmTwin(cjs);
+                        for (const key of [
+                            'request',
+                            'userRequest',
+                            'resource'
+                        ]){
+                            const value = created[key];
+                            if ('string' == typeof value) created[key] = swapPath(value, cjs, esm);
+                        }
+                    } else if (PATH_REQUEST.test(data.request)) {
+                        const target = node_path.resolve(data.context ?? '', data.request);
+                        if (isMfCjs(target)) data.request = esmTwin(target);
+                    }
+                }));
+            });
+        }
+    };
+}
+const RUNTIME_CONFIG_URL = '/config/runtime-config.json';
+const ENV_NAME = /^[a-z0-9-]+$/;
+const ENV_FILE = /^runtime-config\.([a-z0-9-]+)\.json$/;
+function runtimeConfigEnv(env) {
+    const name = void 0 === env.MFE_ENV || '' === env.MFE_ENV ? 'dev' : env.MFE_ENV;
+    if (!ENV_NAME.test(name)) throw new Error(`@mfeflow/rsbuild: MFE_ENV="${name}" is not an environment name (lowercase letters, digits, -)`);
+    return name;
+}
+function runtimeConfigEnvs(cwd) {
+    try {
+        return node_fs.readdirSync(node_path.join(cwd, 'public', 'config')).flatMap((name)=>ENV_FILE.exec(name)?.[1] ?? []).toSorted((a, b)=>a.localeCompare(b));
+    } catch  {
+        return [];
+    }
+}
+function runtimeConfigHandler(cwd, env) {
+    return (req, res, next)=>{
+        const pathname = (req.url ?? '').split('?')[0];
+        if (pathname !== RUNTIME_CONFIG_URL || 'GET' !== req.method && 'HEAD' !== req.method) return void next();
+        const file = node_path.join(cwd, 'public', 'config', `runtime-config.${env}.json`);
+        let body;
+        try {
+            body = node_fs.readFileSync(file, 'utf8');
+        } catch  {
+            const found = runtimeConfigEnvs(cwd).join(', ');
+            res.statusCode = 404;
+            res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+            res.end(`MFE_ENV=${env} has no public/config/runtime-config.${env}.json (found: ${found})`);
+            return;
+        }
+        res.statusCode = 200;
+        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+        res.setHeader('Cache-Control', 'no-store');
+        res.end('HEAD' === req.method ? void 0 : body);
+    };
+}
+function runtimeConfigSetup(cwd, env) {
+    if (0 === runtimeConfigEnvs(cwd).length) return;
+    const handler = runtimeConfigHandler(cwd, runtimeConfigEnv(env));
+    return ({ server })=>{
+        server.middlewares.use(handler);
+    };
+}
+const DEFAULT_SINGLETONS = [
+    'react',
+    'react/jsx-runtime',
+    'react/jsx-dev-runtime',
+    'react-dom',
+    'react-dom/client',
+    'react-router',
+    '@tanstack/react-query',
+    'i18next',
+    'react-i18next',
+    '@mfeflow/runtime',
+    '@mfeflow/analytics',
+    '@mfeflow/analytics/react',
+    '@mfeflow/telemetry',
+    '@mfeflow/storage',
+    '@mfeflow/storage/react',
+    '@mfeflow/theme',
+    '@mfeflow/theme/react',
+    '@mfeflow/i18n',
+    '@mfeflow/i18n/react'
+];
+function packageNameOf(specifier) {
+    const parts = specifier.split('/');
+    return specifier.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0] ?? specifier;
+}
+function resolvableFrom(cwd) {
+    const require = createRequire(node_path.join(cwd, 'package.json'));
+    return (specifier)=>{
+        try {
+            require.resolve(specifier);
+            return true;
+        } catch  {
+            return false;
+        }
+    };
+}
+function installedVersionFrom(cwd) {
+    const require = createRequire(node_path.join(cwd, 'package.json'));
+    return (specifier)=>{
+        const name = packageNameOf(specifier);
+        let file;
+        try {
+            file = require.resolve(name);
+        } catch  {
+            return;
+        }
+        let dir = node_path.dirname(file);
+        for(;;){
+            const candidate = node_path.join(dir, 'package.json');
+            if (node_fs.existsSync(candidate)) {
+                const pkg = JSON.parse(node_fs.readFileSync(candidate, 'utf8'));
+                if ('object' == typeof pkg && null !== pkg && Reflect.get(pkg, 'name') === name) {
+                    const version = Reflect.get(pkg, 'version');
+                    return 'string' == typeof version ? version : void 0;
+                }
+            }
+            const parent = node_path.dirname(dir);
+            if (parent === dir) return;
+            dir = parent;
+        }
+    };
+}
+function sharedSingletons(canResolve, extra = [], versionOf = ()=>void 0, eager = false) {
+    const out = {};
+    const add = (name)=>{
+        const version = versionOf(name);
+        out[name] = {
+            singleton: true,
+            ...void 0 === version ? {} : {
+                requiredVersion: `^${version}`
+            },
+            ...eager ? {
+                eager: true
+            } : {}
+        };
+    };
+    for (const name of DEFAULT_SINGLETONS)if (canResolve(name)) add(name);
+    for (const name of extra){
+        if (!canResolve(name)) throw new Error(`@mfeflow/rsbuild: shared package "${name}" cannot be resolved; is it installed?`);
+        add(name);
+    }
+    return out;
+}
+const NAME = /^[a-z][a-z0-9_]*$/;
+function checkName(name) {
+    if (!NAME.test(name)) throw new Error(`@mfeflow/rsbuild: "${name}" is not a valid Module Federation name (lowercase letters, digits, _)`);
+}
+function remoteFederationOptions(o, canResolve, versionOf) {
+    checkName(o.name);
+    if (0 === Object.keys(o.exposes).length) throw new Error(`@mfeflow/rsbuild: remote "${o.name}" exposes nothing`);
+    return {
+        name: o.name,
+        exposes: {
+            ...o.exposes
+        },
+        shared: sharedSingletons(canResolve, o.shared, versionOf),
+        manifest: true,
+        dts: false === o.types ? false : {
+            generateTypes: true,
+            consumeTypes: false
+        },
+        experiments: {
+            externalRuntime: true,
+            optimization: {
+                target: 'web',
+                ...true === o.consumesRemotes ? {} : {
+                    disableRemote: true
+                }
+            }
+        }
+    };
+}
+function createRemoteConfig(o) {
+    const cwd = o.cwd ?? process.cwd();
+    return {
+        plugins: [
+            pluginReact(),
+            ...false === o.esmRuntime ? [] : [
+                pluginMfEsmRuntime()
+            ],
+            pluginModuleFederation(remoteFederationOptions(o, resolvableFrom(cwd), installedVersionFrom(cwd)))
+        ],
+        source: {
+            entry: {
+                index: './src/index.ts'
+            }
+        },
+        output: {
+            assetPrefix: 'auto'
+        },
+        server: void 0 === o.port ? {} : {
+            port: o.port
+        }
+    };
+}
+function snapshotEnabled(o) {
+    return o.snapshot ?? 'production' !== (o.env ?? process.env).NODE_ENV;
+}
+function shellFederationOptions(o, canResolve, resolvePath, versionOf) {
+    checkName(o.name);
+    const env = o.env ?? process.env;
+    const typesBuild = '1' === env.MFEFLOW_TYPES && void 0 !== o.typesFrom;
+    const snapshot = snapshotEnabled(o);
+    const remotes = {};
+    if (typesBuild) for (const [remote, url] of Object.entries(o.typesFrom ?? {})){
+        checkName(remote);
+        remotes[remote] = `${remote}@${url}`;
+    }
+    return {
+        name: o.name,
+        remotes,
+        shared: sharedSingletons(canResolve, o.shared, versionOf, false !== o.eager),
+        manifest: true,
+        dts: typesBuild ? {
+            generateTypes: false,
+            consumeTypes: {
+                typesOnBuild: true,
+                abortOnError: true
+            }
+        } : false,
+        runtimePlugins: [
+            ...canResolve('@mfeflow/runtime/plugins/report') ? [
+                resolvePath('@mfeflow/runtime/plugins/report')
+            ] : [],
+            ...canResolve('@mfeflow/runtime/plugins/entry-retry') ? [
+                resolvePath('@mfeflow/runtime/plugins/entry-retry')
+            ] : [],
+            ...o.runtimePlugins ?? []
+        ],
+        experiments: {
+            provideExternalRuntime: true,
+            optimization: {
+                target: 'web',
+                ...snapshot ? {} : {
+                    disableSnapshot: true
+                }
+            }
+        }
+    };
+}
+const RELATIVE_SPECIFIER = /^\.\.?\//;
+function importsRelativeModule(source) {
+    try {
+        return parse(source)[0].some((i)=>'dynamic' === i.type && !i.glob && !i.probablyTypeOnly && void 0 !== i.specifier && RELATIVE_SPECIFIER.test(i.specifier));
+    } catch  {
+        return true;
+    }
+}
+function assertAsyncBoundary(entryFile, read = (f)=>node_fs.existsSync(f) ? node_fs.readFileSync(f, 'utf8') : void 0) {
+    const source = read(entryFile);
+    if (void 0 === source || importsRelativeModule(source)) return;
+    throw new Error(`@mfeflow/rsbuild: eager: false needs an async bootstrap boundary, but ${entryFile} has no import() of a relative module. Make it \`import('./bootstrap')\` (shared singletons load asynchronously, so a synchronous bootstrap fails with "Shared module is not available for eager consumption"), or drop eager: false.`);
+}
+function appVersion(cwd) {
+    try {
+        const pkg = JSON.parse(node_fs.readFileSync(node_path.join(cwd, 'package.json'), 'utf8'));
+        const version = 'object' == typeof pkg && null !== pkg ? Reflect.get(pkg, 'version') : void 0;
+        return 'string' == typeof version ? version : '0.0.0';
+    } catch  {
+        return '0.0.0';
+    }
+}
+function createShellConfig(o) {
+    const cwd = o.cwd ?? process.cwd();
+    const require = createRequire(node_path.join(cwd, 'package.json'));
+    if (false === o.eager) assertAsyncBoundary(node_path.join(cwd, 'src/index.ts'));
+    const setup = runtimeConfigSetup(cwd, o.env ?? process.env);
+    return {
+        plugins: [
+            pluginReact(),
+            ...false === o.esmRuntime ? [] : [
+                pluginMfEsmRuntime()
+            ],
+            pluginModuleFederation(shellFederationOptions(o, resolvableFrom(cwd), (s)=>require.resolve(s)))
+        ],
+        source: {
+            entry: {
+                index: './src/index.ts'
+            },
+            define: {
+                __MFEFLOW_SNAPSHOT__: JSON.stringify(snapshotEnabled(o)),
+                __MFEFLOW_APP_VERSION__: JSON.stringify(appVersion(cwd))
+            }
+        },
+        server: {
+            historyApiFallback: true,
+            ...void 0 === o.port ? {} : {
+                port: o.port
+            },
+            ...void 0 === setup ? {} : {
+                setup
+            }
+        }
+    };
+}
+export { DEFAULT_SINGLETONS, RUNTIME_CONFIG_URL, appVersion, assertAsyncBoundary, createRemoteConfig, createShellConfig, esmTwin, installedVersionFrom, isMfCjs, packageNameOf, pluginMfEsmRuntime, remoteFederationOptions, resolvableFrom, runtimeConfigEnv, runtimeConfigEnvs, runtimeConfigHandler, runtimeConfigSetup, sharedSingletons, shellFederationOptions, snapshotEnabled };

package/dist/runtime-config.d.ts

@@ -0,0 +1,22 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { RsbuildConfig } from '@rsbuild/core';
+type ServerSetup = NonNullable<NonNullable<RsbuildConfig['server']>['setup']>;
+type ServerSetupFn = Extract<ServerSetup, (...args: never[]) => unknown>;
+/** Where the shell fetches its runtime config from. */
+export declare const RUNTIME_CONFIG_URL = "/config/runtime-config.json";
+/** The environment whose runtime config the dev and preview servers answer with: `MFE_ENV`, default `dev`. */
+export declare function runtimeConfigEnv(env: Readonly<Record<string, string | undefined>>): string;
+/** The `<env>` of every `public/config/runtime-config.<env>.json`, sorted. */
+export declare function runtimeConfigEnvs(cwd: string): string[];
+/**
+ * Answers `/config/runtime-config.json` with `runtime-config.<env>.json`, read on every request so an
+ * edit shows on reload. A missing file for the chosen env is a 404 that says which envs exist.
+ */
+export declare function runtimeConfigHandler(cwd: string, env: string): (req: IncomingMessage, res: ServerResponse, next: () => void) => void;
+/**
+ * The `server.setup` for a shell with `public/config/runtime-config.<env>.json` files, or undefined
+ * without them. It serves the chosen env's file at `/config/runtime-config.json` in the dev and
+ * preview servers; a deployed build gets the same file copied there by the deploy step.
+ */
+export declare function runtimeConfigSetup(cwd: string, env: Readonly<Record<string, string | undefined>>): ServerSetupFn | undefined;
+export {};

package/dist/shared.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Packages every mfeflow app shares as singletons, when the app depends on
+ * them. Subpaths are listed on purpose: Module Federation shares each import
+ * specifier separately, and `react-dom/client` bypassing the share was a real
+ * React 19 bug (module-federation/core#4727).
+ */
+export declare const DEFAULT_SINGLETONS: readonly string[];
+export interface SharedConfig {
+    singleton: true;
+    /** `^<installed version>`. Set explicitly because Module Federation otherwise reads the raw spec from package.json, which is `catalog:` or `workspace:*` in pnpm workspaces. */
+    requiredVersion?: string;
+    /** Ships the package in the initial chunk instead of an async one (shell only). */
+    eager?: true;
+}
+/** `react-dom/client` → `react-dom`, `@mfeflow/theme/react` → `@mfeflow/theme`. */
+export declare function packageNameOf(specifier: string): string;
+/** Can `specifier` be resolved from the app in `cwd`? */
+export declare function resolvableFrom(cwd: string): (specifier: string) => boolean;
+/** Installed version of the package behind `specifier`, found by walking up from its entry file. */
+export declare function installedVersionFrom(cwd: string): (specifier: string) => string | undefined;
+/**
+ * The `shared` map for an app: the default singletons it can resolve, plus
+ * `extra`. Unresolvable defaults are skipped so a remote without i18n does not
+ * fail to build; unresolvable extras throw, because they are a typo.
+ */
+export declare function sharedSingletons(canResolve: (specifier: string) => boolean, extra?: readonly string[], versionOf?: (specifier: string) => string | undefined, eager?: boolean): Record<string, SharedConfig>;

package/package.json

@@ -1,6 +1,67 @@
 {
   "name": "@mfeflow/rsbuild",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Rsbuild presets for Module Federation 2.0 micro-frontends: createShellConfig and createRemoteConfig with shared singletons, external runtime, manifests, types and error reporting set up.",
+  "keywords": [
+    "micro-frontend",
+    "mfe",
+    "module-federation",
+    "module-federation-2",
+    "rsbuild",
+    "rspack",
+    "preset",
+    "react"
+  ],
+  "homepage": "https://mfeflow.github.io/mfeflow/",
+  "bugs": "https://github.com/mfeflow/mfeflow/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mfeflow/mfeflow.git",
+    "directory": "packages/rsbuild"
+  },
+  "license": "MIT",
+  "author": "Sanjeev Sharma <speedsharma.ai@gmail.com>",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.12"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@module-federation/rsbuild-plugin": "2.9.2",
+    "@rsbuild/plugin-react": "2.1.1",
+    "es-module-lexer": "3.0.4"
+  },
+  "peerDependencies": {
+    "@rsbuild/core": "^2.0.0"
+  },
+  "devDependencies": {
+    "@rsbuild/core": "2.3.0",
+    "@rslib/core": "1.0.5",
+    "@types/node": "26.6.6",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
+    "react": "19.3.1",
+    "react-dom": "19.3.1",
+    "typescript": "7.0.2"
+  },
+  "mfeflow": {
+    "bucket": "config"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "typecheck": "tsc --noEmit"
+  }
 }