@hot-updater/react-native 1.0.0-rc.40 → 1.0.0-rc.42

package/lib/module/index.js

@@ -1,15 +1,17 @@
 "use strict";
 
-import { emitAfterAppReady } from "./appReady.js";
+import { createLaunchReporter } from "./appReady.js";
 import { checkForUpdate, reportUpdateError } from "./checkForUpdate.js";
 import { createHttpClient } from "./httpClient.js";
 import { addListener, getPublicActiveUpdateState, getActiveUpdateState, getBundleId, clearCrashHistory, getAppVersion, getBaseURL, getUpdateId, getChannel, getCohort, getCrashHistory, getDefaultChannel, getFingerprintHash, getInstallId, getManifest, getMinBundleId, isChannelSwitched, notifyAppReady, reload, resetChannel, setCohort, setReloadBehavior, stageBundle } from "./native.js";
-import { configurePlugins } from "./pluginHost.js";
+import { createAppPluginHost } from "./pluginHost.js";
 import { hotUpdaterStore } from "./store.js";
-import { init, wrap } from "./wrap.js";
+import { wrap } from "./wrap.js";
 export { defineClientPlugin } from "./clientPlugin.js";
 // The built-in Insights client plugin, for HotUpdater.init({ plugins }).
 export { insights } from "@hot-updater/plugin-insights/client";
+// The built-in Remote Config client plugin, for HotUpdater.init({ plugins }).
+export { remoteConfig } from "@hot-updater/plugin-remote-config/client";
 export * from "./store.js";
 export { extractSignatureFailure, isSignatureVerificationError } from "./types.js";
 /**
@@ -29,255 +31,204 @@ const registerGlobalGetBaseURL = () => {
 
 // Call registration immediately on module load
 registerGlobalGetBaseURL();
-/**
- * Creates a HotUpdater client instance with all update management methods.
- * This function is called once on module initialization to create a singleton instance.
- */
-function createHotUpdaterClient() {
-  let configurationAPI = null;
-  let mixedConfigurationReported = false;
+const createMissingNetworkConfigError = () => new Error(`[HotUpdater] baseURL must be provided.\n\n` + `Configure HotUpdater with the standard baseURL setup:\n\n` + `  export const hotUpdater = HotUpdater.init({\n` + `    baseURL: "<your-update-server-url>",\n` + `  });\n\n` + `See https://hot-updater.dev/docs/react-native-api/init`);
 
-  // Global configuration stored from wrap
-  const globalConfig = {
-    client: null
-  };
-  const createMissingNetworkConfigError = apiName => {
-    if (apiName === "init") {
-      return new Error(`[HotUpdater] baseURL must be provided.\n\n` + `Configure HotUpdater before calling update APIs with the standard baseURL setup:\n\n` + `  HotUpdater.init({\n` + `    baseURL: "<your-update-server-url>",\n` + `  });\n\n` + `For manual update flows, visit: https://hot-updater.dev/docs/guides/custom-update`);
-    }
-    const baseURLExample = `  export default HotUpdater.wrap({\n` + `    baseURL: "<your-update-server-url>",\n` + `    updateStrategy: "appVersion"\n` + `  })(App);\n\n`;
-    return new Error(`[HotUpdater] baseURL must be provided.\n\n` + `Configure HotUpdater.wrap with the standard baseURL setup:\n\n` + baseURLExample + `For manual update flows, use HotUpdater.init() and visit: ` + `https://hot-updater.dev/docs/guides/custom-update`);
-  };
-  const normalizeOptions = options => {
-    const incoming = options;
-    if (incoming.updateMode === "manual") {
-      throw new Error('[HotUpdater] HotUpdater.wrap({ updateMode: "manual" }) was removed. ' + "Call HotUpdater.init({ ... }) instead, export your root component " + "directly, and use HotUpdater.checkForUpdate(...) for the manual " + "update flow. See https://hot-updater.dev/docs/guides/custom-update");
-    }
-    const autoOptions = incoming;
-    if (autoOptions.baseURL) {
-      const {
-        baseURL,
-        plugins: _plugins,
-        ...rest
-      } = autoOptions;
-      return {
-        ...rest,
-        client: createHttpClient(baseURL, response => {
-          emitAfterAppReady("onHttpResponse", () => response);
-        })
-      };
-    }
-    throw createMissingNetworkConfigError("wrap");
-  };
-  const normalizeInitOptions = options => {
-    const {
-      updateMode: _updateMode,
-      ...rest
-    } = options;
-    if (rest.baseURL) {
-      const {
-        baseURL,
-        plugins: _plugins,
-        ...baseURLRest
-      } = rest;
-      return {
-        ...baseURLRest,
-        client: createHttpClient(baseURL, response => {
-          emitAfterAppReady("onHttpResponse", () => response);
-        })
-      };
-    }
-    throw createMissingNetworkConfigError("init");
-  };
-  const configureGlobal = (normalizedOptions, options) => {
-    // Plugins are set up before init or wrap reads the launch they observe.
-    configurePlugins(options.plugins, {
-      baseURL: options.baseURL,
-      requestHeaders: options.requestHeaders,
-      requestTimeout: options.requestTimeout,
-      onError: options.onError
-    });
-    globalConfig.client = normalizedOptions.client;
-    globalConfig.requestHeaders = options.requestHeaders;
-    globalConfig.requestTimeout = options.requestTimeout;
-    globalConfig.onError = options.onError;
-  };
-  const reportMixedConfiguration = nextAPI => {
-    if (configurationAPI !== null && configurationAPI !== nextAPI && !mixedConfigurationReported) {
-      mixedConfigurationReported = true;
-      console.error("[HotUpdater] HotUpdater.init() and HotUpdater.wrap() must not be used together. " + "For custom or manual update flows, use HotUpdater.init() with " + "HotUpdater.checkForUpdate(). For the automatic HOC flow, use " + "HotUpdater.wrap().");
-    }
-    configurationAPI ??= nextAPI;
-  };
-  const ensureGlobalClient = methodName => {
-    if (!globalConfig.client) {
-      throw new Error(`[HotUpdater] ${methodName} requires HotUpdater.wrap() or HotUpdater.init() to be used.\n\n` + `To fix this issue, configure HotUpdater before calling ${methodName}:\n\n` + `Option 1: With HotUpdater.wrap()\n` + `  export default HotUpdater.wrap({\n` + `    baseURL: "<your-update-server-url>",\n` + `    updateStrategy: "appVersion"\n` + `  })(App);\n\n` + `Option 2: With HotUpdater.init() for custom runtimes\n` + `  HotUpdater.init({\n` + `    baseURL: "<your-update-server-url>",\n` + `  });\n\n` + `For manual update flows, visit: https://hot-updater.dev/docs/guides/custom-update`);
+/** The methods that read or change native state, the same on every instance. */
+const nativeMethods = {
+  /**
+   * Reloads the app.
+   */
+  reload,
+  /**
+   * Configures how `hotUpdater.reload()` behaves.
+   *
+   * This can be called unconditionally on both platforms.
+   * The default is `processRestart`.
+   *
+   * - `reload`: built-in React Native reload on both platforms
+   * - `processRestart`: Android process restart, iOS behaves like normal reload
+   * - `custom`: run a custom JS handler on both platforms
+   */
+  setReloadBehavior,
+  /**
+   * Returns whether an update has finished downloading in this app session.
+   *
+   * When it returns true, calling `hotUpdater.reload()` (or restarting the app)
+   * will apply the downloaded update bundle.
+   *
+   * - Derived from `progress` reaching 1.0
+   * - Resets to false when a new download starts (progress < 1)
+   *
+   * @returns {boolean} True if a downloaded update is ready to apply
+   * @example
+   * ```ts
+   * if (hotUpdater.isUpdateDownloaded()) {
+   *   await hotUpdater.reload();
+   * }
+   * ```
+   */
+  isUpdateDownloaded: () => hotUpdaterStore.getSnapshot().isUpdateDownloaded,
+  /**
+   * Fetches the current app version.
+   */
+  getAppVersion,
+  /** Reads the active and stable Release/Bundle state. */
+  getActiveUpdateState: async () => getPublicActiveUpdateState(),
+  /**
+   * Returns the selected update ID, matching the ID shown in the console.
+   * A staged update can change this ID before the app reloads.
+   */
+  getBundleId: getUpdateId,
+  /** Returns the minimum bundle ID based on the native app build time. */
+  getMinBundleId,
+  /**
+   * Fetches the current manifest for the active bundle.
+   */
+  getManifest,
+  /**
+   * Fetches the current channel of the app.
+   *
+   * If no channel is specified, the app is assigned to the 'production' channel.
+   *
+   * @returns {string} The current release channel of the app
+   * @default "production"
+   * @example
+   * ```ts
+   * const channel = hotUpdater.getChannel();
+   * console.log(`Current channel: ${channel}`);
+   * ```
+   */
+  getChannel,
+  /**
+   * Fetches the build-time default channel of the app.
+   *
+   * This value does not change when a runtime channel override is active.
+   *
+   * @returns {string} The default release channel embedded in the app
+   * @example
+   * ```ts
+   * const defaultChannel = hotUpdater.getDefaultChannel();
+   * console.log(`Default channel: ${defaultChannel}`);
+   * ```
+   */
+  getDefaultChannel,
+  /**
+   * Returns whether the app is currently using a runtime channel override.
+   *
+   * @returns {boolean} true when a non-default channel has been applied
+   */
+  isChannelSwitched,
+  /**
+   * Sets the persisted cohort used for rollout calculations.
+   * Call `getCohort()` first if you need to restore the initial value later.
+   */
+  setCohort,
+  /**
+   * Gets the persisted cohort used for rollout calculations.
+   */
+  getCohort,
+  /**
+   * Adds a listener to HotUpdater events.
+   *
+   * @param {keyof HotUpdaterEvent} eventName - The name of the event to listen for
+   * @param {(event: HotUpdaterEvent[T]) => void} listener - The callback function to handle the event
+   * @returns {() => void} A cleanup function that removes the event listener
+   *
+   * @example
+   * ```ts
+   * const unsubscribe = hotUpdater.addListener("onProgress", ({ progress }) => {
+   *   console.log(`Update progress: ${progress * 100}%`);
+   * });
+   *
+   * // Unsubscribe when no longer needed
+   * unsubscribe();
+   * ```
+   */
+  addListener,
+  /**
+   * Clears the runtime channel override and restores the original bundle.
+   *
+   * @returns {Promise<boolean>} Resolves with true if reset was successful
+   */
+  resetChannel: async () => {
+    const ok = await resetChannel();
+    if (ok) {
+      hotUpdaterStore.setState({
+        artifactType: null,
+        details: null,
+        isUpdateDownloaded: false,
+        progress: 0
+      });
     }
-    return globalConfig.client;
-  };
-  return {
-    /**
-     * `HotUpdater.wrap` checks for updates at the entry point, and if there is a bundle to update, it downloads the bundle and applies the update strategy.
-     *
-     * @param {object} options - Configuration options
-     * @param {string} options.source - Update server URL
-     * @param {object} [options.requestHeaders] - Request headers
-     * @param {React.ComponentType} [options.fallbackComponent] - Component to display during updates
-     * @param {boolean} [options.reloadOnForceUpdate=true] - Whether to automatically reload the app on force updates
-     * @param {Function} [options.onUpdateProcessCompleted] - Callback after update process completes
-     * @param {Function} [options.onProgress] - Callback to track bundle download progress
-     * @returns {Function} Higher-order component that wraps the app component
-     *
-     * @example
-     * ```tsx
-     * export default HotUpdater.wrap({
-     *   baseURL: "<your-update-server-url>",
-     *   updateStrategy: "appVersion",
-     *   requestHeaders: {
-     *     "x-api-key": "<your-api-key>",
-     *   },
-     * })(App);
-     * ```
-     */
-    wrap: options => {
-      const normalizedOptions = normalizeOptions(options);
-      reportMixedConfiguration("wrap");
-      configureGlobal(normalizedOptions, options);
-      return wrap(normalizedOptions);
-    },
-    /**
-     * Initializes HotUpdater without wrapping a React component.
-     *
-     * Use this for manual update flows in runtimes where a root component HOC
-     * is not convenient. Use this instead of wrapping the root component.
-     *
-     * @example
-     * ```tsx
-     * HotUpdater.init({
-     *   baseURL: "<your-update-server-url>",
-     * });
-     *
-     * export default App;
-     * ```
-     */
-    init: options => {
-      const normalizedOptions = normalizeInitOptions(options);
-      reportMixedConfiguration("init");
-      configureGlobal(normalizedOptions, options);
-      init(normalizedOptions);
+    return ok;
+  },
+  /**
+   * Fetches the fingerprint of the app.
+   *
+   * @returns {string} The fingerprint of the app
+   *
+   * @example
+   * ```ts
+   * const fingerprint = hotUpdater.getFingerprintHash();
+   * console.log(`Fingerprint: ${fingerprint}`);
+   * ```
+   */
+  getFingerprintHash,
+  /**
+   * Fetches the persisted install id for this app installation.
+   */
+  getInstallId,
+  /**
+   * Reads the native launch report for the current process.
+   */
+  notifyAppReady,
+  /**
+   * Gets the list of bundle IDs that have been marked as crashed.
+   * These bundles will be rejected if attempted to install again.
+   *
+   * @returns {string[]} Array of crashed bundle IDs
+   *
+   * @example
+   * ```ts
+   * const crashedBundles = hotUpdater.getCrashHistory();
+   * console.log("Crashed bundles:", crashedBundles);
+   * ```
+   */
+  getCrashHistory,
+  /**
+   * Clears the crashed bundle history, allowing previously crashed bundles
+   * to be installed again.
+   *
+   * @returns {boolean} true if clearing was successful
+   *
+   * @example
+   * ```ts
+   * // Clear crash history to allow retrying a previously failed bundle
+   * hotUpdater.clearCrashHistory();
+   * ```
+   */
+  clearCrashHistory
+};
+
+/** What an instance's own methods use: its server, settings, and launch. */
+
+/** The methods that use the instance's own configuration and plugins. */
+const createConfiguredMethods = config => {
+  const check = options => checkForUpdate({
+    ...options,
+    client: config.client,
+    emit: config.launch.emit,
+    requestHeaders: {
+      ...config.requestHeaders,
+      ...options.requestHeaders
     },
+    requestTimeout: options.requestTimeout ?? config.requestTimeout,
+    onError: options.onError ?? config.onError
+  });
+  return {
     /**
-     * Reloads the app.
-     */
-    reload,
-    /**
-     * Configures how `HotUpdater.reload()` behaves.
-     *
-     * This can be called unconditionally on both platforms.
-     * The default is `processRestart`.
-     *
-     * - `reload`: built-in React Native reload on both platforms
-     * - `processRestart`: Android process restart, iOS behaves like normal reload
-     * - `custom`: run a custom JS handler on both platforms
-     */
-    setReloadBehavior,
-    /**
-     * Returns whether an update has finished downloading in this app session.
-     *
-     * When it returns true, calling `HotUpdater.reload()` (or restarting the app)
-     * will apply the downloaded update bundle.
-     *
-     * - Derived from `progress` reaching 1.0
-     * - Resets to false when a new download starts (progress < 1)
-     *
-     * @returns {boolean} True if a downloaded update is ready to apply
-     * @example
-     * ```ts
-     * if (HotUpdater.isUpdateDownloaded()) {
-     *   await HotUpdater.reload();
-     * }
-     * ```
-     */
-    isUpdateDownloaded: () => hotUpdaterStore.getSnapshot().isUpdateDownloaded,
-    /**
-     * Fetches the current app version.
-     */
-    getAppVersion,
-    /** Reads the active and stable Release/Bundle state. */
-    getActiveUpdateState: async () => getPublicActiveUpdateState(),
-    /**
-     * Returns the selected update ID, matching the ID shown in the console.
-     * A staged update can change this ID before the app reloads.
-     */
-    getBundleId: getUpdateId,
-    /** Returns the minimum bundle ID based on the native app build time. */
-    getMinBundleId,
-    /**
-     * Fetches the current manifest for the active bundle.
-     */
-    getManifest,
-    /**
-     * Fetches the current channel of the app.
-     *
-     * If no channel is specified, the app is assigned to the 'production' channel.
-     *
-     * @returns {string} The current release channel of the app
-     * @default "production"
-     * @example
-     * ```ts
-     * const channel = HotUpdater.getChannel();
-     * console.log(`Current channel: ${channel}`);
-     * ```
-     */
-    getChannel,
-    /**
-     * Fetches the build-time default channel of the app.
-     *
-     * This value does not change when a runtime channel override is active.
-     *
-     * @returns {string} The default release channel embedded in the app
-     * @example
-     * ```ts
-     * const defaultChannel = HotUpdater.getDefaultChannel();
-     * console.log(`Default channel: ${defaultChannel}`);
-     * ```
-     */
-    getDefaultChannel,
-    /**
-     * Returns whether the app is currently using a runtime channel override.
-     *
-     * @returns {boolean} true when a non-default channel has been applied
-     */
-    isChannelSwitched,
-    /**
-     * Sets the persisted cohort used for rollout calculations.
-     * Call `getCohort()` first if you need to restore the initial value later.
-     */
-    setCohort,
-    /**
-     * Gets the persisted cohort used for rollout calculations.
-     */
-    getCohort,
-    /**
-     * Adds a listener to HotUpdater events.
-     *
-     * @param {keyof HotUpdaterEvent} eventName - The name of the event to listen for
-     * @param {(event: HotUpdaterEvent[T]) => void} listener - The callback function to handle the event
-     * @returns {() => void} A cleanup function that removes the event listener
-     *
-     * @example
-     * ```ts
-     * const unsubscribe = HotUpdater.addListener("onProgress", ({ progress }) => {
-     *   console.log(`Update progress: ${progress * 100}%`);
-     * });
-     *
-     * // Unsubscribe when no longer needed
-     * unsubscribe();
-     * ```
-     */
-    addListener,
-    /**
-     * Manually checks for updates.
+     * Checks for an update, with this instance's server and request
+     * settings.
      *
      * @param {Object} config - Update check configuration
      * @param {string} [config.channel] - Optional channel override for this update check
@@ -287,7 +238,7 @@ function createHotUpdaterClient() {
      *
      * @example
      * ```ts
-     * const updateInfo = await HotUpdater.checkForUpdate({
+     * const updateInfo = await hotUpdater.checkForUpdate({
      *   updateStrategy: "appVersion",
      *   requestHeaders: {
      *     "x-api-key": "<your-api-key>",
@@ -301,24 +252,11 @@ function createHotUpdaterClient() {
      *
      * await updateInfo.updateBundle();
      * if (updateInfo.shouldForceUpdate) {
-     *   await HotUpdater.reload();
+     *   await hotUpdater.reload();
      * }
      * ```
      */
-    checkForUpdate: config => {
-      const client = ensureGlobalClient("checkForUpdate");
-      const mergedConfig = {
-        ...config,
-        client,
-        requestHeaders: {
-          ...globalConfig.requestHeaders,
-          ...config.requestHeaders
-        },
-        requestTimeout: config.requestTimeout ?? globalConfig.requestTimeout,
-        onError: config.onError ?? globalConfig.onError
-      };
-      return checkForUpdate(mergedConfig);
-    },
+    checkForUpdate: check,
     /**
      * Updates the bundle of the app.
      *
@@ -328,7 +266,7 @@ function createHotUpdaterClient() {
      *
      * @example
      * ```ts
-     * const updateInfo = await HotUpdater.checkForUpdate({
+     * const updateInfo = await hotUpdater.checkForUpdate({
      *   updateStrategy: "appVersion",
      *   requestHeaders: {
      *     "x-api-key": "<your-api-key>",
@@ -343,12 +281,11 @@ function createHotUpdaterClient() {
      *
      * await updateInfo.updateBundle();
      * if (updateInfo.shouldForceUpdate) {
-     *   await HotUpdater.reload();
+     *   await hotUpdater.reload();
      * }
      * ```
      */
     updateBundle: async params => {
-      ensureGlobalClient("updateBundle");
       const fromBundleId = getBundleId();
       const state = getActiveUpdateState();
       const active = state.activeSelection;
@@ -359,7 +296,7 @@ function createHotUpdaterClient() {
       try {
         delivery = await stageBundle(params);
       } catch (error) {
-        reportUpdateError(error, "download", undefined, {
+        reportUpdateError(config.launch.emit, error, "download", undefined, {
           bundleId: fromBundleId,
           channel,
           targetBundleId: params.bundleId,
@@ -369,7 +306,7 @@ function createHotUpdaterClient() {
         throw error;
       }
       if (delivery !== null && params.bundleId !== fromBundleId) {
-        emitAfterAppReady("onBundleDownloaded", () => {
+        config.launch.emit("onBundleDownloaded", () => {
           const selection = getActiveUpdateState().activeSelection;
           return {
             channel,
@@ -385,69 +322,102 @@ function createHotUpdaterClient() {
       return true;
     },
     /**
-     * Clears the runtime channel override and restores the original bundle.
-     *
-     * @returns {Promise<boolean>} Resolves with true if reset was successful
-     */
-    resetChannel: async () => {
-      const ok = await resetChannel();
-      if (ok) {
-        hotUpdaterStore.setState({
-          artifactType: null,
-          details: null,
-          isUpdateDownloaded: false,
-          progress: 0
-        });
-      }
-      return ok;
-    },
-    /**
-     * Fetches the fingerprint of the app.
-     *
-     * @returns {string} The fingerprint of the app
-     *
-     * @example
-     * ```ts
-     * const fingerprint = HotUpdater.getFingerprintHash();
-     * console.log(`Fingerprint: ${fingerprint}`);
-     * ```
-     */
-    getFingerprintHash,
-    /**
-     * Fetches the persisted install id for this app installation.
-     */
-    getInstallId,
-    /**
-     * Reads the native launch report for the current process.
-     */
-    notifyAppReady,
-    /**
-     * Gets the list of bundle IDs that have been marked as crashed.
-     * These bundles will be rejected if attempted to install again.
-     *
-     * @returns {string[]} Array of crashed bundle IDs
-     *
-     * @example
-     * ```ts
-     * const crashedBundles = HotUpdater.getCrashHistory();
-     * console.log("Crashed bundles:", crashedBundles);
-     * ```
-     */
-    getCrashHistory,
-    /**
-     * Clears the crashed bundle history, allowing previously crashed bundles
-     * to be installed again.
-     *
-     * @returns {boolean} true if clearing was successful
+     * Wraps the app's root: when it mounts, it checks for an update with
+     * this instance's configuration, downloads one, and reloads for a
+     * forced update. A `fallbackComponent` replaces the root until the
+     * check and a forced update finish.
      *
      * @example
-     * ```ts
-     * // Clear crash history to allow retrying a previously failed bundle
-     * HotUpdater.clearCrashHistory();
+     * ```tsx
+     * export default hotUpdater.wrap({
+     *   updateStrategy: "appVersion",
+     *   fallbackComponent: ({ progress }) => <Splash progress={progress} />,
+     * })(App);
      * ```
      */
-    clearCrashHistory
+    wrap: options => wrap({
+      ...options,
+      checkForUpdate: check,
+      appReady: () => config.launch.appReady,
+      onError: error => config.onError?.(error)
+    })
   };
-}
-export const HotUpdater = createHotUpdaterClient();
+};
+
+/** The methods of every instance `HotUpdater.init` returns. */
+
+/**
+ * The instance `HotUpdater.init` returns: HotUpdater's methods, and each
+ * plugin's API under the plugin's id.
+ */
+
+export const HotUpdater = {
+  /**
+   * Creates the app's HotUpdater instance: the update server, its request
+   * settings, and the client plugins. Each call returns an independent
+   * instance with its own configuration and plugins, so create one, at the
+   * top level of a module, and export it.
+   *
+   * The instance has every HotUpdater method, such as `wrap`,
+   * `checkForUpdate`, and `reload`, and each plugin's API under the
+   * plugin's id, such as `hotUpdater.remoteConfig` for `remoteConfig()`.
+   *
+   * @example
+   * ```tsx
+   * export const hotUpdater = HotUpdater.init({
+   *   baseURL: "<your-update-server-url>",
+   *   plugins: [remoteConfig({ defaults: { welcome_message: "Hi" } })],
+   * });
+   *
+   * hotUpdater.remoteConfig.getString("welcome_message");
+   * ```
+   */
+  init: options => {
+    const {
+      baseURL,
+      plugins,
+      requestHeaders,
+      requestTimeout,
+      onError,
+      onNotifyAppReady
+    } = options;
+    if (!baseURL) throw createMissingNetworkConfigError();
+    const host = createAppPluginHost();
+    const launch = createLaunchReporter(host);
+    const instance = {
+      ...nativeMethods,
+      ...createConfiguredMethods({
+        client: createHttpClient(baseURL, response => {
+          launch.emit("onHttpResponse", () => response);
+        }),
+        requestHeaders,
+        requestTimeout,
+        onError,
+        launch
+      })
+    };
+    const reservedIds = new Set([...Object.keys(instance), "init"]);
+    for (const plugin of plugins ?? []) {
+      if (reservedIds.has(plugin.id)) {
+        throw new Error(`[HotUpdater] A plugin cannot use the id "${plugin.id}": the HotUpdater instance has its own "${plugin.id}".`);
+      }
+    }
+
+    // Plugins are set up before the instance reads the launch they observe.
+    const apis = host.configurePlugins(plugins, {
+      baseURL,
+      requestHeaders,
+      requestTimeout,
+      onError
+    });
+    void launch.read({
+      onNotifyAppReady,
+      onError
+    });
+    return Object.freeze({
+      ...instance,
+      ...apis
+    });
+  }
+};
 //# sourceMappingURL=index.js.map