@module-federation/metro 0.0.0-next-20250827124348

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Callstack and Zephyr Cloud
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# metro
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build metro` to build the library.
+
+## Running unit tests
+
+Run `nx test metro` to execute the unit tests via [Jest](https://jestjs.io).

package/babel-plugin/index.js

@@ -0,0 +1,115 @@
+// reuse `@babel/types` from `metro`
+const metroPath = require.resolve('metro');
+const babelTypesPath = require.resolve('@babel/types', { paths: [metroPath] });
+const t = require(babelTypesPath);
+
+const UNSUPPORTED_IMPORT_MESSAGE =
+  'The module path for import() must be a static string literal. Expressions or variables are not supported.';
+const WEBPACK_IGNORE_COMMENT = 'webpackIgnore: true';
+
+function isIgnoredWebpackImport(path) {
+  const [firstArg] = path.node.arguments;
+
+  const comments = [
+    ...(firstArg?.leadingComments || []),
+    ...(path.node?.leadingComments || []),
+    ...(path.node?.innerComments || []),
+  ];
+
+  return (
+    t.isImport(path.node.callee) &&
+    comments.some((comment) => comment.value.includes(WEBPACK_IGNORE_COMMENT))
+  );
+}
+
+function getRemotesRegExp(remotes) {
+  return new RegExp(`^(${Object.keys(remotes).join('|')})/`);
+}
+
+function getSharedRegExp(shared) {
+  return new RegExp(`^(${Object.keys(shared).join('|')})$`);
+}
+
+function isRemoteImport(path, options) {
+  return (
+    t.isImport(path.node.callee) &&
+    t.isStringLiteral(path.node.arguments[0]) &&
+    Object.keys(options.remotes).length > 0 &&
+    path.node.arguments[0].value.match(getRemotesRegExp(options.remotes))
+  );
+}
+
+function isSharedImport(path, options) {
+  return (
+    t.isImport(path.node.callee) &&
+    t.isStringLiteral(path.node.arguments[0]) &&
+    Object.keys(options.shared).length > 0 &&
+    path.node.arguments[0].value.match(getSharedRegExp(options.shared))
+  );
+}
+
+function createWrappedImport(importName, methodName) {
+  const importArg = t.stringLiteral(importName);
+
+  // require('mf:remote-module-registry')
+  const requireCall = t.callExpression(t.identifier('require'), [
+    t.stringLiteral('mf:remote-module-registry'),
+  ]);
+
+  // .loadAndGetRemote(importName) or .loadAndGetShared(importName)
+  const loadAndGetCall = t.callExpression(
+    t.memberExpression(requireCall, t.identifier(methodName)),
+    [importArg],
+  );
+
+  return loadAndGetCall;
+}
+
+function getWrappedRemoteImport(importName) {
+  return createWrappedImport(importName, 'loadAndGetRemote');
+}
+
+function getWrappedSharedImport(importName) {
+  return createWrappedImport(importName, 'loadAndGetShared');
+}
+
+function getRejectedPromise(errorMessage) {
+  return t.callExpression(
+    t.memberExpression(t.identifier('Promise'), t.identifier('reject')),
+    [t.newExpression(t.identifier('Error'), [t.stringLiteral(errorMessage)])],
+  );
+}
+
+function moduleFederationMetroBabelPlugin() {
+  return {
+    name: 'module-federation-metro-babel-plugin',
+    visitor: {
+      CallExpression(path, state) {
+        if (state.opts.blacklistedPaths.includes(state.filename)) {
+          return;
+        }
+
+        // Workaround to remove problematic import from `loadEsmEntry` in `@module-federation/runtime-core`
+        // That causes crashes in Metro bundler
+        if (isIgnoredWebpackImport(path)) {
+          path.replaceWith(getRejectedPromise(UNSUPPORTED_IMPORT_MESSAGE));
+          return;
+        }
+
+        if (isRemoteImport(path, state.opts)) {
+          const wrappedImport = getWrappedRemoteImport(
+            path.node.arguments[0].value,
+          );
+          path.replaceWith(wrappedImport);
+        } else if (isSharedImport(path, state.opts)) {
+          const wrappedImport = getWrappedSharedImport(
+            path.node.arguments[0].value,
+          );
+          path.replaceWith(wrappedImport);
+        }
+      },
+    },
+  };
+}
+
+module.exports = moduleFederationMetroBabelPlugin;

package/babel-plugin/patch-initialize-core.js

@@ -0,0 +1,61 @@
+// reuse `@babel/types` from `metro`
+const metroPath = require.resolve('metro');
+const babelTypesPath = require.resolve('@babel/types', { paths: [metroPath] });
+const t = require(babelTypesPath);
+
+/**
+ * Inject require('mf:init-host') right after 'use strict' directive
+ * in React Native's Initialize Core
+ */
+function injectInitHostRequire(path, state) {
+  // Only process once per file
+  if (state.hasInjected) return;
+
+  let insertIndex = 0;
+
+  // Find the position after 'use strict' directive
+  for (let i = 0; i < path.node.body.length; i++) {
+    const node = path.node.body[i];
+    if (
+      t.isExpressionStatement(node) &&
+      t.isStringLiteral(node.expression) &&
+      node.expression.value === 'use strict'
+    ) {
+      insertIndex = i + 1;
+      break;
+    }
+  }
+
+  // Create the require('mf:init-host') statement
+  const requireStatement = t.expressionStatement(
+    t.callExpression(t.identifier('require'), [
+      t.stringLiteral('mf:init-host'),
+    ]),
+  );
+
+  // Insert the require statement
+  path.node.body.splice(insertIndex, 0, requireStatement);
+  state.hasInjected = true;
+}
+
+function metroPatchInitializeCorePlugin() {
+  return {
+    name: 'module-federation-metro-patch-initialize-core',
+    visitor: {
+      Program: {
+        enter(_, state) {
+          state.hasInjected = false;
+          state.shouldTransform = state.file.opts.filename.includes(
+            'react-native/Libraries/Core/InitializeCore.js',
+          );
+        },
+        exit(path, state) {
+          if (!state.shouldTransform) return;
+          injectInitHostRequire(path, state);
+        },
+      },
+    },
+  };
+}
+
+module.exports = metroPatchInitializeCorePlugin;

package/babel-plugin/patch-require.js

@@ -0,0 +1,174 @@
+// reuse `@babel/types` from `metro`
+const metroPath = require.resolve('metro');
+const babelTypesPath = require.resolve('@babel/types', { paths: [metroPath] });
+const t = require(babelTypesPath);
+
+const METRO_PREFIX = '__METRO_GLOBAL_PREFIX__';
+const GLOBAL_NAMES_TO_PREFIX = ['__r', '__c', '__registerSegment', '__accept'];
+const REFRESH_SYMBOLS = ['$RefreshReg$', '$RefreshSig$'];
+
+/**
+ * - global.__r = metroRequire;
+ * + global[`${__METRO_GLOBAL_PREFIX__}__r`] = metroRequire;
+ */
+function prefixGlobalNames(path) {
+  const { object, property, computed } = path.node;
+
+  if (
+    t.isIdentifier(object, { name: 'global' }) &&
+    t.isIdentifier(property) &&
+    !computed &&
+    GLOBAL_NAMES_TO_PREFIX.includes(property.name)
+  ) {
+    path.replaceWith(
+      t.memberExpression(
+        t.identifier('global'),
+        t.templateLiteral(
+          [
+            t.templateElement({ raw: '', cooked: '' }),
+            t.templateElement(
+              { raw: property.name, cooked: property.name },
+              true,
+            ),
+          ],
+          [t.identifier(METRO_PREFIX)],
+        ),
+        true,
+      ),
+    );
+  }
+}
+
+/**
+ * - global.$RefreshReg$ = () => {};
+ * - global.$RefreshSig$ = () => (type) => type;
+ * + global.$RefreshReg$ = global.$RefreshReg$ ?? (() => {});
+ * + global.$RefreshSig$ = global.$RefreshSig$ ?? (() => type => type);
+ */
+function defaultRefreshSymbols(path, state) {
+  const { node } = path;
+
+  if (
+    t.isMemberExpression(node.left) &&
+    t.isIdentifier(node.left.object, { name: 'global' }) &&
+    t.isIdentifier(node.left.property) &&
+    REFRESH_SYMBOLS.includes(node.left.property.name)
+  ) {
+    const propName = node.left.property.name;
+
+    if (state.hasTransformed[propName]) {
+      return;
+    }
+
+    const globalProp = t.memberExpression(
+      t.identifier('global'),
+      t.identifier(node.left.property.name),
+    );
+
+    path.replaceWith(
+      t.assignmentExpression(
+        '=',
+        globalProp,
+        t.logicalExpression('??', globalProp, node.right),
+      ),
+    );
+    state.hasTransformed[propName] = true;
+  }
+}
+
+/**
+ * - RefreshRuntime.register(type, moduleId + " " + id);
+ * + RefreshRuntime.register(type, __METRO_GLOBAL_PREFIX__ + ' ' + moduleId + ' ' + id);
+ */
+function prefixModuleIDs(path) {
+  const { callee, arguments: args } = path.node;
+  const isRegisterExports = t.isIdentifier(callee, {
+    name: 'registerExportsForReactRefresh',
+  });
+  const isRefreshRuntimeRegister =
+    t.isMemberExpression(callee) &&
+    t.isIdentifier(callee.object, { name: 'RefreshRuntime' }) &&
+    t.isIdentifier(callee.property, { name: 'register' });
+
+  if (!isRegisterExports && !isRefreshRuntimeRegister) return;
+
+  const lastArgIndex = args.length - 1;
+  const lastArg = args[lastArgIndex];
+
+  args[lastArgIndex] = t.binaryExpression(
+    '+',
+    t.identifier(METRO_PREFIX),
+    t.binaryExpression('+', t.stringLiteral(' '), lastArg),
+  );
+}
+
+/**
+ * - global[__METRO_GLOBAL_PREFIX__ + '__ReactRefresh'] || metroRequire.Refresh
+ * + global[global.__METRO_GLOBAL_PREFIX__ + '__ReactRefresh'] ||
+ * + metroRequire.Refresh
+ */
+function patchRequireRefresh(path) {
+  const funcPath = path.findParent(
+    (p) =>
+      (p.isFunctionDeclaration() || p.isFunctionExpression()) &&
+      p.node.id?.name === 'requireRefresh',
+  );
+
+  if (!funcPath) return;
+
+  const newReturn = t.logicalExpression(
+    '||',
+    t.memberExpression(
+      t.identifier('global'),
+      t.binaryExpression(
+        '+',
+        t.memberExpression(t.identifier('global'), t.identifier(METRO_PREFIX)),
+        t.stringLiteral('__ReactRefresh'),
+      ),
+      true,
+    ),
+    t.memberExpression(t.identifier('metroRequire'), t.identifier('Refresh')),
+  );
+
+  path.get('argument').replaceWith(newReturn);
+}
+
+function metroPatchRequireBabelPlugin() {
+  return {
+    name: 'module-federation-metro-patch-require',
+    visitor: {
+      Program: {
+        enter(_, state) {
+          // Transform only require.js from metro-runtime
+          state.shouldTransform = state.file.opts.filename.includes(
+            'metro-runtime/src/polyfills/require.js',
+          );
+          // Perform refreshSymbols transformation only once
+          // Because it is referenced in multiple places
+          state.hasTransformed = {
+            $RefreshReg$: false,
+            $RefreshSig$: false,
+          };
+        },
+      },
+      MemberExpression(path, state) {
+        if (!state.shouldTransform) return;
+        prefixGlobalNames(path);
+      },
+      AssignmentExpression(path, state) {
+        if (!state.shouldTransform) return;
+        defaultRefreshSymbols(path, state);
+      },
+      CallExpression(path, state) {
+        if (!state.shouldTransform) return;
+        prefixModuleIDs(path);
+      },
+      ReturnStatement(path, state) {
+        if (!state.shouldTransform) return;
+        patchRequireRefresh(path);
+      },
+    },
+  };
+}
+
+module.exports = metroPatchRequireBabelPlugin;

package/bootstrap/index.d.ts

@@ -0,0 +1 @@
+export { withAsyncStartup } from '../dist/modules/asyncStartup';

package/bootstrap/index.js

@@ -0,0 +1 @@
+module.exports = require('../dist/modules/asyncStartup');

package/dist/babel/transformer.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

package/dist/babel/transformer.js

@@ -0,0 +1,15 @@
+const babelTransformer = require('__BABEL_TRANSFORMER_PATH__');
+const babelPlugins = __BABEL_PLUGINS__;
+function transform(config) {
+    return babelTransformer.transform({
+        ...config,
+        plugins: [
+            ...babelPlugins,
+            ...config.plugins
+        ]
+    });
+}
+module.exports = {
+    ...babelTransformer,
+    transform
+};

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

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

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

@@ -0,0 +1,95 @@
+"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, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != 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__, {
+    bundleFederatedHostOptions: ()=>external_options_js_default(),
+    default: ()=>bundle_host
+});
+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 Server_namespaceObject = require("metro/src/Server");
+var Server_default = /*#__PURE__*/ __webpack_require__.n(Server_namespaceObject);
+const errors_js_namespaceObject = require("../../utils/errors.js");
+const create_resolver_js_namespaceObject = require("../utils/create-resolver.js");
+const get_community_plugin_js_namespaceObject = require("../utils/get-community-plugin.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 save_bundle_and_map_js_namespaceObject = require("../utils/save-bundle-and-map.js");
+const external_options_js_namespaceObject = require("./options.js");
+var external_options_js_default = /*#__PURE__*/ __webpack_require__.n(external_options_js_namespaceObject);
+async function bundleFederatedHost(_argv, cfg, args) {
+    const logger = cfg.logger ?? console;
+    global.__METRO_FEDERATION_ORIGINAL_ENTRY_PATH = args.entryFile;
+    const config = await load_metro_config_js_default()(cfg, {
+        maxWorkers: args.maxWorkers,
+        resetCache: args.resetCache,
+        config: args.config
+    });
+    const hostEntryFilepath = global.__METRO_FEDERATION_HOST_ENTRY_PATH;
+    if (!hostEntryFilepath) {
+        logger.error(`${external_node_util_default().styleText('red', 'error')} Cannot determine the host entrypoint path.`);
+        throw new errors_js_namespaceObject.CLIError('Bundling failed');
+    }
+    args.entryFile = hostEntryFilepath;
+    const communityCliPlugin = (0, get_community_plugin_js_namespaceObject.getCommunityCliPlugin)(cfg.reactNativePath);
+    const buildBundleWithConfig = communityCliPlugin.unstable_buildBundleWithConfig;
+    return buildBundleWithConfig(args, config, {
+        build: async (server, requestOpts)=>{
+            config.server.enhanceMiddleware(server.processRequest, server);
+            const resolver = await (0, create_resolver_js_namespaceObject.createResolver)(server, args.platform);
+            resolver.resolve({
+                from: config.projectRoot,
+                to: `./${external_node_path_default().relative(config.projectRoot, hostEntryFilepath)}`
+            });
+            return server.build({
+                ...Server_default().DEFAULT_BUNDLE_OPTIONS,
+                ...requestOpts
+            });
+        },
+        save: save_bundle_and_map_js_namespaceObject.saveBundleAndMap,
+        formatName: 'bundle'
+    });
+}
+const bundle_host = bundleFederatedHost;
+exports.bundleFederatedHostOptions = __webpack_exports__.bundleFederatedHostOptions;
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "bundleFederatedHostOptions",
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,69 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import node_path from "node:path";
+import node_util from "node:util";
+import { CLIError } from "../../utils/errors.mjs";
+import { createResolver } from "../utils/create-resolver.mjs";
+import { getCommunityCliPlugin } from "../utils/get-community-plugin.mjs";
+import load_metro_config from "../utils/load-metro-config.mjs";
+import { saveBundleAndMap } from "../utils/save-bundle-and-map.mjs";
+import options from "./options.mjs";
+import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "node:module";
+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 = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+const Server_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("metro/src/Server");
+var Server_default = /*#__PURE__*/ __webpack_require__.n(Server_namespaceObject);
+async function bundleFederatedHost(_argv, cfg, args) {
+    const logger = cfg.logger ?? console;
+    global.__METRO_FEDERATION_ORIGINAL_ENTRY_PATH = args.entryFile;
+    const config = await load_metro_config(cfg, {
+        maxWorkers: args.maxWorkers,
+        resetCache: args.resetCache,
+        config: args.config
+    });
+    const hostEntryFilepath = global.__METRO_FEDERATION_HOST_ENTRY_PATH;
+    if (!hostEntryFilepath) {
+        logger.error(`${node_util.styleText('red', 'error')} Cannot determine the host entrypoint path.`);
+        throw new CLIError('Bundling failed');
+    }
+    args.entryFile = hostEntryFilepath;
+    const communityCliPlugin = getCommunityCliPlugin(cfg.reactNativePath);
+    const buildBundleWithConfig = communityCliPlugin.unstable_buildBundleWithConfig;
+    return buildBundleWithConfig(args, config, {
+        build: async (server, requestOpts)=>{
+            config.server.enhanceMiddleware(server.processRequest, server);
+            const resolver = await createResolver(server, args.platform);
+            resolver.resolve({
+                from: config.projectRoot,
+                to: `./${node_path.relative(config.projectRoot, hostEntryFilepath)}`
+            });
+            return server.build({
+                ...Server_default().DEFAULT_BUNDLE_OPTIONS,
+                ...requestOpts
+            });
+        },
+        save: saveBundleAndMap,
+        formatName: 'bundle'
+    });
+}
+const bundle_host = bundleFederatedHost;
+export { options as bundleFederatedHostOptions, bundle_host as default };

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

@@ -0,0 +1,5 @@
+declare const options: {
+    name: string;
+    description: string;
+}[];
+export default options;

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

@@ -0,0 +1,39 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != 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_host_options
+});
+const get_community_plugin_js_namespaceObject = require("../utils/get-community-plugin.js");
+const communityCliPlugin = (0, get_community_plugin_js_namespaceObject.getCommunityCliPlugin)();
+const options = communityCliPlugin.bundleCommand.options;
+const bundle_host_options = options;
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/commands/bundle-host/options.mjs

@@ -0,0 +1,7 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { getCommunityCliPlugin } from "../utils/get-community-plugin.mjs";
+const communityCliPlugin = getCommunityCliPlugin();
+const options = communityCliPlugin.bundleCommand.options;
+const bundle_host_options = options;
+export { bundle_host_options as default };

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

@@ -0,0 +1,22 @@
+export type BundleFederatedHostArgs = {
+    assetsDest?: string;
+    assetCatalogDest?: string;
+    entryFile: string;
+    resetCache: boolean;
+    resetGlobalCache: boolean;
+    transformer?: string;
+    minify?: boolean;
+    config?: string;
+    platform: string;
+    dev: boolean;
+    bundleOutput: string;
+    bundleEncoding?: 'utf8' | 'utf16le' | 'ascii';
+    maxWorkers?: number;
+    sourcemapOutput?: string;
+    sourcemapSourcesRoot?: string;
+    sourcemapUseAbsolutePath: boolean;
+    verbose: boolean;
+    unstableTransformProfile: 'hermes-stable' | 'hermes-canary' | 'default';
+    indexedRamBundle?: boolean;
+    resolverOptions?: Array<string>;
+};