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

package/dist/commands/utils/path-utils.js

@@ -0,0 +1,51 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    normalizeOutputRelativePath: ()=>normalizeOutputRelativePath,
+    toFileSourceUrl: ()=>toFileSourceUrl
+});
+const external_node_url_namespaceObject = require("node:url");
+const helpers_js_namespaceObject = require("../../plugin/helpers.js");
+function normalizeOutputRelativePath(relativePath) {
+    return (0, helpers_js_namespaceObject.toPosixPath)(relativePath);
+}
+function toFileSourceUrl(relativePath) {
+    const normalizedRelativePath = normalizeOutputRelativePath(relativePath);
+    return (0, external_node_url_namespaceObject.pathToFileURL)(`/${normalizedRelativePath}`).href;
+}
+exports.normalizeOutputRelativePath = __webpack_exports__.normalizeOutputRelativePath;
+exports.toFileSourceUrl = __webpack_exports__.toFileSourceUrl;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeOutputRelativePath",
+    "toFileSourceUrl"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/commands/utils/path-utils.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+import { pathToFileURL } from "node:url";
+import { toPosixPath } from "../../plugin/helpers.mjs";
+function normalizeOutputRelativePath(relativePath) {
+    return toPosixPath(relativePath);
+}
+function toFileSourceUrl(relativePath) {
+    const normalizedRelativePath = normalizeOutputRelativePath(relativePath);
+    return pathToFileURL(`/${normalizedRelativePath}`).href;
+}
+export { normalizeOutputRelativePath, toFileSourceUrl };

package/dist/commands/utils/save-bundle-and-map.d.ts

@@ -0,0 +1,5 @@
+import type { OutputOptions } from '../../utils/metro-compat';
+export declare function saveBundleAndMap(bundle: {
+    code: string;
+    map: string;
+}, options: OutputOptions, log: (msg: string) => void): Promise<void>;

package/dist/commands/utils/save-bundle-and-map.js

@@ -0,0 +1,80 @@
+"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__, {
+    saveBundleAndMap: ()=>saveBundleAndMap
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_util_namespaceObject = require("node:util");
+var external_node_util_default = /*#__PURE__*/ __webpack_require__.n(external_node_util_namespaceObject);
+const metro_compat_js_namespaceObject = require("../../utils/metro-compat.js");
+function relativizeSerializedMap(map, sourceMapSourcesRoot) {
+    const sourceMap = JSON.parse(map);
+    (0, metro_compat_js_namespaceObject.relativizeSourceMapInline)(sourceMap, sourceMapSourcesRoot);
+    return JSON.stringify(sourceMap);
+}
+async function saveBundleAndMap(bundle, options, log) {
+    const { bundleOutput, bundleEncoding: encoding, sourcemapOutput, sourcemapSourcesRoot } = options;
+    const writeFns = [];
+    writeFns.push(async ()=>{
+        log(`Writing bundle output to:\n${external_node_util_default().styleText('dim', bundleOutput)}`);
+        await external_node_fs_namespaceObject.promises.writeFile(bundleOutput, bundle.code, encoding);
+        log('Done writing bundle output');
+    });
+    if (sourcemapOutput) {
+        let { map } = bundle;
+        if (null != sourcemapSourcesRoot) {
+            log('Start relativating source map');
+            map = relativizeSerializedMap(map, sourcemapSourcesRoot);
+            log('Finished relativating');
+        }
+        writeFns.push(async ()=>{
+            log(`Writing sourcemap output to:\n${external_node_util_default().styleText('dim', sourcemapOutput)}`);
+            await external_node_fs_namespaceObject.promises.writeFile(sourcemapOutput, map);
+            log('Done writing sourcemap output');
+        });
+    }
+    await Promise.all(writeFns.map((cb)=>cb()));
+}
+exports.saveBundleAndMap = __webpack_exports__.saveBundleAndMap;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "saveBundleAndMap"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/commands/utils/save-bundle-and-map.mjs

@@ -0,0 +1,33 @@
+import "node:module";
+import { promises } from "node:fs";
+import node_util from "node:util";
+import { relativizeSourceMapInline } from "../../utils/metro-compat.mjs";
+function relativizeSerializedMap(map, sourceMapSourcesRoot) {
+    const sourceMap = JSON.parse(map);
+    relativizeSourceMapInline(sourceMap, sourceMapSourcesRoot);
+    return JSON.stringify(sourceMap);
+}
+async function saveBundleAndMap(bundle, options, log) {
+    const { bundleOutput, bundleEncoding: encoding, sourcemapOutput, sourcemapSourcesRoot } = options;
+    const writeFns = [];
+    writeFns.push(async ()=>{
+        log(`Writing bundle output to:\n${node_util.styleText('dim', bundleOutput)}`);
+        await promises.writeFile(bundleOutput, bundle.code, encoding);
+        log('Done writing bundle output');
+    });
+    if (sourcemapOutput) {
+        let { map } = bundle;
+        if (null != sourcemapSourcesRoot) {
+            log('Start relativating source map');
+            map = relativizeSerializedMap(map, sourcemapSourcesRoot);
+            log('Finished relativating');
+        }
+        writeFns.push(async ()=>{
+            log(`Writing sourcemap output to:\n${node_util.styleText('dim', sourcemapOutput)}`);
+            await promises.writeFile(sourcemapOutput, map);
+            log('Done writing sourcemap output');
+        });
+    }
+    await Promise.all(writeFns.map((cb)=>cb()));
+}
+export { saveBundleAndMap };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { withModuleFederation } from './plugin';
+export { updateManifest } from './plugin/manifest';

package/dist/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    updateManifest: ()=>manifest_js_namespaceObject.updateManifest,
+    withModuleFederation: ()=>index_js_namespaceObject.withModuleFederation
+});
+const index_js_namespaceObject = require("./plugin/index.js");
+const manifest_js_namespaceObject = require("./plugin/manifest.js");
+exports.updateManifest = __webpack_exports__.updateManifest;
+exports.withModuleFederation = __webpack_exports__.withModuleFederation;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "updateManifest",
+    "withModuleFederation"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+export { withModuleFederation } from "./plugin/index.mjs";
+export { updateManifest } from "./plugin/manifest.mjs";

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: import("@module-federation/sdk").Logger;
+export default logger;

package/dist/logger.js

@@ -0,0 +1,43 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    default: ()=>src_logger
+});
+const sdk_namespaceObject = require("@module-federation/sdk");
+const constants_js_namespaceObject = require("./plugin/constants.js");
+const logger = (0, sdk_namespaceObject.createLogger)(constants_js_namespaceObject.PLUGIN_IDENTIFIER);
+const src_logger = logger;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/logger.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+import { createLogger } from "@module-federation/sdk";
+import { PLUGIN_IDENTIFIER } from "./plugin/constants.mjs";
+const logger = createLogger(PLUGIN_IDENTIFIER);
+const src_logger = logger;
+export default src_logger;

package/dist/modules/HMRClient.ts

@@ -0,0 +1,31 @@
+import HMRClient from 'react-native/Libraries/Utilities/HMRClient';
+
+let hmrOrigin: string | null = null;
+
+const originalRegisterBundle = HMRClient.registerBundle;
+const originalSetup = HMRClient.setup;
+
+HMRClient.setup = (
+  platform: string,
+  bundleEntry: string,
+  host: string,
+  port: number | string,
+  isEnabled: boolean,
+  scheme = 'http',
+) => {
+  const serverHost = port !== null && port !== '' ? `${host}:${port}` : host;
+  hmrOrigin = `${scheme}://${serverHost}`;
+
+  return originalSetup(platform, bundleEntry, host, port, isEnabled, scheme);
+};
+
+HMRClient.registerBundle = (requestUrl: string) => {
+  // only process registerBundle calls from the same origin
+  if (!requestUrl.includes(hmrOrigin as string)) {
+    return;
+  }
+
+  return originalRegisterBundle(requestUrl);
+};
+
+export default HMRClient;

package/dist/modules/HMRClientShim.ts

@@ -0,0 +1 @@
+export { default } from 'react-native/Libraries/Utilities/HMRClientProdShim';

package/dist/modules/asyncRequire.ts

@@ -0,0 +1,156 @@
+// join two paths
+// e.g. /a/b/ + /c/d -> /a/b/c/d
+function joinComponents(prefix: string, suffix: string) {
+  return prefix.replace(/\/+$/, '') + '/' + suffix.replace(/^\/+/, '');
+}
+
+// get the public path from the url
+// e.g. http://host:8081/a/b.bundle -> http://host:8081/a
+function getPublicPath(url?: string) {
+  return url?.split('/').slice(0, -1).join('/');
+}
+
+function isUrl(url: string) {
+  return url.match(/^https?:\/\//);
+}
+
+// get bundle id from the bundle path
+// e.g. /a/b.bundle?platform=ios -> a/b
+// e.g. http://host:8081/a/b.bundle -> a/b
+function getBundleId(bundlePath: string, publicPath: string) {
+  let path = bundlePath;
+  // remove the public path if it's an url
+  if (isUrl(path)) {
+    path = path.replace(publicPath, '');
+  }
+  // remove the leading slash
+  if (path.startsWith('/')) {
+    path = path.slice(1);
+  }
+  // remove the query params and normalize Windows separators
+  path = path.split('?')[0].replaceAll('\\', '/');
+  // remove the bundle extension
+  return path.replace('.bundle', '');
+}
+
+function isSameOrigin(url: string, originPublicPath?: string) {
+  // if it's not a fully qualified url, we assume it's the same origin
+  if (!isUrl(url)) {
+    return true;
+  }
+  return !!originPublicPath && url.startsWith(originPublicPath);
+}
+
+// prefix the bundle path with the public path
+// e.g. /a/b.bundle -> http://host:8081/a/b.bundle
+function getBundlePath(bundlePath: string, bundleOrigin?: string) {
+  // don't modify the path in development
+  if (process.env.NODE_ENV !== 'production') {
+    return bundlePath;
+  }
+  // don't modify fully qualified urls
+  // e.g. when loading container modules
+  if (isUrl(bundlePath)) {
+    return bundlePath;
+  }
+  // don't modify the path if we don't know the bundle origin
+  // e.g. when loading host split bundles
+  if (!bundleOrigin) {
+    return bundlePath;
+  }
+  return joinComponents(bundleOrigin, bundlePath);
+}
+
+function buildLoadBundleAsyncWrapper() {
+  const registry = require('mf:remote-module-registry');
+
+  const __loadBundleAsync =
+    globalThis[`${__METRO_GLOBAL_PREFIX__ ?? ''}__loadBundleAsync`];
+
+  const loadBundleAsync =
+    __loadBundleAsync as typeof globalThis.__loadBundleAsync;
+
+  return async (originalBundlePath: string): Promise<void> => {
+    const scope = globalThis.__FEDERATION__.__NATIVE__[__METRO_GLOBAL_PREFIX__];
+
+    // entry is always in the root directory of assets associated with remote
+    // based on that, we extract the public path from the origin URL
+    // e.g. http://example.com/a/b/c/mf-manfiest.json -> http://example.com/a/b/c
+    const publicPath = getPublicPath(scope.origin);
+    let bundlePath = getBundlePath(originalBundlePath, publicPath);
+
+    const isSplitBundle = !isUrl(originalBundlePath);
+
+    // Cache handler registered externally (e.g. by zephyr-native-cache register()).
+    // Stored under __FEDERATION__.__NATIVE__.__CACHE__ as a singleton (no prefix scope).
+    const cacheHandler = (globalThis as any).__FEDERATION__?.__NATIVE__
+      ?.__CACHE__ as
+      | ((
+          fallback: (path: string) => Promise<void>,
+          bundlePath: string,
+        ) => Promise<void>)
+      | undefined;
+
+    // For remote split bundles with cache enabled, convert relative paths to
+    // full URLs so they enter the same cache path as container bundles.
+    // In dev mode, getBundlePath returns relative paths unchanged, but we need
+    // full URLs for the cache layer (download + eval).
+    if (isSplitBundle && cacheHandler && publicPath && !isUrl(bundlePath)) {
+      bundlePath = joinComponents(publicPath, bundlePath);
+    }
+
+    // ../../node_modules/ -> ..%2F..%2Fnode_modules/ so that it's not automatically sanitized
+    const encodedBundlePath = bundlePath.replaceAll('../', '..%2F');
+
+    let result;
+    if (cacheHandler) {
+      await cacheHandler(loadBundleAsync, encodedBundlePath);
+    } else {
+      result = await loadBundleAsync(encodedBundlePath);
+    }
+
+    // when the origin is not the same, it means we are loading a remote container
+    // we can return early since dependencies are processed differently for entry bundles
+    if (!isSameOrigin(bundlePath, publicPath)) {
+      return result;
+    }
+
+    // at this point the code in the bundle has been evaluated
+    // but not yet executed through metroRequire
+    // note: at this point, public path is always defined
+    const bundleId = getBundleId(bundlePath, publicPath!);
+    const shared = scope.deps.shared[bundleId];
+    const remotes = scope.deps.remotes[bundleId];
+
+    const promises = [];
+    if (shared && shared.length > 0) {
+      // load shared used synchronously in the bundle
+      promises.push(...shared.map(registry.loadSharedToRegistry));
+    }
+    if (remotes && remotes.length > 0) {
+      // load remotes used synchronously in the bundle
+      promises.push(...remotes.map(registry.loadRemoteToRegistry));
+    }
+
+    await Promise.all(promises);
+
+    return result;
+  };
+}
+
+// load expo async require if outside expo
+if (!process.env.EXPO_OS) {
+  // @expo/metro-runtime/src/async-require/fetchAsync.native.ts requires
+  // process.env.EXPO_OS to be set but since expo is optional, we set it
+  // to an empty string as a fallback to prevent reference errors
+  process.env.EXPO_OS = '';
+
+  const {
+    buildAsyncRequire,
+  } = require('@expo/metro-runtime/src/async-require/buildAsyncRequire');
+
+  global[`${__METRO_GLOBAL_PREFIX__}__loadBundleAsync`] = buildAsyncRequire();
+}
+
+global[`${__METRO_GLOBAL_PREFIX__}__loadBundleAsync`] =
+  buildLoadBundleAsyncWrapper();

package/dist/modules/asyncStartup.tsx

@@ -0,0 +1,43 @@
+import type { Federation } from '@module-federation/runtime';
+import React from 'react';
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __DEV__: boolean;
+  // eslint-disable-next-line no-var
+  var __METRO_GLOBAL_PREFIX__: string;
+  // eslint-disable-next-line no-var
+  var __FUSEBOX_HAS_FULL_CONSOLE_SUPPORT__: boolean;
+  // eslint-disable-next-line no-var
+  var __loadBundleAsync: (entry: string) => Promise<void>;
+  // eslint-disable-next-line no-var
+  var __FEDERATION__: Federation;
+}
+
+type LazyComponent = { default: React.ComponentType };
+
+function getFallbackComponent(lazyFallbackFn?: () => LazyComponent) {
+  if (!lazyFallbackFn) return () => null;
+  const fallback = lazyFallbackFn();
+  return fallback.default;
+}
+
+export function withAsyncStartup(
+  lazyAppFn: () => LazyComponent,
+  lazyFallbackFn?: () => LazyComponent,
+): () => () => React.JSX.Element {
+  const AppComponent = React.lazy(async () => {
+    await globalThis.__FEDERATION__.__NATIVE__[__METRO_GLOBAL_PREFIX__].init;
+    return lazyAppFn();
+  });
+
+  const FallbackComponent = getFallbackComponent(lazyFallbackFn);
+
+  return () => () => {
+    return (
+      <React.Suspense fallback={<FallbackComponent />}>
+        <AppComponent />
+      </React.Suspense>
+    );
+  };
+}

package/dist/modules/getDevServer.ts

@@ -0,0 +1,15 @@
+export default function getDevServer() {
+  const scriptUrl =
+    globalThis.__FEDERATION__.__NATIVE__[__METRO_GLOBAL_PREFIX__].origin;
+
+  if (!scriptUrl) {
+    throw new Error(
+      `Cannot determine dev server URL for ${__METRO_GLOBAL_PREFIX__} remote`,
+    );
+  }
+
+  return {
+    url: scriptUrl.match(/^https?:\/\/.*?\//)![0],
+    fullBundleUrl: scriptUrl,
+  };
+}

package/dist/modules/metroCorePlugin.ts

@@ -0,0 +1,87 @@
+import type {
+  Federation,
+  ModuleFederationRuntimePlugin,
+} from '@module-federation/runtime';
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __DEV__: boolean;
+  // eslint-disable-next-line no-var
+  var __METRO_GLOBAL_PREFIX__: string;
+  // eslint-disable-next-line no-var
+  var __FUSEBOX_HAS_FULL_CONSOLE_SUPPORT__: boolean;
+  // eslint-disable-next-line no-var
+  var __loadBundleAsync: (entry: string) => Promise<void>;
+  // eslint-disable-next-line no-var
+  var __FEDERATION__: Federation;
+}
+
+const getQueryParams = () => {
+  const isFuseboxEnabled = !!globalThis.__FUSEBOX_HAS_FULL_CONSOLE_SUPPORT__;
+  const queryParams: Record<string, string> = {
+    platform: require('react-native').Platform.OS,
+    dev: 'true',
+    lazy: 'true',
+    minify: 'false',
+    runModule: 'true',
+    modulesOnly: 'false',
+  };
+
+  if (isFuseboxEnabled) {
+    queryParams.excludeSource = 'true';
+    queryParams.sourcePaths = 'url-server';
+  }
+
+  return new URLSearchParams(queryParams);
+};
+
+const buildUrlForEntryBundle = (entry: string) => {
+  if (__DEV__) {
+    return `${entry}?${getQueryParams().toString()}`;
+  }
+  return entry;
+};
+
+const MetroCorePlugin: () => ModuleFederationRuntimePlugin = () => ({
+  name: 'metro-core-plugin',
+  loadEntry: async ({ remoteInfo }) => {
+    const { entry, entryGlobalName } = remoteInfo;
+
+    const __loadBundleAsync =
+      globalThis[`${__METRO_GLOBAL_PREFIX__ ?? ''}__loadBundleAsync`];
+
+    const loadBundleAsync =
+      __loadBundleAsync as typeof globalThis.__loadBundleAsync;
+
+    if (!loadBundleAsync) {
+      throw new Error('loadBundleAsync is not defined');
+    }
+
+    try {
+      const entryUrl = buildUrlForEntryBundle(entry);
+      await loadBundleAsync(entryUrl);
+
+      if (!globalThis.__FEDERATION__.__NATIVE__[entryGlobalName]) {
+        throw new Error(`Remote entry ${entryGlobalName} failed to register.`);
+      }
+
+      globalThis.__FEDERATION__.__NATIVE__[entryGlobalName].origin = entryUrl;
+
+      return globalThis.__FEDERATION__.__NATIVE__[entryGlobalName].exports;
+    } catch (error) {
+      throw new Error(
+        `Failed to load remote entry: ${entryGlobalName}. Reason: ${error}`,
+      );
+    }
+  },
+  generatePreloadAssets: async () => {
+    // noop for compatibility
+    return Promise.resolve({
+      cssAssets: [],
+      jsAssetsWithoutEntry: [],
+      entryAssets: [],
+    });
+  },
+});
+
+export default MetroCorePlugin;

package/dist/plugin/babel-transformer.d.ts

@@ -0,0 +1,11 @@
+import type { ModuleFederationConfigNormalized } from '../types';
+interface CreateBabelTransformerOptions {
+    blacklistedPaths: string[];
+    federationConfig: ModuleFederationConfigNormalized;
+    originalBabelTransformerPath: string;
+    tmpDirPath: string;
+    enableInitializeCorePatching: boolean;
+    enableRuntimeRequirePatching: boolean;
+}
+export declare function createBabelTransformer({ blacklistedPaths, federationConfig, originalBabelTransformerPath, tmpDirPath, enableInitializeCorePatching, enableRuntimeRequirePatching, }: CreateBabelTransformerOptions): string;
+export {};