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

package/dist/commands/bundle-remote/index.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleFederationConfigNormalized } from '../../types';
+import type { Config } from '../types';
+import type { BundleFederatedRemoteArgs } from './types';
+declare global {
+    var __METRO_FEDERATION_CONFIG: ModuleFederationConfigNormalized;
+    var __METRO_FEDERATION_ORIGINAL_ENTRY_PATH: string | undefined;
+    var __METRO_FEDERATION_REMOTE_ENTRY_PATH: string | undefined;
+    var __METRO_FEDERATION_MANIFEST_PATH: string | undefined;
+}
+declare function bundleFederatedRemote(_argv: Array<string>, cfg: Config, args: BundleFederatedRemoteArgs): Promise<void>;
+export default bundleFederatedRemote;
+export { default as bundleFederatedRemoteOptions } from './options';

package/dist/commands/bundle-remote/index.js

@@ -0,0 +1,241 @@
+"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__, {
+    bundleFederatedRemoteOptions: ()=>external_options_js_default(),
+    default: ()=>bundle_remote
+});
+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 external_node_util_namespaceObject = require("node:util");
+var external_node_util_default = /*#__PURE__*/ __webpack_require__.n(external_node_util_namespaceObject);
+const external_metro_namespaceObject = require("metro");
+const errors_js_namespaceObject = require("../../utils/errors.js");
+const federated_remote_types_js_namespaceObject = require("../../utils/federated-remote-types.js");
+const metro_compat_js_namespaceObject = require("../../utils/metro-compat.js");
+const create_module_path_remapper_js_namespaceObject = require("../utils/create-module-path-remapper.js");
+const create_resolver_js_namespaceObject = require("../utils/create-resolver.js");
+const load_metro_config_js_namespaceObject = require("../utils/load-metro-config.js");
+var load_metro_config_js_default = /*#__PURE__*/ __webpack_require__.n(load_metro_config_js_namespaceObject);
+const path_utils_js_namespaceObject = require("../utils/path-utils.js");
+const save_bundle_and_map_js_namespaceObject = require("../utils/save-bundle-and-map.js");
+const helpers_js_namespaceObject = require("../../plugin/helpers.js");
+const external_options_js_namespaceObject = require("./options.js");
+var external_options_js_default = /*#__PURE__*/ __webpack_require__.n(external_options_js_namespaceObject);
+const DEFAULT_OUTPUT = 'dist';
+async function buildBundle(server, requestOpts) {
+    const bundle = await server.build({
+        ...metro_compat_js_namespaceObject.Server.DEFAULT_BUNDLE_OPTIONS,
+        ...requestOpts
+    });
+    return bundle;
+}
+function getRequestOpts(args, opts) {
+    return {
+        dev: args.dev,
+        minify: void 0 !== args.minify ? args.minify : !args.dev,
+        platform: args.platform,
+        entryFile: opts.entryFile,
+        sourceUrl: opts.sourceUrl,
+        sourceMapUrl: opts.sourceMapUrl,
+        lazy: opts.isContainerModule,
+        runModule: opts.isContainerModule,
+        modulesOnly: !opts.isContainerModule
+    };
+}
+function getSaveBundleOpts(args, opts) {
+    return {
+        indexedRamBundle: false,
+        bundleEncoding: args.bundleEncoding,
+        dev: args.dev,
+        platform: args.platform,
+        sourcemapSourcesRoot: args.sourcemapSourcesRoot,
+        sourcemapUseAbsolutePath: args.sourcemapUseAbsolutePath,
+        bundleOutput: opts.bundleOutput,
+        sourcemapOutput: opts.sourcemapOutput
+    };
+}
+async function bundleFederatedRemote(_argv, cfg, args) {
+    const rawConfig = await load_metro_config_js_default()(cfg, {
+        maxWorkers: args.maxWorkers,
+        resetCache: args.resetCache,
+        config: args.config
+    });
+    const logger = cfg.logger ?? console;
+    const federationConfig = global.__METRO_FEDERATION_CONFIG;
+    if (!federationConfig) {
+        logger.error(`${external_node_util_default().styleText('red', 'error')} Module Federation configuration is missing.`);
+        logger.info("Import the plugin 'withModuleFederation' from '@module-federation/metro' package and wrap your final Metro config with it.");
+        throw new errors_js_namespaceObject.CLIError('Bundling failed');
+    }
+    const containerEntryFilepath = global.__METRO_FEDERATION_REMOTE_ENTRY_PATH;
+    if (!containerEntryFilepath) {
+        logger.error(`${external_node_util_default().styleText('red', 'error')} Cannot determine the container entry file path.`);
+        logger.info("To bundle a container, you need to expose at least one module in your Module Federation configuration.");
+        throw new errors_js_namespaceObject.CLIError('Bundling failed');
+    }
+    const manifestFilepath = global.__METRO_FEDERATION_MANIFEST_PATH;
+    if (!manifestFilepath) {
+        logger.error(`${external_node_util_default().styleText('red', 'error')} Cannot determine the manifest file path.`);
+        throw new errors_js_namespaceObject.CLIError('Bundling failed');
+    }
+    if (-1 === rawConfig.resolver.platforms.indexOf(args.platform)) {
+        logger.error(`${external_node_util_default().styleText('red', 'error')}: Invalid platform ${args.platform ? `"${external_node_util_default().styleText('bold', args.platform)}" ` : ''}selected.`);
+        logger.info(`Available platforms are: ${rawConfig.resolver.platforms.map((x)=>`"${external_node_util_default().styleText('bold', x)}"`).join(', ')}. If you are trying to bundle for an out-of-tree platform, it may not be installed.`);
+        throw new errors_js_namespaceObject.CLIError('Bundling failed');
+    }
+    process.env.NODE_ENV = args.dev ? 'development' : 'production';
+    const modulePathRemapper = (0, create_module_path_remapper_js_namespaceObject.createModulePathRemapper)();
+    const config = (0, external_metro_namespaceObject.mergeConfig)(rawConfig, {
+        resolver: {
+            resolveRequest: (context, moduleName, platform)=>{
+                const originalResolveRequest = rawConfig.resolver.resolveRequest;
+                const res = originalResolveRequest(context, moduleName, platform);
+                return modulePathRemapper.remap(res);
+            }
+        },
+        serializer: {
+            createModuleIdFactory: ()=>{
+                const factory = rawConfig.serializer.createModuleIdFactory();
+                return (path)=>factory(modulePathRemapper.reverse(path));
+            }
+        }
+    });
+    const server = new metro_compat_js_namespaceObject.Server(config);
+    config.server.enhanceMiddleware(server.processRequest, server);
+    const resolver = await (0, create_resolver_js_namespaceObject.createResolver)(server, args.platform);
+    const outputDir = args.output ? external_node_path_default().resolve(external_node_path_default().join(args.output, args.platform)) : external_node_path_default().resolve(config.projectRoot, external_node_path_default().join(DEFAULT_OUTPUT, args.platform));
+    const containerModule = {
+        [federationConfig.filename]: {
+            moduleInputFilepath: containerEntryFilepath,
+            moduleOutputDir: outputDir,
+            isContainerModule: true
+        }
+    };
+    const relativeContainerEntryPath = (0, helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(config.projectRoot, containerEntryFilepath));
+    resolver.resolve({
+        from: config.projectRoot,
+        to: `./${relativeContainerEntryPath}`
+    });
+    const exposedModules = Object.entries(federationConfig.exposes).map(([moduleName, moduleFilepath])=>[
+            moduleName.slice(2),
+            moduleFilepath
+        ]).reduce((acc, [moduleName, moduleInputFilepath])=>{
+        acc[moduleName] = {
+            moduleInputFilepath: external_node_path_default().resolve(config.projectRoot, moduleInputFilepath),
+            moduleOutputDir: external_node_path_default().resolve(outputDir, 'exposed'),
+            isContainerModule: false
+        };
+        return acc;
+    }, {});
+    const sharedModules = Object.entries(federationConfig.shared).filter(([, sharedConfig])=>!sharedConfig.eager && false !== sharedConfig.import).reduce((acc, [moduleName])=>{
+        const inputFilepath = resolver.resolve({
+            from: containerEntryFilepath,
+            to: moduleName
+        });
+        acc[moduleName] = {
+            moduleInputFilepath: inputFilepath,
+            moduleOutputDir: external_node_path_default().resolve(outputDir, 'shared'),
+            isContainerModule: false
+        };
+        return acc;
+    }, {});
+    const requests = Object.entries({
+        ...containerModule,
+        ...exposedModules,
+        ...sharedModules
+    }).map(([moduleName, { moduleInputFilepath, moduleOutputDir, isContainerModule = false }])=>{
+        const moduleBundleName = isContainerModule ? moduleName : `${moduleName}.bundle`;
+        const moduleBundleFilepath = external_node_path_default().resolve(moduleOutputDir, moduleBundleName);
+        const relativeModuleBundlePath = (0, path_utils_js_namespaceObject.normalizeOutputRelativePath)(external_node_path_default().relative(outputDir, moduleBundleFilepath));
+        const moduleBundleUrl = (0, path_utils_js_namespaceObject.toFileSourceUrl)(relativeModuleBundlePath);
+        const moduleSourceMapName = `${moduleBundleName}.map`;
+        const moduleSourceMapFilepath = external_node_path_default().resolve(moduleOutputDir, moduleSourceMapName);
+        const moduleSourceMapUrl = (0, path_utils_js_namespaceObject.normalizeOutputRelativePath)(external_node_path_default().relative(outputDir, moduleSourceMapFilepath));
+        if (!isContainerModule) modulePathRemapper.addMapping(moduleInputFilepath, relativeModuleBundlePath);
+        return {
+            targetDir: external_node_path_default().dirname(moduleBundleFilepath),
+            requestOpts: getRequestOpts(args, {
+                isContainerModule,
+                entryFile: moduleInputFilepath,
+                sourceUrl: moduleBundleUrl,
+                sourceMapUrl: moduleSourceMapUrl
+            }),
+            saveBundleOpts: getSaveBundleOpts(args, {
+                bundleOutput: moduleBundleFilepath,
+                sourcemapOutput: moduleSourceMapFilepath
+            })
+        };
+    });
+    try {
+        logger.info(`${external_node_util_default().styleText('blue', 'Processing remote container and exposed modules')}`);
+        for (const { requestOpts, saveBundleOpts, targetDir } of requests){
+            await external_node_fs_namespaceObject.promises.mkdir(targetDir, {
+                recursive: true,
+                mode: 493
+            });
+            const bundle = await buildBundle(server, requestOpts);
+            await (0, save_bundle_and_map_js_namespaceObject.saveBundleAndMap)(bundle, saveBundleOpts, logger.info);
+        }
+        const manifestOutputFilepath = external_node_path_default().resolve(outputDir, 'mf-manifest.json');
+        const typesMeta = await (0, federated_remote_types_js_namespaceObject.maybeGenerateFederatedRemoteTypes)({
+            federationConfig,
+            projectRoot: config.projectRoot,
+            outputDir,
+            logger
+        });
+        logger.info(`${external_node_util_default().styleText('blue', 'Processing manifest')}`);
+        const rawManifest = JSON.parse(await external_node_fs_namespaceObject.promises.readFile(manifestFilepath, 'utf-8'));
+        (0, federated_remote_types_js_namespaceObject.applyTypesMetaToManifest)(rawManifest, typesMeta);
+        await external_node_fs_namespaceObject.promises.writeFile(manifestOutputFilepath, JSON.stringify(rawManifest, void 0, 2), 'utf-8');
+        logger.info(`Done writing MF Manifest to:\n${external_node_util_default().styleText('dim', manifestOutputFilepath)}`);
+    } finally{
+        await server.end();
+    }
+}
+const bundle_remote = bundleFederatedRemote;
+exports.bundleFederatedRemoteOptions = __webpack_exports__.bundleFederatedRemoteOptions;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "bundleFederatedRemoteOptions",
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/commands/bundle-remote/index.mjs

@@ -0,0 +1,190 @@
+import "node:module";
+import { promises } from "node:fs";
+import node_path from "node:path";
+import node_util from "node:util";
+import { CLIError } from "../../utils/errors.mjs";
+import { applyTypesMetaToManifest, maybeGenerateFederatedRemoteTypes } from "../../utils/federated-remote-types.mjs";
+import { Server } from "../../utils/metro-compat.mjs";
+import { createModulePathRemapper } from "../utils/create-module-path-remapper.mjs";
+import { createResolver } from "../utils/create-resolver.mjs";
+import load_metro_config from "../utils/load-metro-config.mjs";
+import { normalizeOutputRelativePath, toFileSourceUrl } from "../utils/path-utils.mjs";
+import { saveBundleAndMap } from "../utils/save-bundle-and-map.mjs";
+import { toPosixPath } from "../../plugin/helpers.mjs";
+import { createRequire as __rspack_createRequire } from "node:module";
+const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+const external_metro_namespaceObject = __rspack_createRequire_require("metro");
+const DEFAULT_OUTPUT = 'dist';
+async function buildBundle(server, requestOpts) {
+    const bundle = await server.build({
+        ...Server.DEFAULT_BUNDLE_OPTIONS,
+        ...requestOpts
+    });
+    return bundle;
+}
+function getRequestOpts(args, opts) {
+    return {
+        dev: args.dev,
+        minify: void 0 !== args.minify ? args.minify : !args.dev,
+        platform: args.platform,
+        entryFile: opts.entryFile,
+        sourceUrl: opts.sourceUrl,
+        sourceMapUrl: opts.sourceMapUrl,
+        lazy: opts.isContainerModule,
+        runModule: opts.isContainerModule,
+        modulesOnly: !opts.isContainerModule
+    };
+}
+function getSaveBundleOpts(args, opts) {
+    return {
+        indexedRamBundle: false,
+        bundleEncoding: args.bundleEncoding,
+        dev: args.dev,
+        platform: args.platform,
+        sourcemapSourcesRoot: args.sourcemapSourcesRoot,
+        sourcemapUseAbsolutePath: args.sourcemapUseAbsolutePath,
+        bundleOutput: opts.bundleOutput,
+        sourcemapOutput: opts.sourcemapOutput
+    };
+}
+async function bundleFederatedRemote(_argv, cfg, args) {
+    const rawConfig = await load_metro_config(cfg, {
+        maxWorkers: args.maxWorkers,
+        resetCache: args.resetCache,
+        config: args.config
+    });
+    const logger = cfg.logger ?? console;
+    const federationConfig = global.__METRO_FEDERATION_CONFIG;
+    if (!federationConfig) {
+        logger.error(`${node_util.styleText('red', 'error')} Module Federation configuration is missing.`);
+        logger.info("Import the plugin 'withModuleFederation' from '@module-federation/metro' package and wrap your final Metro config with it.");
+        throw new CLIError('Bundling failed');
+    }
+    const containerEntryFilepath = global.__METRO_FEDERATION_REMOTE_ENTRY_PATH;
+    if (!containerEntryFilepath) {
+        logger.error(`${node_util.styleText('red', 'error')} Cannot determine the container entry file path.`);
+        logger.info("To bundle a container, you need to expose at least one module in your Module Federation configuration.");
+        throw new CLIError('Bundling failed');
+    }
+    const manifestFilepath = global.__METRO_FEDERATION_MANIFEST_PATH;
+    if (!manifestFilepath) {
+        logger.error(`${node_util.styleText('red', 'error')} Cannot determine the manifest file path.`);
+        throw new CLIError('Bundling failed');
+    }
+    if (-1 === rawConfig.resolver.platforms.indexOf(args.platform)) {
+        logger.error(`${node_util.styleText('red', 'error')}: Invalid platform ${args.platform ? `"${node_util.styleText('bold', args.platform)}" ` : ''}selected.`);
+        logger.info(`Available platforms are: ${rawConfig.resolver.platforms.map((x)=>`"${node_util.styleText('bold', x)}"`).join(', ')}. If you are trying to bundle for an out-of-tree platform, it may not be installed.`);
+        throw new CLIError('Bundling failed');
+    }
+    process.env.NODE_ENV = args.dev ? 'development' : 'production';
+    const modulePathRemapper = createModulePathRemapper();
+    const config = (0, external_metro_namespaceObject.mergeConfig)(rawConfig, {
+        resolver: {
+            resolveRequest: (context, moduleName, platform)=>{
+                const originalResolveRequest = rawConfig.resolver.resolveRequest;
+                const res = originalResolveRequest(context, moduleName, platform);
+                return modulePathRemapper.remap(res);
+            }
+        },
+        serializer: {
+            createModuleIdFactory: ()=>{
+                const factory = rawConfig.serializer.createModuleIdFactory();
+                return (path)=>factory(modulePathRemapper.reverse(path));
+            }
+        }
+    });
+    const server = new Server(config);
+    config.server.enhanceMiddleware(server.processRequest, server);
+    const resolver = await createResolver(server, args.platform);
+    const outputDir = args.output ? node_path.resolve(node_path.join(args.output, args.platform)) : node_path.resolve(config.projectRoot, node_path.join(DEFAULT_OUTPUT, args.platform));
+    const containerModule = {
+        [federationConfig.filename]: {
+            moduleInputFilepath: containerEntryFilepath,
+            moduleOutputDir: outputDir,
+            isContainerModule: true
+        }
+    };
+    const relativeContainerEntryPath = toPosixPath(node_path.relative(config.projectRoot, containerEntryFilepath));
+    resolver.resolve({
+        from: config.projectRoot,
+        to: `./${relativeContainerEntryPath}`
+    });
+    const exposedModules = Object.entries(federationConfig.exposes).map(([moduleName, moduleFilepath])=>[
+            moduleName.slice(2),
+            moduleFilepath
+        ]).reduce((acc, [moduleName, moduleInputFilepath])=>{
+        acc[moduleName] = {
+            moduleInputFilepath: node_path.resolve(config.projectRoot, moduleInputFilepath),
+            moduleOutputDir: node_path.resolve(outputDir, 'exposed'),
+            isContainerModule: false
+        };
+        return acc;
+    }, {});
+    const sharedModules = Object.entries(federationConfig.shared).filter(([, sharedConfig])=>!sharedConfig.eager && false !== sharedConfig.import).reduce((acc, [moduleName])=>{
+        const inputFilepath = resolver.resolve({
+            from: containerEntryFilepath,
+            to: moduleName
+        });
+        acc[moduleName] = {
+            moduleInputFilepath: inputFilepath,
+            moduleOutputDir: node_path.resolve(outputDir, 'shared'),
+            isContainerModule: false
+        };
+        return acc;
+    }, {});
+    const requests = Object.entries({
+        ...containerModule,
+        ...exposedModules,
+        ...sharedModules
+    }).map(([moduleName, { moduleInputFilepath, moduleOutputDir, isContainerModule = false }])=>{
+        const moduleBundleName = isContainerModule ? moduleName : `${moduleName}.bundle`;
+        const moduleBundleFilepath = node_path.resolve(moduleOutputDir, moduleBundleName);
+        const relativeModuleBundlePath = normalizeOutputRelativePath(node_path.relative(outputDir, moduleBundleFilepath));
+        const moduleBundleUrl = toFileSourceUrl(relativeModuleBundlePath);
+        const moduleSourceMapName = `${moduleBundleName}.map`;
+        const moduleSourceMapFilepath = node_path.resolve(moduleOutputDir, moduleSourceMapName);
+        const moduleSourceMapUrl = normalizeOutputRelativePath(node_path.relative(outputDir, moduleSourceMapFilepath));
+        if (!isContainerModule) modulePathRemapper.addMapping(moduleInputFilepath, relativeModuleBundlePath);
+        return {
+            targetDir: node_path.dirname(moduleBundleFilepath),
+            requestOpts: getRequestOpts(args, {
+                isContainerModule,
+                entryFile: moduleInputFilepath,
+                sourceUrl: moduleBundleUrl,
+                sourceMapUrl: moduleSourceMapUrl
+            }),
+            saveBundleOpts: getSaveBundleOpts(args, {
+                bundleOutput: moduleBundleFilepath,
+                sourcemapOutput: moduleSourceMapFilepath
+            })
+        };
+    });
+    try {
+        logger.info(`${node_util.styleText('blue', 'Processing remote container and exposed modules')}`);
+        for (const { requestOpts, saveBundleOpts, targetDir } of requests){
+            await promises.mkdir(targetDir, {
+                recursive: true,
+                mode: 493
+            });
+            const bundle = await buildBundle(server, requestOpts);
+            await saveBundleAndMap(bundle, saveBundleOpts, logger.info);
+        }
+        const manifestOutputFilepath = node_path.resolve(outputDir, 'mf-manifest.json');
+        const typesMeta = await maybeGenerateFederatedRemoteTypes({
+            federationConfig,
+            projectRoot: config.projectRoot,
+            outputDir,
+            logger
+        });
+        logger.info(`${node_util.styleText('blue', 'Processing manifest')}`);
+        const rawManifest = JSON.parse(await promises.readFile(manifestFilepath, 'utf-8'));
+        applyTypesMetaToManifest(rawManifest, typesMeta);
+        await promises.writeFile(manifestOutputFilepath, JSON.stringify(rawManifest, void 0, 2), 'utf-8');
+        logger.info(`Done writing MF Manifest to:\n${node_util.styleText('dim', manifestOutputFilepath)}`);
+    } finally{
+        await server.end();
+    }
+}
+const bundle_remote = bundleFederatedRemote;
+export { default as bundleFederatedRemoteOptions } from "./options.mjs";
+export default bundle_remote;

package/dist/commands/bundle-remote/options.d.ts

@@ -0,0 +1,32 @@
+declare const options: ({
+    name: string;
+    description: string;
+    default: string;
+    parse?: undefined;
+} | {
+    name: string;
+    description: string;
+    parse: (val: string) => boolean;
+    default: boolean;
+} | {
+    name: string;
+    description: string;
+    parse: (val: string) => boolean;
+    default?: undefined;
+} | {
+    name: string;
+    description: string;
+    default?: undefined;
+    parse?: undefined;
+} | {
+    name: string;
+    description: string;
+    default: boolean;
+    parse?: undefined;
+} | {
+    name: string;
+    description: string;
+    parse: (val: string) => string;
+    default?: undefined;
+})[];
+export default options;

package/dist/commands/bundle-remote/options.js

@@ -0,0 +1,113 @@
+"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__, {
+    default: ()=>bundle_remote_options
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const options = [
+    {
+        name: '--platform <string>',
+        description: 'Either "ios" or "android"',
+        default: 'ios'
+    },
+    {
+        name: '--dev [boolean]',
+        description: 'If false, warnings are disabled and the bundle is minified',
+        parse: (val)=>'false' !== val,
+        default: true
+    },
+    {
+        name: '--minify [boolean]',
+        description: "Allows overriding whether bundle is minified. This defaults to false if dev is true, and true if dev is false. Disabling minification can be useful for speeding up production builds for testing purposes.",
+        parse: (val)=>'false' !== val
+    },
+    {
+        name: '--bundle-encoding <string>',
+        description: 'Encoding the bundle should be written in (https://nodejs.org/api/buffer.html#buffer_buffer).',
+        default: 'utf8'
+    },
+    {
+        name: '--max-workers <number>',
+        description: "Specifies the maximum number of workers the worker-pool will spawn for transforming files. This defaults to the number of the cores available on your machine."
+    },
+    {
+        name: '--sourcemap-output <string>',
+        description: 'File name where to store the sourcemap file for resulting bundle, ex. /tmp/groups.map'
+    },
+    {
+        name: '--sourcemap-sources-root <string>',
+        description: "Path to make sourcemap's sources entries relative to, ex. /root/dir"
+    },
+    {
+        name: '--sourcemap-use-absolute-path',
+        description: 'Report SourceMapURL using its full path',
+        default: false
+    },
+    {
+        name: '--assets-dest <string>',
+        description: 'Directory name where to store assets referenced in the bundle'
+    },
+    {
+        name: '--asset-catalog-dest [string]',
+        description: 'Path where to create an iOS Asset Catalog for images'
+    },
+    {
+        name: '--reset-cache',
+        description: 'Removes cached files',
+        default: false
+    },
+    {
+        name: '--config <string>',
+        description: 'Path to the CLI configuration file',
+        parse: (val)=>external_node_path_default().resolve(val)
+    },
+    {
+        name: '--output <string>',
+        description: 'Output directory for the bundle'
+    }
+];
+const bundle_remote_options = options;
+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/commands/bundle-remote/options.mjs

@@ -0,0 +1,66 @@
+import "node:module";
+import node_path from "node:path";
+const options = [
+    {
+        name: '--platform <string>',
+        description: 'Either "ios" or "android"',
+        default: 'ios'
+    },
+    {
+        name: '--dev [boolean]',
+        description: 'If false, warnings are disabled and the bundle is minified',
+        parse: (val)=>'false' !== val,
+        default: true
+    },
+    {
+        name: '--minify [boolean]',
+        description: "Allows overriding whether bundle is minified. This defaults to false if dev is true, and true if dev is false. Disabling minification can be useful for speeding up production builds for testing purposes.",
+        parse: (val)=>'false' !== val
+    },
+    {
+        name: '--bundle-encoding <string>',
+        description: 'Encoding the bundle should be written in (https://nodejs.org/api/buffer.html#buffer_buffer).',
+        default: 'utf8'
+    },
+    {
+        name: '--max-workers <number>',
+        description: "Specifies the maximum number of workers the worker-pool will spawn for transforming files. This defaults to the number of the cores available on your machine."
+    },
+    {
+        name: '--sourcemap-output <string>',
+        description: 'File name where to store the sourcemap file for resulting bundle, ex. /tmp/groups.map'
+    },
+    {
+        name: '--sourcemap-sources-root <string>',
+        description: "Path to make sourcemap's sources entries relative to, ex. /root/dir"
+    },
+    {
+        name: '--sourcemap-use-absolute-path',
+        description: 'Report SourceMapURL using its full path',
+        default: false
+    },
+    {
+        name: '--assets-dest <string>',
+        description: 'Directory name where to store assets referenced in the bundle'
+    },
+    {
+        name: '--asset-catalog-dest [string]',
+        description: 'Path where to create an iOS Asset Catalog for images'
+    },
+    {
+        name: '--reset-cache',
+        description: 'Removes cached files',
+        default: false
+    },
+    {
+        name: '--config <string>',
+        description: 'Path to the CLI configuration file',
+        parse: (val)=>node_path.resolve(val)
+    },
+    {
+        name: '--output <string>',
+        description: 'Output directory for the bundle'
+    }
+];
+const bundle_remote_options = options;
+export default bundle_remote_options;

package/dist/commands/bundle-remote/types.d.ts

@@ -0,0 +1,16 @@
+export type BundleFederatedRemoteArgs = {
+    entryFile: string;
+    platform: string;
+    dev: boolean;
+    minify?: boolean;
+    bundleEncoding?: 'utf8' | 'utf16le' | 'ascii';
+    maxWorkers?: string;
+    sourcemapOutput?: string;
+    sourcemapSourcesRoot?: string;
+    sourcemapUseAbsolutePath?: boolean;
+    assetsDest?: string;
+    assetCatalogDest?: string;
+    resetCache?: boolean;
+    config?: string;
+    output?: string;
+};