@module-federation/metro 0.0.0-chore-bump-node-22-20260710161714

package/dist/plugin/manifest-middleware.js

@@ -0,0 +1,217 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createManifestMiddleware: ()=>createManifestMiddleware
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const metro_compat_js_namespaceObject = require("../utils/metro-compat.js");
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_generators_js_namespaceObject = require("./generators.js");
+const external_helpers_js_namespaceObject = require("./helpers.js");
+const external_manifest_js_namespaceObject = require("./manifest.js");
+function createManifestMiddleware({ federationConfig, projectRoot, remoteEntryPath, tmpDirPath, vmManager }) {
+    const warmups = new Map();
+    return (middleware, metroServer)=>{
+        const nextMiddleware = middleware;
+        return async (req, res, next)=>{
+            try {
+                const warmupOptions = getManifestWarmupOptions(req.url);
+                if (warmupOptions) {
+                    const warmupKey = JSON.stringify(warmupOptions);
+                    let warmup = warmups.get(warmupKey);
+                    if (!warmup) {
+                        warmup = warmManifestBundles(metroServer, {
+                            federationConfig,
+                            host: req.headers.host,
+                            projectRoot,
+                            remoteEntryPath,
+                            tmpDirPath,
+                            vmManager,
+                            warmupOptions
+                        }).finally(()=>{
+                            warmups.delete(warmupKey);
+                        });
+                        warmups.set(warmupKey, warmup);
+                    }
+                    await warmup;
+                }
+                return nextMiddleware(req, res, next);
+            } catch (error) {
+                next(error instanceof Error ? error : new Error(String(error)));
+            }
+        };
+    };
+}
+function getManifestWarmupOptions(rawUrl) {
+    const parsedUrl = new URL(rawUrl ?? '/', 'http://localhost');
+    if (parsedUrl.pathname !== `/${external_constants_js_namespaceObject.MANIFEST_FILENAME}`) return null;
+    const platform = parsedUrl.searchParams.get('platform');
+    if (!platform) return null;
+    return {
+        dev: getBoolean(parsedUrl.searchParams, 'dev', true),
+        excludeSource: getBoolean(parsedUrl.searchParams, 'excludeSource', false),
+        minify: getBoolean(parsedUrl.searchParams, 'minify', false),
+        platform,
+        sourcePaths: parsedUrl.searchParams.get('sourcePaths') ?? void 0
+    };
+}
+async function warmManifestBundles(metroServer, { federationConfig, host, projectRoot, remoteEntryPath, tmpDirPath, vmManager, warmupOptions }) {
+    for (const request of getBundleWarmupRequests({
+        federationConfig,
+        projectRoot,
+        remoteEntryPath,
+        tmpDirPath,
+        vmManager
+    })){
+        if (request.virtualModule) await ensureVirtualModuleReady(request.virtualModule, vmManager);
+        await metroServer.build(getBundleOptions(request, host, warmupOptions));
+    }
+}
+function getBundleWarmupRequests({ federationConfig, projectRoot, remoteEntryPath, tmpDirPath }) {
+    const relativeTmpDirPath = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(projectRoot, tmpDirPath));
+    const remoteEntryName = (0, external_helpers_js_namespaceObject.removeExtension)(external_node_path_default().basename(remoteEntryPath));
+    const relativeRemoteEntryPath = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(projectRoot, remoteEntryPath));
+    const requests = [
+        {
+            bundlePath: `${relativeTmpDirPath}/${remoteEntryName}.bundle`,
+            entryFile: `./${relativeRemoteEntryPath}`,
+            isContainer: true,
+            virtualModule: {
+                filePath: remoteEntryPath,
+                getCode: ()=>(0, external_generators_js_namespaceObject.getRemoteEntryModule)(federationConfig, {
+                        projectDir: projectRoot,
+                        tmpDir: tmpDirPath
+                    })
+            }
+        }
+    ];
+    for (const exposePath of Object.values(federationConfig.exposes)){
+        const bundlePath = getBundlePathForSource(exposePath);
+        requests.push({
+            bundlePath,
+            entryFile: normalizeEntryFile(exposePath),
+            isContainer: false
+        });
+    }
+    for (const [sharedName, sharedConfig] of Object.entries(federationConfig.shared)){
+        if (sharedConfig.eager || false === sharedConfig.import) continue;
+        const sharedVirtualModulePath = (0, external_manifest_js_namespaceObject.getSharedVirtualModulePath)(tmpDirPath, sharedName);
+        const relativeSharedVirtualModulePath = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(projectRoot, sharedVirtualModulePath));
+        const sharedImportName = getSharedImportName(sharedName, sharedConfig);
+        requests.push({
+            bundlePath: (0, external_helpers_js_namespaceObject.replaceExtension)(relativeSharedVirtualModulePath, '.bundle'),
+            entryFile: normalizeEntryFile(relativeSharedVirtualModulePath),
+            isContainer: false,
+            virtualModule: {
+                filePath: sharedVirtualModulePath,
+                getCode: ()=>(0, external_generators_js_namespaceObject.getRemoteModule)(sharedImportName)
+            }
+        });
+    }
+    return requests;
+}
+async function ensureVirtualModuleReady(virtualModule, vmManager) {
+    const code = virtualModule.getCode();
+    await external_node_fs_namespaceObject.promises.mkdir(external_node_path_default().dirname(virtualModule.filePath), {
+        recursive: true
+    });
+    await external_node_fs_namespaceObject.promises.writeFile(virtualModule.filePath, code, 'utf-8');
+    vmManager.registerVirtualModule(virtualModule.filePath, ()=>code);
+}
+function getBundleOptions(request, host, warmupOptions) {
+    const query = getBundleQuery(warmupOptions, request.isContainer);
+    const sourceUrl = getSourceUrl(host, request.bundlePath, query);
+    const bundleOptions = {
+        ...metro_compat_js_namespaceObject.Server.DEFAULT_BUNDLE_OPTIONS,
+        dev: warmupOptions.dev,
+        entryFile: request.entryFile,
+        excludeSource: warmupOptions.excludeSource,
+        lazy: true,
+        minify: warmupOptions.minify,
+        modulesOnly: !request.isContainer,
+        platform: warmupOptions.platform,
+        runModule: request.isContainer,
+        sourceMapUrl: sourceUrl.replace(/\.bundle(\?)/, '.map$1'),
+        sourceUrl
+    };
+    if (warmupOptions.sourcePaths) bundleOptions.sourcePaths = warmupOptions.sourcePaths;
+    return bundleOptions;
+}
+function getBundleQuery(warmupOptions, isContainer) {
+    const query = new URLSearchParams();
+    query.set('platform', warmupOptions.platform);
+    query.set('dev', String(warmupOptions.dev));
+    query.set('lazy', 'true');
+    query.set('minify', String(warmupOptions.minify));
+    query.set('runModule', String(isContainer));
+    query.set('modulesOnly', String(!isContainer));
+    if (warmupOptions.excludeSource) query.set('excludeSource', 'true');
+    if (warmupOptions.sourcePaths) query.set('sourcePaths', warmupOptions.sourcePaths);
+    return query;
+}
+function getSourceUrl(host, bundlePath, query) {
+    const normalizedBundlePath = bundlePath.startsWith('/') ? bundlePath : `/${bundlePath}`;
+    return `http://${host ?? 'localhost'}${normalizedBundlePath}?${query.toString()}`;
+}
+function getBundlePathForSource(sourcePath) {
+    const normalized = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().normalize(sourcePath));
+    const withoutPrefix = normalized.startsWith('./') ? normalized.slice(2) : normalized;
+    return (0, external_helpers_js_namespaceObject.replaceExtension)(withoutPrefix, '.bundle');
+}
+function normalizeEntryFile(sourcePath) {
+    const normalized = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().normalize(sourcePath));
+    return normalized.startsWith('./') ? normalized : `./${normalized}`;
+}
+function getSharedImportName(sharedName, sharedConfig) {
+    return 'string' == typeof sharedConfig.import ? sharedConfig.import : sharedName;
+}
+function getBoolean(params, key, defaultValue) {
+    const value = params.get(key);
+    if (null == value) return defaultValue;
+    return 'true' === value || '1' === value;
+}
+exports.createManifestMiddleware = __webpack_exports__.createManifestMiddleware;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createManifestMiddleware"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/manifest-middleware.mjs

@@ -0,0 +1,170 @@
+import "node:module";
+import { promises } from "node:fs";
+import node_path from "node:path";
+import { Server } from "../utils/metro-compat.mjs";
+import { MANIFEST_FILENAME } from "./constants.mjs";
+import { getRemoteEntryModule, getRemoteModule } from "./generators.mjs";
+import { removeExtension, replaceExtension, toPosixPath } from "./helpers.mjs";
+import { getSharedVirtualModulePath } from "./manifest.mjs";
+function createManifestMiddleware({ federationConfig, projectRoot, remoteEntryPath, tmpDirPath, vmManager }) {
+    const warmups = new Map();
+    return (middleware, metroServer)=>{
+        const nextMiddleware = middleware;
+        return async (req, res, next)=>{
+            try {
+                const warmupOptions = getManifestWarmupOptions(req.url);
+                if (warmupOptions) {
+                    const warmupKey = JSON.stringify(warmupOptions);
+                    let warmup = warmups.get(warmupKey);
+                    if (!warmup) {
+                        warmup = warmManifestBundles(metroServer, {
+                            federationConfig,
+                            host: req.headers.host,
+                            projectRoot,
+                            remoteEntryPath,
+                            tmpDirPath,
+                            vmManager,
+                            warmupOptions
+                        }).finally(()=>{
+                            warmups.delete(warmupKey);
+                        });
+                        warmups.set(warmupKey, warmup);
+                    }
+                    await warmup;
+                }
+                return nextMiddleware(req, res, next);
+            } catch (error) {
+                next(error instanceof Error ? error : new Error(String(error)));
+            }
+        };
+    };
+}
+function getManifestWarmupOptions(rawUrl) {
+    const parsedUrl = new URL(rawUrl ?? '/', 'http://localhost');
+    if (parsedUrl.pathname !== `/${MANIFEST_FILENAME}`) return null;
+    const platform = parsedUrl.searchParams.get('platform');
+    if (!platform) return null;
+    return {
+        dev: getBoolean(parsedUrl.searchParams, 'dev', true),
+        excludeSource: getBoolean(parsedUrl.searchParams, 'excludeSource', false),
+        minify: getBoolean(parsedUrl.searchParams, 'minify', false),
+        platform,
+        sourcePaths: parsedUrl.searchParams.get('sourcePaths') ?? void 0
+    };
+}
+async function warmManifestBundles(metroServer, { federationConfig, host, projectRoot, remoteEntryPath, tmpDirPath, vmManager, warmupOptions }) {
+    for (const request of getBundleWarmupRequests({
+        federationConfig,
+        projectRoot,
+        remoteEntryPath,
+        tmpDirPath,
+        vmManager
+    })){
+        if (request.virtualModule) await ensureVirtualModuleReady(request.virtualModule, vmManager);
+        await metroServer.build(getBundleOptions(request, host, warmupOptions));
+    }
+}
+function getBundleWarmupRequests({ federationConfig, projectRoot, remoteEntryPath, tmpDirPath }) {
+    const relativeTmpDirPath = toPosixPath(node_path.relative(projectRoot, tmpDirPath));
+    const remoteEntryName = removeExtension(node_path.basename(remoteEntryPath));
+    const relativeRemoteEntryPath = toPosixPath(node_path.relative(projectRoot, remoteEntryPath));
+    const requests = [
+        {
+            bundlePath: `${relativeTmpDirPath}/${remoteEntryName}.bundle`,
+            entryFile: `./${relativeRemoteEntryPath}`,
+            isContainer: true,
+            virtualModule: {
+                filePath: remoteEntryPath,
+                getCode: ()=>getRemoteEntryModule(federationConfig, {
+                        projectDir: projectRoot,
+                        tmpDir: tmpDirPath
+                    })
+            }
+        }
+    ];
+    for (const exposePath of Object.values(federationConfig.exposes)){
+        const bundlePath = getBundlePathForSource(exposePath);
+        requests.push({
+            bundlePath,
+            entryFile: normalizeEntryFile(exposePath),
+            isContainer: false
+        });
+    }
+    for (const [sharedName, sharedConfig] of Object.entries(federationConfig.shared)){
+        if (sharedConfig.eager || false === sharedConfig.import) continue;
+        const sharedVirtualModulePath = getSharedVirtualModulePath(tmpDirPath, sharedName);
+        const relativeSharedVirtualModulePath = toPosixPath(node_path.relative(projectRoot, sharedVirtualModulePath));
+        const sharedImportName = getSharedImportName(sharedName, sharedConfig);
+        requests.push({
+            bundlePath: replaceExtension(relativeSharedVirtualModulePath, '.bundle'),
+            entryFile: normalizeEntryFile(relativeSharedVirtualModulePath),
+            isContainer: false,
+            virtualModule: {
+                filePath: sharedVirtualModulePath,
+                getCode: ()=>getRemoteModule(sharedImportName)
+            }
+        });
+    }
+    return requests;
+}
+async function ensureVirtualModuleReady(virtualModule, vmManager) {
+    const code = virtualModule.getCode();
+    await promises.mkdir(node_path.dirname(virtualModule.filePath), {
+        recursive: true
+    });
+    await promises.writeFile(virtualModule.filePath, code, 'utf-8');
+    vmManager.registerVirtualModule(virtualModule.filePath, ()=>code);
+}
+function getBundleOptions(request, host, warmupOptions) {
+    const query = getBundleQuery(warmupOptions, request.isContainer);
+    const sourceUrl = getSourceUrl(host, request.bundlePath, query);
+    const bundleOptions = {
+        ...Server.DEFAULT_BUNDLE_OPTIONS,
+        dev: warmupOptions.dev,
+        entryFile: request.entryFile,
+        excludeSource: warmupOptions.excludeSource,
+        lazy: true,
+        minify: warmupOptions.minify,
+        modulesOnly: !request.isContainer,
+        platform: warmupOptions.platform,
+        runModule: request.isContainer,
+        sourceMapUrl: sourceUrl.replace(/\.bundle(\?)/, '.map$1'),
+        sourceUrl
+    };
+    if (warmupOptions.sourcePaths) bundleOptions.sourcePaths = warmupOptions.sourcePaths;
+    return bundleOptions;
+}
+function getBundleQuery(warmupOptions, isContainer) {
+    const query = new URLSearchParams();
+    query.set('platform', warmupOptions.platform);
+    query.set('dev', String(warmupOptions.dev));
+    query.set('lazy', 'true');
+    query.set('minify', String(warmupOptions.minify));
+    query.set('runModule', String(isContainer));
+    query.set('modulesOnly', String(!isContainer));
+    if (warmupOptions.excludeSource) query.set('excludeSource', 'true');
+    if (warmupOptions.sourcePaths) query.set('sourcePaths', warmupOptions.sourcePaths);
+    return query;
+}
+function getSourceUrl(host, bundlePath, query) {
+    const normalizedBundlePath = bundlePath.startsWith('/') ? bundlePath : `/${bundlePath}`;
+    return `http://${host ?? 'localhost'}${normalizedBundlePath}?${query.toString()}`;
+}
+function getBundlePathForSource(sourcePath) {
+    const normalized = toPosixPath(node_path.normalize(sourcePath));
+    const withoutPrefix = normalized.startsWith('./') ? normalized.slice(2) : normalized;
+    return replaceExtension(withoutPrefix, '.bundle');
+}
+function normalizeEntryFile(sourcePath) {
+    const normalized = toPosixPath(node_path.normalize(sourcePath));
+    return normalized.startsWith('./') ? normalized : `./${normalized}`;
+}
+function getSharedImportName(sharedName, sharedConfig) {
+    return 'string' == typeof sharedConfig.import ? sharedConfig.import : sharedName;
+}
+function getBoolean(params, key, defaultValue) {
+    const value = params.get(key);
+    if (null == value) return defaultValue;
+    return 'true' === value || '1' === value;
+}
+export { createManifestMiddleware };

package/dist/plugin/manifest.d.ts

@@ -0,0 +1,16 @@
+import type { ModuleFederationConfigNormalized } from '../types';
+export type BundleHashMap = Map<string, string>;
+export type ManifestGenerationOptions = {
+    projectRoot?: string;
+    target?: 'development' | 'build';
+    tmpDirPath?: string;
+};
+export declare function createManifest(options: ModuleFederationConfigNormalized, mfMetroPath: string, hashesOrOptions?: BundleHashMap | ManifestGenerationOptions, manifestOptions?: ManifestGenerationOptions): string;
+export declare function updateManifest(manifestPath: string, options: ModuleFederationConfigNormalized, hashesOrOptions?: BundleHashMap | ManifestGenerationOptions, manifestOptions?: ManifestGenerationOptions): string;
+/**
+ * Compute SHA-256 of bundle code and store the hash for the matching
+ * manifest entry (container, exposed, or shared).
+ */
+export declare function recordBundleHash(hashes: BundleHashMap, code: string, entryPoint: string, projectRoot: string, config: ModuleFederationConfigNormalized): void;
+export declare function getSharedVirtualModuleName(sharedName: string): string;
+export declare function getSharedVirtualModulePath(tmpDirPath: string, sharedName: string): string;

package/dist/plugin/manifest.js

@@ -0,0 +1,246 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createManifest: ()=>createManifest,
+    getSharedVirtualModuleName: ()=>getSharedVirtualModuleName,
+    getSharedVirtualModulePath: ()=>getSharedVirtualModulePath,
+    recordBundleHash: ()=>recordBundleHash,
+    updateManifest: ()=>updateManifest
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+var external_node_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_node_crypto_namespaceObject);
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_helpers_js_namespaceObject = require("./helpers.js");
+function createManifest(options, mfMetroPath, hashesOrOptions, manifestOptions) {
+    const { hashes, options: generationOptions } = normalizeManifestArgs(hashesOrOptions, manifestOptions);
+    const manifestPath = external_node_path_default().join(mfMetroPath, external_constants_js_namespaceObject.MANIFEST_FILENAME);
+    const manifest = generateManifest(options, hashes, generationOptions);
+    external_node_fs_default().writeFileSync(manifestPath, JSON.stringify(manifest, void 0, 2));
+    return manifestPath;
+}
+function updateManifest(manifestPath, options, hashesOrOptions, manifestOptions) {
+    const { hashes, options: generationOptions } = normalizeManifestArgs(hashesOrOptions, manifestOptions);
+    const manifest = generateManifest(options, hashes, generationOptions);
+    const existingManifest = readManifest(manifestPath);
+    if (existingManifest?.metaData?.types) manifest.metaData.types = {
+        ...manifest.metaData.types,
+        ...existingManifest.metaData.types
+    };
+    external_node_fs_default().writeFileSync(manifestPath, JSON.stringify(manifest, void 0, 2));
+    return manifestPath;
+}
+function recordBundleHash(hashes, code, entryPoint, projectRoot, config) {
+    const hash = external_node_crypto_default().createHash('sha256').update(code).digest('hex');
+    const key = resolveBundleKey(entryPoint, projectRoot, config);
+    if (key) hashes.set(key, hash);
+}
+function generateManifest(config, hashes, manifestOptions = {}) {
+    return {
+        id: config.name,
+        name: config.name,
+        metaData: generateMetaData(config, hashes),
+        exposes: generateExposes(config, hashes),
+        remotes: generateRemotes(config),
+        shared: generateShared(config, hashes, manifestOptions)
+    };
+}
+function generateMetaData(config, hashes) {
+    return {
+        name: config.name,
+        type: 'app',
+        buildInfo: {
+            buildVersion: '1.0.0',
+            buildName: config.name,
+            hash: hashes?.get(`container:${config.name}`) ?? ''
+        },
+        remoteEntry: {
+            name: config.filename,
+            path: '',
+            type: 'global'
+        },
+        types: {
+            path: '',
+            name: '',
+            api: '',
+            zip: ''
+        },
+        globalName: config.name,
+        pluginVersion: '',
+        publicPath: 'auto'
+    };
+}
+function generateExposes(config, hashes) {
+    return Object.keys(config.exposes).map((expose)=>{
+        const formatKey = expose.replace('./', '');
+        const assets = getEmptyAssets();
+        assets.js.sync.push(config.exposes[expose]);
+        return {
+            id: `${config.name}:${formatKey}`,
+            name: formatKey,
+            path: expose,
+            assets,
+            hash: hashes?.get(`expose:${formatKey}`) ?? ''
+        };
+    });
+}
+function generateRemotes(config) {
+    return Object.keys(config.remotes).map((remote)=>({
+            federationContainerName: config.remotes[remote],
+            moduleName: remote,
+            alias: remote,
+            entry: '*'
+        }));
+}
+function generateShared(config, hashes, manifestOptions = {}) {
+    return Object.keys(config.shared).map((sharedName)=>{
+        const assets = getEmptyAssets();
+        if (config.shared[sharedName].eager) assets.js.sync.push(config.filename);
+        else if (false !== config.shared[sharedName].import) assets.js.sync.push(getSharedAssetPath(sharedName, manifestOptions));
+        return {
+            id: sharedName,
+            name: sharedName,
+            version: getManifestVersion(config.shared[sharedName].version),
+            requiredVersion: getManifestRequiredVersion(config.shared[sharedName].requiredVersion),
+            singleton: config.shared[sharedName].singleton,
+            hash: hashes?.get(`shared:${sharedName}`) ?? '',
+            assets
+        };
+    });
+}
+function resolveBundleKey(entryPoint, projectRoot, config) {
+    const relPath = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(projectRoot, entryPoint));
+    const normalizedRel = relPath.startsWith('./') ? relPath.slice(2) : relPath;
+    const normalizedRelNoExt = (0, external_helpers_js_namespaceObject.removeExtension)(normalizedRel);
+    for (const [exposeKey, exposePath] of Object.entries(config.exposes)){
+        const normalizedExpose = (0, external_helpers_js_namespaceObject.toPosixPath)(exposePath.startsWith('./') ? exposePath.slice(2) : exposePath);
+        if (normalizedRel === normalizedExpose || normalizedRelNoExt === (0, external_helpers_js_namespaceObject.removeExtension)(normalizedExpose)) return `expose:${exposeKey.replace('./', '')}`;
+    }
+    if ((0, external_helpers_js_namespaceObject.removeExtension)(external_node_path_default().basename(entryPoint)) === (0, external_helpers_js_namespaceObject.removeExtension)(external_node_path_default().basename(config.filename))) return `container:${config.name}`;
+    const virtualSharedKey = resolveDevVirtualSharedKey(entryPoint, projectRoot, config);
+    if (virtualSharedKey) return virtualSharedKey;
+    const absPath = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().resolve(entryPoint));
+    const nmMatch = absPath.match(/.*node_modules\/(.+)/);
+    if (nmMatch) {
+        const modulePath = (0, external_helpers_js_namespaceObject.removeExtension)(nmMatch[1]);
+        const sharedKey = findSharedKeyForModulePath(modulePath, config);
+        if (sharedKey) return `shared:${sharedKey}`;
+    }
+    return null;
+}
+function normalizeManifestArgs(hashesOrOptions, manifestOptions) {
+    if (hashesOrOptions instanceof Map) return {
+        hashes: hashesOrOptions,
+        options: manifestOptions ?? {}
+    };
+    return {
+        hashes: void 0,
+        options: hashesOrOptions ?? {}
+    };
+}
+function readManifest(manifestPath) {
+    if (!external_node_fs_default().existsSync(manifestPath)) return;
+    return JSON.parse(external_node_fs_default().readFileSync(manifestPath, 'utf-8'));
+}
+function getSharedVirtualModuleName(sharedName) {
+    return sharedName.replaceAll('/', '_');
+}
+function getSharedVirtualModulePath(tmpDirPath, sharedName) {
+    return external_node_path_default().join(tmpDirPath, 'shared', `${getSharedVirtualModuleName(sharedName)}.js`);
+}
+function getSharedAssetPath(sharedName, manifestOptions) {
+    if ('development' === manifestOptions.target && manifestOptions.projectRoot && manifestOptions.tmpDirPath) return (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(manifestOptions.projectRoot, getSharedVirtualModulePath(manifestOptions.tmpDirPath, sharedName)));
+    return `shared/${sharedName}.bundle`;
+}
+function resolveDevVirtualSharedKey(entryPoint, projectRoot, config) {
+    const relativePath = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(projectRoot, entryPoint));
+    const virtualSharedPrefix = `node_modules/${external_constants_js_namespaceObject.TMP_DIR_NAME}/shared/`;
+    if (!relativePath.startsWith(virtualSharedPrefix)) return null;
+    const virtualModuleName = (0, external_helpers_js_namespaceObject.removeExtension)(relativePath.slice(virtualSharedPrefix.length));
+    const sharedKey = Object.keys(config.shared).find((sharedName)=>getSharedVirtualModuleName(sharedName) === virtualModuleName);
+    return sharedKey ? `shared:${sharedKey}` : null;
+}
+function findSharedKeyForModulePath(modulePath, config) {
+    const sharedEntries = Object.entries(config.shared).map(([sharedName, sharedConfig])=>{
+        const importName = 'string' == typeof sharedConfig.import ? sharedConfig.import : sharedName;
+        return {
+            importName,
+            sharedName
+        };
+    }).sort((a, b)=>b.importName.length - a.importName.length);
+    const normalizedModulePath = (0, external_helpers_js_namespaceObject.toPosixPath)(modulePath);
+    for (const { importName, sharedName } of sharedEntries)if (normalizedModulePath === importName || normalizedModulePath.startsWith(`${importName}/`)) return sharedName;
+    return null;
+}
+function getManifestVersion(version) {
+    return 'string' == typeof version ? version : '';
+}
+function getManifestRequiredVersion(requiredVersion) {
+    return 'string' == typeof requiredVersion ? requiredVersion : '*';
+}
+function getEmptyAssets() {
+    return {
+        js: {
+            sync: [],
+            async: []
+        },
+        css: {
+            sync: [],
+            async: []
+        }
+    };
+}
+exports.createManifest = __webpack_exports__.createManifest;
+exports.getSharedVirtualModuleName = __webpack_exports__.getSharedVirtualModuleName;
+exports.getSharedVirtualModulePath = __webpack_exports__.getSharedVirtualModulePath;
+exports.recordBundleHash = __webpack_exports__.recordBundleHash;
+exports.updateManifest = __webpack_exports__.updateManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createManifest",
+    "getSharedVirtualModuleName",
+    "getSharedVirtualModulePath",
+    "recordBundleHash",
+    "updateManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});