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

package/dist/runtime/remote-entry.js

@@ -0,0 +1,57 @@
+import 'mf:async-require';
+import { loadSharedToRegistry } from 'mf:remote-module-registry';
+import { init as runtimeInit } from '@module-federation/runtime';
+__PLUGINS__;
+const usedRemotes = __REMOTES__;
+const usedShared = __SHARED__;
+const exposesMap = __EXPOSES_MAP__;
+function get(moduleName) {
+    if (!(moduleName in exposesMap)) throw new Error(`Module ${moduleName} does not exist in container.`);
+    return exposesMap[moduleName]().then((m)=>()=>m);
+}
+const initTokens = {};
+const name = __NAME__;
+const shareScopeName = 'default';
+const shareStrategy = __SHARE_STRATEGY__;
+let hmrInitialized = false;
+async function init(shared = {}, initScope = []) {
+    const instance = runtimeInit({
+        name,
+        remotes: usedRemotes,
+        shared: usedShared,
+        plugins,
+        shareStrategy
+    });
+    let initToken = initTokens[shareScopeName];
+    if (!initToken) initToken = initTokens[shareScopeName] = {
+        from: name
+    };
+    if (initScope.indexOf(initToken) >= 0) return;
+    initScope.push(initToken);
+    instance.initShareScopeMap(shareScopeName, shared);
+    const initSharingPromise = Promise.all(instance.initializeSharing(shareScopeName, {
+        strategy: shareStrategy,
+        from: 'build',
+        initScope
+    }));
+    __EARLY_SHARED__.forEach(loadSharedToRegistry);
+    await initSharingPromise;
+    if (__DEV__ && !hmrInitialized) {
+        const hmr = require('mf:remote-hmr');
+        hmr.setup();
+        hmrInitialized = true;
+    }
+    await Promise.all(Object.keys(shared).map(loadSharedToRegistry));
+    return instance;
+}
+globalThis.__FEDERATION__ ??= {};
+globalThis.__FEDERATION__.__NATIVE__ ??= {};
+globalThis.__FEDERATION__.__NATIVE__[name] ??= {};
+globalThis.__FEDERATION__.__NATIVE__[name].deps ??= {
+    shared: {},
+    remotes: {}
+};
+globalThis.__FEDERATION__.__NATIVE__[name].exports = {
+    get,
+    init
+};

package/dist/runtime/remote-hmr.js

@@ -0,0 +1,19 @@
+function parseUrl(url) {
+    const urlPattern = /^((https?):\/\/([^:/]+)(?::(\d+))?)\/?(.*)?$/;
+    const match = url.match(urlPattern);
+    if (!match) throw new Error('Invalid URL: ' + url);
+    const [, origin, scheme, host, port, path] = match;
+    return {
+        origin,
+        scheme,
+        host,
+        port,
+        path
+    };
+}
+export function setup() {
+    const HMRClient = require('react-native/Libraries/Utilities/HMRClient');
+    const platform = require('react-native').Platform.OS;
+    const { scheme, host, port, path } = parseUrl(globalThis.__FEDERATION__.__NATIVE__[__METRO_GLOBAL_PREFIX__].origin);
+    HMRClient.default.setup(platform, path, host, port, true, scheme);
+}

package/dist/runtime/remote-module-registry.js

@@ -0,0 +1,57 @@
+import { loadRemote, loadShare, loadShareSync } from '@module-federation/runtime';
+const registry = {};
+const loading = {};
+const earlyModuleTest = __EARLY_MODULE_TEST__;
+function cloneModule(module, target) {
+    for (const key of Object.getOwnPropertyNames(module)){
+        const descriptor = Object.getOwnPropertyDescriptor(module, key);
+        Object.defineProperty(target, key, descriptor);
+    }
+}
+export async function loadAndGetShared(id) {
+    await loadSharedToRegistry(id);
+    return getModuleFromRegistry(id);
+}
+export async function loadAndGetRemote(id) {
+    await loadRemoteToRegistry(id);
+    return getModuleFromRegistry(id);
+}
+export async function loadRemoteToRegistry(id) {
+    const promise = loading[id];
+    if (promise) await promise;
+    else {
+        registry[id] = {};
+        loading[id] = (async ()=>{
+            const remoteModule = await loadRemote(id);
+            cloneModule(remoteModule, registry[id]);
+        })();
+        await loading[id];
+    }
+}
+export function loadSharedToRegistry(id) {
+    if (earlyModuleTest.test(id)) return loadSharedToRegistrySync(id);
+    return loadSharedToRegistryAsync(id);
+}
+export async function loadSharedToRegistryAsync(id) {
+    const promise = loading[id];
+    if (promise) await promise;
+    else {
+        registry[id] = {};
+        loading[id] = (async ()=>{
+            const factory = await loadShare(id);
+            const sharedModule = factory();
+            cloneModule(sharedModule, registry[id]);
+        })();
+        await loading[id];
+    }
+}
+export function loadSharedToRegistrySync(id) {
+    if (loading[id]) return;
+    loading[id] = loadShareSync(id);
+    registry[id] = loading[id]();
+}
+export function getModuleFromRegistry(id) {
+    const module = registry[id];
+    if (!module) throw new Error(`Module ${id} not found in registry`);
+    return module;
+}

package/dist/runtime/remote-module.js

@@ -0,0 +1,2 @@
+import { getModuleFromRegistry } from 'mf:remote-module-registry';
+module.exports = getModuleFromRegistry(__MODULE_ID__);

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+import type { moduleFederationPlugin } from '@module-federation/sdk';
+export interface ModuleFederationConfig extends moduleFederationPlugin.ModuleFederationPluginOptions {
+    /**
+     * @deprecated Use runtimePlugins instead. Scheduled for removal in the next major version.
+     */
+    plugins?: string[];
+}
+export type ShareObject = Record<string, moduleFederationPlugin.SharedConfig>;
+export interface ModuleFederationConfigNormalized {
+    name: string;
+    filename: string;
+    remotes: Record<string, string>;
+    exposes: Record<string, string>;
+    shared: ShareObject;
+    shareStrategy: moduleFederationPlugin.SharedStrategy;
+    plugins: string[];
+    dts: boolean | moduleFederationPlugin.PluginDtsOptions;
+}
+export type ModuleFederationExtraOptions = {
+    flags?: MetroMFFlags;
+};
+export type MetroMFFlags = {
+    unstable_patchHMRClient?: boolean;
+    unstable_patchInitializeCore?: boolean;
+    unstable_patchRuntimeRequire?: boolean;
+};

package/dist/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/utils/errors.d.ts

@@ -0,0 +1,8 @@
+declare class EnhancedError extends Error {
+    constructor(msg: string, originalError?: Error | string);
+}
+export declare class ConfigError extends EnhancedError {
+}
+export declare class CLIError extends EnhancedError {
+}
+export {};

package/dist/utils/errors.js

@@ -0,0 +1,54 @@
+"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__);
+const inlineString = (str = '')=>str.replace(/(\s{2,})/gm, ' ').trim();
+class EnhancedError extends Error {
+    constructor(msg, originalError){
+        super(inlineString(msg));
+        if (null != originalError) this.stack = 'string' == typeof originalError ? originalError : originalError.stack || ''.split('\n').slice(0, 2).join('\n');
+        else this.stack = '';
+    }
+}
+class ConfigError extends EnhancedError {
+}
+class CLIError extends EnhancedError {
+}
+__webpack_require__.d(__webpack_exports__, {
+    CLIError: ()=>CLIError,
+    ConfigError: ()=>ConfigError
+});
+exports.CLIError = __webpack_exports__.CLIError;
+exports.ConfigError = __webpack_exports__.ConfigError;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CLIError",
+    "ConfigError"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/errors.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+const inlineString = (str = '')=>str.replace(/(\s{2,})/gm, ' ').trim();
+class EnhancedError extends Error {
+    constructor(msg, originalError){
+        super(inlineString(msg));
+        if (null != originalError) this.stack = 'string' == typeof originalError ? originalError : originalError.stack || ''.split('\n').slice(0, 2).join('\n');
+        else this.stack = '';
+    }
+}
+class ConfigError extends EnhancedError {
+}
+class CLIError extends EnhancedError {
+}
+export { CLIError, ConfigError };

package/dist/utils/federated-remote-types.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleFederationConfigNormalized } from '../types';
+export type FederatedTypesMeta = {
+    zipName: string;
+    apiFileName: string;
+};
+export declare function maybeGenerateFederatedRemoteTypes(opts: {
+    federationConfig: ModuleFederationConfigNormalized;
+    projectRoot: string;
+    outputDir: string;
+    logger: Pick<Console, 'info' | 'warn'>;
+}): Promise<FederatedTypesMeta | undefined>;
+export declare function applyTypesMetaToManifest(manifest: Record<string, any>, typesMeta: FederatedTypesMeta | undefined): Record<string, any>;

package/dist/utils/federated-remote-types.js

@@ -0,0 +1,140 @@
+"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__, {
+    applyTypesMetaToManifest: ()=>applyTypesMetaToManifest,
+    maybeGenerateFederatedRemoteTypes: ()=>maybeGenerateFederatedRemoteTypes
+});
+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);
+async function maybeGenerateFederatedRemoteTypes(opts) {
+    const { federationConfig, projectRoot, outputDir, logger } = opts;
+    if (false === federationConfig.dts) return;
+    const dtsPlugin = await import("@module-federation/dts-plugin");
+    const dtsPluginCore = await import("@module-federation/dts-plugin/core");
+    const dtsConfig = true === federationConfig.dts ? {
+        consumeTypes: false
+    } : 'object' != typeof federationConfig.dts || null === federationConfig.dts || Object.prototype.hasOwnProperty.call(federationConfig.dts, 'consumeTypes') ? federationConfig.dts : {
+        ...federationConfig.dts,
+        consumeTypes: false
+    };
+    const mfOptions = {
+        name: federationConfig.name,
+        filename: federationConfig.filename,
+        remotes: federationConfig.remotes,
+        exposes: federationConfig.exposes,
+        shared: federationConfig.shared,
+        dts: dtsConfig
+    };
+    const normalizedDtsOptions = dtsPlugin.normalizeDtsOptions(mfOptions, projectRoot, {
+        defaultGenerateOptions: {
+            generateAPITypes: true,
+            compileInChildProcess: false,
+            abortOnError: false,
+            extractThirdParty: false,
+            extractRemoteTypes: false
+        },
+        defaultConsumeOptions: {
+            abortOnError: true,
+            consumeAPITypes: true
+        }
+    });
+    if (!normalizedDtsOptions) return;
+    const dtsManagerOptions = dtsPlugin.normalizeGenerateTypesOptions({
+        context: projectRoot,
+        outputDir,
+        dtsOptions: normalizedDtsOptions,
+        pluginOptions: mfOptions
+    });
+    if (!dtsManagerOptions) return;
+    if (dtsManagerOptions.host) {
+        let remoteTypeUrls = dtsManagerOptions.host.remoteTypeUrls;
+        if ('function' == typeof remoteTypeUrls) remoteTypeUrls = await remoteTypeUrls();
+        await dtsPluginCore.consumeTypes({
+            ...dtsManagerOptions,
+            host: {
+                ...dtsManagerOptions.host,
+                remoteTypeUrls
+            }
+        });
+    }
+    logger.info(`${external_node_util_default().styleText('blue', 'Generating federated types (d.ts)')}`);
+    await dtsPlugin.generateTypesAPI({
+        dtsManagerOptions
+    });
+    const { zipTypesPath, apiTypesPath, zipName, apiFileName } = dtsPluginCore.retrieveTypesAssetsInfo(dtsManagerOptions.remote);
+    const produced = {};
+    const fileExists = async (p)=>{
+        try {
+            await external_node_fs_namespaceObject.promises.stat(p);
+            return true;
+        } catch  {
+            return false;
+        }
+    };
+    if (zipTypesPath && zipName && await fileExists(zipTypesPath)) produced.zipName = zipName;
+    if (apiTypesPath && apiFileName && await fileExists(apiTypesPath)) produced.apiFileName = apiFileName;
+    if (process.env['FEDERATION_DEBUG']) logger.info(`dts debug: zipTypesPath=${zipTypesPath} zipExists=${String(Boolean(produced.zipName))} apiTypesPath=${apiTypesPath} apiExists=${String(Boolean(produced.apiFileName))}`);
+    if (!produced.zipName && !produced.apiFileName) return void logger.warn(`${external_node_util_default().styleText('yellow', 'Federated types enabled, but no types files were produced.')}`);
+    logger.info(`Done writing federated types:\n${external_node_util_default().styleText('dim', [
+        produced.zipName,
+        produced.apiFileName
+    ].filter(Boolean).join('\n'))}`);
+    return {
+        zipName: produced.zipName ?? '',
+        apiFileName: produced.apiFileName ?? ''
+    };
+}
+function applyTypesMetaToManifest(manifest, typesMeta) {
+    if (!typesMeta?.zipName && !typesMeta?.apiFileName) return manifest;
+    manifest.metaData = manifest.metaData || {};
+    manifest.metaData.types = manifest.metaData.types || {};
+    if (typesMeta.zipName) manifest.metaData.types.zip = typesMeta.zipName;
+    if (typesMeta.apiFileName) manifest.metaData.types.api = typesMeta.apiFileName;
+    return manifest;
+}
+exports.applyTypesMetaToManifest = __webpack_exports__.applyTypesMetaToManifest;
+exports.maybeGenerateFederatedRemoteTypes = __webpack_exports__.maybeGenerateFederatedRemoteTypes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyTypesMetaToManifest",
+    "maybeGenerateFederatedRemoteTypes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/federated-remote-types.mjs

@@ -0,0 +1,90 @@
+import "node:module";
+import { promises } from "node:fs";
+import node_util from "node:util";
+async function maybeGenerateFederatedRemoteTypes(opts) {
+    const { federationConfig, projectRoot, outputDir, logger } = opts;
+    if (false === federationConfig.dts) return;
+    const dtsPlugin = await import("@module-federation/dts-plugin");
+    const dtsPluginCore = await import("@module-federation/dts-plugin/core");
+    const dtsConfig = true === federationConfig.dts ? {
+        consumeTypes: false
+    } : 'object' != typeof federationConfig.dts || null === federationConfig.dts || Object.prototype.hasOwnProperty.call(federationConfig.dts, 'consumeTypes') ? federationConfig.dts : {
+        ...federationConfig.dts,
+        consumeTypes: false
+    };
+    const mfOptions = {
+        name: federationConfig.name,
+        filename: federationConfig.filename,
+        remotes: federationConfig.remotes,
+        exposes: federationConfig.exposes,
+        shared: federationConfig.shared,
+        dts: dtsConfig
+    };
+    const normalizedDtsOptions = dtsPlugin.normalizeDtsOptions(mfOptions, projectRoot, {
+        defaultGenerateOptions: {
+            generateAPITypes: true,
+            compileInChildProcess: false,
+            abortOnError: false,
+            extractThirdParty: false,
+            extractRemoteTypes: false
+        },
+        defaultConsumeOptions: {
+            abortOnError: true,
+            consumeAPITypes: true
+        }
+    });
+    if (!normalizedDtsOptions) return;
+    const dtsManagerOptions = dtsPlugin.normalizeGenerateTypesOptions({
+        context: projectRoot,
+        outputDir,
+        dtsOptions: normalizedDtsOptions,
+        pluginOptions: mfOptions
+    });
+    if (!dtsManagerOptions) return;
+    if (dtsManagerOptions.host) {
+        let remoteTypeUrls = dtsManagerOptions.host.remoteTypeUrls;
+        if ('function' == typeof remoteTypeUrls) remoteTypeUrls = await remoteTypeUrls();
+        await dtsPluginCore.consumeTypes({
+            ...dtsManagerOptions,
+            host: {
+                ...dtsManagerOptions.host,
+                remoteTypeUrls
+            }
+        });
+    }
+    logger.info(`${node_util.styleText('blue', 'Generating federated types (d.ts)')}`);
+    await dtsPlugin.generateTypesAPI({
+        dtsManagerOptions
+    });
+    const { zipTypesPath, apiTypesPath, zipName, apiFileName } = dtsPluginCore.retrieveTypesAssetsInfo(dtsManagerOptions.remote);
+    const produced = {};
+    const fileExists = async (p)=>{
+        try {
+            await promises.stat(p);
+            return true;
+        } catch  {
+            return false;
+        }
+    };
+    if (zipTypesPath && zipName && await fileExists(zipTypesPath)) produced.zipName = zipName;
+    if (apiTypesPath && apiFileName && await fileExists(apiTypesPath)) produced.apiFileName = apiFileName;
+    if (process.env['FEDERATION_DEBUG']) logger.info(`dts debug: zipTypesPath=${zipTypesPath} zipExists=${String(Boolean(produced.zipName))} apiTypesPath=${apiTypesPath} apiExists=${String(Boolean(produced.apiFileName))}`);
+    if (!produced.zipName && !produced.apiFileName) return void logger.warn(`${node_util.styleText('yellow', 'Federated types enabled, but no types files were produced.')}`);
+    logger.info(`Done writing federated types:\n${node_util.styleText('dim', [
+        produced.zipName,
+        produced.apiFileName
+    ].filter(Boolean).join('\n'))}`);
+    return {
+        zipName: produced.zipName ?? '',
+        apiFileName: produced.apiFileName ?? ''
+    };
+}
+function applyTypesMetaToManifest(manifest, typesMeta) {
+    if (!typesMeta?.zipName && !typesMeta?.apiFileName) return manifest;
+    manifest.metaData = manifest.metaData || {};
+    manifest.metaData.types = manifest.metaData.types || {};
+    if (typesMeta.zipName) manifest.metaData.types.zip = typesMeta.zipName;
+    if (typesMeta.apiFileName) manifest.metaData.types.api = typesMeta.apiFileName;
+    return manifest;
+}
+export { applyTypesMetaToManifest, maybeGenerateFederatedRemoteTypes };

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { CLIError, ConfigError } from './errors';
+export { VirtualModuleManager } from './vm-manager';

package/dist/utils/index.js

@@ -0,0 +1,47 @@
+"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__, {
+    CLIError: ()=>external_errors_js_namespaceObject.CLIError,
+    ConfigError: ()=>external_errors_js_namespaceObject.ConfigError,
+    VirtualModuleManager: ()=>external_vm_manager_js_namespaceObject.VirtualModuleManager
+});
+const external_errors_js_namespaceObject = require("./errors.js");
+const external_vm_manager_js_namespaceObject = require("./vm-manager.js");
+exports.CLIError = __webpack_exports__.CLIError;
+exports.ConfigError = __webpack_exports__.ConfigError;
+exports.VirtualModuleManager = __webpack_exports__.VirtualModuleManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CLIError",
+    "ConfigError",
+    "VirtualModuleManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/index.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+export { CLIError, ConfigError } from "./errors.mjs";
+export { VirtualModuleManager } from "./vm-manager.mjs";

package/dist/utils/metro-compat.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Metro Compatibility Layer
+ *
+ * Provides backwards-compatible imports for Metro 0.82 and 0.83+
+ *
+ * Metro 0.83 introduced a restrictive `exports` field that only allows
+ * `metro/private/*` paths instead of direct `metro/src/*` imports.
+ *
+ * This module dynamically resolves the correct import path based on the
+ * installed Metro version, ensuring compatibility with both versions.
+ */
+import type DefaultServer from 'metro/src/Server';
+import type DefaultBaseJSBundle from 'metro/src/DeltaBundler/Serializers/baseJSBundle';
+import type DefaultCountingSet from 'metro/src/lib/CountingSet';
+import type DefaultBundleToString from 'metro/src/lib/bundleToString';
+import type { MixedSourceMap } from 'metro-source-map';
+export declare const Server: typeof DefaultServer;
+export type Server = DefaultServer;
+export declare const baseJSBundle: typeof DefaultBaseJSBundle;
+export declare const CountingSet: typeof DefaultCountingSet;
+export declare const bundleToString: typeof DefaultBundleToString;
+export declare const relativizeSourceMapInline: (sourceMap: MixedSourceMap, sourcesRoot: string) => void;
+export type { RequestOptions, OutputOptions } from 'metro/src/shared/types';

package/dist/utils/metro-compat.js

@@ -0,0 +1,74 @@
+"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__);
+function resolveAndImport(metro83Path, metro82Path) {
+    let resolvedPath;
+    try {
+        resolvedPath = require.resolve(metro83Path);
+    } catch  {
+        try {
+            resolvedPath = require.resolve(metro82Path);
+        } catch  {
+            throw new Error(`Could not resolve 'metro' module. Tried:\n  - ${metro83Path}\n  - ${metro82Path}\nEnsure 'metro' is installed.`);
+        }
+    }
+    return require(resolvedPath);
+}
+function getDefaultExport(mod) {
+    if (null != mod && 'object' == typeof mod && 'default' in mod) return mod.default;
+    return mod;
+}
+const Server = getDefaultExport(resolveAndImport('metro/private/Server', 'metro/src/Server'));
+const baseJSBundle = getDefaultExport(resolveAndImport('metro/private/DeltaBundler/Serializers/baseJSBundle', 'metro/src/DeltaBundler/Serializers/baseJSBundle'));
+const CountingSet = getDefaultExport(resolveAndImport('metro/private/lib/CountingSet', 'metro/src/lib/CountingSet'));
+const bundleToString = getDefaultExport(resolveAndImport('metro/private/lib/bundleToString', 'metro/src/lib/bundleToString'));
+const relativizeSourceMapModule = resolveAndImport('metro/private/lib/relativizeSourceMap', 'metro/src/lib/relativizeSourceMap');
+const relativizeSourceMapInline = relativizeSourceMapModule.relativizeSourceMapInline || getDefaultExport(relativizeSourceMapModule);
+__webpack_require__.d(__webpack_exports__, {}, {
+    CountingSet: CountingSet,
+    Server: Server,
+    baseJSBundle: baseJSBundle,
+    bundleToString: bundleToString,
+    relativizeSourceMapInline: relativizeSourceMapInline
+});
+exports.CountingSet = __webpack_exports__.CountingSet;
+exports.Server = __webpack_exports__.Server;
+exports.baseJSBundle = __webpack_exports__.baseJSBundle;
+exports.bundleToString = __webpack_exports__.bundleToString;
+exports.relativizeSourceMapInline = __webpack_exports__.relativizeSourceMapInline;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CountingSet",
+    "Server",
+    "baseJSBundle",
+    "bundleToString",
+    "relativizeSourceMapInline"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});