remote-components 0.3.4 → 0.3.6

package/dist/host/html.cjs

@@ -1,2329 +1,40 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/utils/constants.ts
-var RC_PROTECTED_REMOTE_FETCH_PATHNAME, CORS_DOCS_URL;
-var init_constants = __esm({
-  "src/utils/constants.ts"() {
-    "use strict";
-    RC_PROTECTED_REMOTE_FETCH_PATHNAME = "/rc-fetch-protected-remote";
-    CORS_DOCS_URL = "https://vercel.com/docs/remote-components/concepts/cors-external-urls#accessing-cross-site-protected-remote-components";
-  }
-});
-
-// src/runtime/url/protected-rc-fallback.ts
-function isProxiedUrl(url) {
-  try {
-    return new URL(url, location.href).pathname === RC_PROTECTED_REMOTE_FETCH_PATHNAME;
-  } catch {
-    return false;
-  }
-}
-var init_protected_rc_fallback = __esm({
-  "src/runtime/url/protected-rc-fallback.ts"() {
-    "use strict";
-    init_constants();
-  }
-});
-
-// src/utils/abort.ts
-function isAbortError(error) {
-  if (error instanceof DOMException && error.name === "AbortError") {
-    return true;
-  }
-  if (error !== null && typeof error === "object" && "name" in error && error.name === "AbortError" && "message" in error && typeof error.message === "string") {
-    const e = error;
-    return typeof e.code === "number" || e.constructor?.name === "DOMException";
-  }
-  return false;
-}
-var init_abort = __esm({
-  "src/utils/abort.ts"() {
-    "use strict";
-  }
-});
-
-// src/utils/error.ts
-function multipleRemoteComponentsError(url) {
-  return new RemoteComponentsError(
-    `Multiple Remote Components found at "${url}". When a page exposes multiple Remote Components you must specify the "name" prop to select which one to load.`
-  );
-}
-function failedToFetchRemoteComponentError(url, { status, statusText }, help = "Is the URL correct and accessible?") {
-  return new RemoteComponentsError(
-    `Failed to fetch Remote Component from "${url}". ${help}`,
-    { cause: new Error(`${status} ${statusText}`) }
-  );
-}
-async function errorFromFailedFetch(originalUrl, resolvedUrl, res) {
-  const isProxied = isProxiedUrl(resolvedUrl.href);
-  if (isProxied && res) {
-    const body = await res.text().catch(() => "");
-    return failedProxyFetchError(
-      originalUrl,
-      resolvedUrl.href,
-      res.status,
-      body
-    );
-  }
-  const fallback = failedToFetchRemoteComponentError(
-    originalUrl,
-    res ?? { status: 0, statusText: "No Response" }
-  );
-  if (!res)
-    return fallback;
-  try {
-    const body = await res.text();
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(body, "text/html");
-    const errorTemplate = doc.querySelector(
-      "template[data-next-error-message]"
-    );
-    const errorMessage = errorTemplate?.getAttribute("data-next-error-message");
-    if (errorMessage) {
-      const error = new RemoteComponentsError(errorMessage);
-      const errorStack = errorTemplate?.getAttribute("data-next-error-stack");
-      if (errorStack) {
-        error.stack = errorStack;
-      }
-      return error;
-    }
-  } catch (parseError) {
-    if (isAbortError(parseError))
-      throw parseError;
-  }
-  return fallback;
-}
-function failedProxiedAssetError(kind, url, resolvedUrl) {
-  return new RemoteComponentsError(
-    `Failed to load ${kind} "${url}" via proxy "${resolvedUrl}". Ensure withRemoteComponentsHostProxy middleware is configured, "${RC_PROTECTED_REMOTE_FETCH_PATHNAME}" is in the matcher, and the remote URL is included in allowedProxyUrls. See: ${CORS_DOCS_URL}`
-  );
-}
-function failedProxyFetchError(originalUrl, proxyUrl, status, responseBody) {
-  if (status === 404) {
-    return new RemoteComponentsError(
-      `Could not proxy the request to "${originalUrl}" \u2014 the proxy endpoint "${RC_PROTECTED_REMOTE_FETCH_PATHNAME}" returned 404.
-
-The host server needs middleware or a route that handles "${RC_PROTECTED_REMOTE_FETCH_PATHNAME}".
-
-Proxying requires two pieces:
-  1. resolveClientUrl={routeThroughHostProxy} on <RemoteComponent>
-  2. Middleware or a route for "${RC_PROTECTED_REMOTE_FETCH_PATHNAME}" on the host server
-
-Docs: ${CORS_DOCS_URL}`
-    );
-  }
-  if (status === 403) {
-    const detail = responseBody ? ` ${responseBody}` : "";
-    return new RemoteComponentsError(
-      `Proxied request to "${proxyUrl}" was forbidden.${detail} See: ${CORS_DOCS_URL}`
-    );
-  }
-  return new RemoteComponentsError(
-    `Proxied request for "${originalUrl}" via "${proxyUrl}" failed with status ${status}. See: ${CORS_DOCS_URL}`
-  );
-}
-var RemoteComponentsError;
-var init_error = __esm({
-  "src/utils/error.ts"() {
-    "use strict";
-    init_protected_rc_fallback();
-    init_abort();
-    init_constants();
-    RemoteComponentsError = class extends Error {
-      code = "REMOTE_COMPONENTS_ERROR";
-      constructor(message, options) {
-        super(message, options);
-        this.name = "RemoteComponentsError";
-      }
-    };
-  }
-});
-
-// src/utils/logger.ts
-function logDebug(location2, message) {
-  if (DEBUG) {
-    console.debug(`[${PREFIX}:${location2}]: ${message}`);
-  }
-}
-function logWarn(location2, message) {
-  console.warn(`[${PREFIX}:${location2}]: ${message}`);
-}
-function logError(location2, message, cause) {
-  console.error(
-    new RemoteComponentsError(`[${PREFIX}:${location2}]: ${message}`, {
-      cause
-    })
-  );
-}
-function warnCrossOriginFetchError(logLocation, url) {
-  try {
-    const parsed = typeof url === "string" ? new URL(url) : url;
-    if (typeof location === "undefined" || parsed.origin === location.origin) {
-      return;
-    }
-    logWarn(
-      logLocation,
-      `Failed to fetch cross-origin resource "${parsed.href}". To load assets from a protected deployment, two steps are required: (1) configure withRemoteComponentsHostProxy middleware in your host with the remote URL in allowedProxyUrls, and (2) provide a resolveClientUrl prop that rewrites cross-origin asset URLs to go through the proxy. See: ${CORS_DOCS_URL}`
-    );
-  } catch {
-  }
-}
-var PREFIX, DEBUG;
-var init_logger = __esm({
-  "src/utils/logger.ts"() {
-    "use strict";
-    init_constants();
-    init_error();
-    PREFIX = "remote-components";
-    DEBUG = typeof window !== "undefined" && localStorage.getItem("RC_DEBUG") === "true" || typeof process !== "undefined" && process.env.RC_DEBUG === "true";
-  }
-});
-
-// src/utils/index.ts
-function escapeString(str) {
-  return str.replace(/[^a-z0-9]/g, "_");
-}
-function computeScopedName(name, options) {
-  return options.isCrossOrigin ? `${name}_${escapeString(options.remoteHost.toLowerCase())}` : name;
-}
-var init_utils = __esm({
-  "src/utils/index.ts"() {
-    "use strict";
-  }
-});
-
-// src/runtime/constants.ts
-function getBundleKey(bundle) {
-  return escapeString(bundle);
-}
-var DEFAULT_BUNDLE_NAME, DEFAULT_COMPONENT_NAME, DEFAULT_ROUTE, RUNTIME_WEBPACK, RUNTIME_TURBOPACK, RUNTIME_SCRIPT;
-var init_constants2 = __esm({
-  "src/runtime/constants.ts"() {
-    "use strict";
-    init_utils();
-    DEFAULT_BUNDLE_NAME = "__vercel_remote_bundle";
-    DEFAULT_COMPONENT_NAME = "__vercel_remote_component";
-    DEFAULT_ROUTE = "/";
-    RUNTIME_WEBPACK = "webpack";
-    RUNTIME_TURBOPACK = "turbopack";
-    RUNTIME_SCRIPT = "script";
-  }
-});
-
-// src/runtime/namespace.ts
-function getNamespace() {
-  const g = globalThis;
-  const existing = g.__remote_components__;
-  if (existing) {
-    return existing;
-  }
-  const ns = {
-    scopes: /* @__PURE__ */ new Map(),
-    chunkCache: {},
-    mountFns: {},
-    unmountFns: {},
-    bundleUrls: {},
-    moduleRegistry: {},
-    dispatcherRuntime: void 0,
-    hostSharedModules: {},
-    cssCache: {},
-    shadowRoots: {}
-  };
-  const nsRecord = ns;
-  for (const { global, prop } of LEGACY_ALIASES) {
-    const legacyValue = g[global];
-    if (legacyValue != null) {
-      nsRecord[prop] = legacyValue;
-    }
-    g[global] = ns[prop];
-  }
-  const gRecord = g;
-  for (const key of Object.keys(gRecord)) {
-    if (key.startsWith(SHADOW_ROOT_PREFIX)) {
-      const suffix = key.slice(SHADOW_ROOT_PREFIX.length);
-      ns.shadowRoots[suffix] = gRecord[key];
-      delete gRecord[key];
-    }
-  }
-  g.__remote_components__ = ns;
-  return ns;
-}
-var SHADOW_ROOT_PREFIX, LEGACY_ALIASES;
-var init_namespace = __esm({
-  "src/runtime/namespace.ts"() {
-    "use strict";
-    SHADOW_ROOT_PREFIX = "__remote_components_shadowroot_";
-    LEGACY_ALIASES = [
-      { global: "__remote_component_scopes__", prop: "scopes" },
-      {
-        global: "__remote_components_turbopack_chunk_loader_promise__",
-        prop: "chunkCache"
-      },
-      { global: "__remote_script_entrypoint_mount__", prop: "mountFns" },
-      { global: "__remote_script_entrypoint_unmount__", prop: "unmountFns" },
-      { global: "__remote_bundle_url__", prop: "bundleUrls" },
-      { global: "__rc_module_registry__", prop: "moduleRegistry" },
-      {
-        global: "__remote_component_host_shared_modules__",
-        prop: "hostSharedModules"
-      },
-      { global: "__remote_next_css__", prop: "cssCache" }
-    ];
-  }
-});
-
-// src/runtime/patterns.ts
-function collapseDoubleSlashes(path) {
-  return path.replace(DOUBLE_SLASH_RE, "/");
-}
-var REMOTE_COMPONENT_REGEX, NEXT_BUNDLE_PATH_RE, DOUBLE_SLASH_RE;
-var init_patterns = __esm({
-  "src/runtime/patterns.ts"() {
-    "use strict";
-    REMOTE_COMPONENT_REGEX = /(?<prefix>.*?)\[(?<bundle>[^\]]+)\](?:%20| )(?<id>.+)/;
-    NEXT_BUNDLE_PATH_RE = /\/_next\/\[.+\](?:%20| )/;
-    DOUBLE_SLASH_RE = /(?<!:)\/\//g;
-  }
-});
-
-// src/runtime/turbopack/remote-scope.ts
-function getRegistry() {
-  return getNamespace().scopes;
-}
-function createScope(name, url, runtime, resolveClientUrl) {
-  const isCrossOrigin = url.origin !== location.origin;
-  const scopedName = computeScopedName(name, {
-    remoteHost: url.host,
-    isCrossOrigin
-  });
-  const globalKey = getBundleKey(scopedName);
-  return {
-    name,
-    scopedName,
-    globalKey,
-    url,
-    runtime,
-    resolveClientUrl,
-    moduleCache: {},
-    sharedModules: {},
-    moduleGlobal: {},
-    turbopackModules: []
-  };
-}
-function registerScope(scope) {
-  const registry = getRegistry();
-  registry.set(scope.scopedName, scope);
-  if (scope.scopedName !== scope.name) {
-    const existing = registry.get(scope.name);
-    if (existing && existing.scopedName !== scope.scopedName) {
-      logWarn(
-        "RemoteScope",
-        `Plain name "${scope.name}" already registered by scope "${existing.scopedName}" \u2014 overwriting with "${scope.scopedName}". Static hosts will only resolve the latest one.`
-      );
-    }
-    registry.set(scope.name, scope);
-  }
-  logDebug(
-    "RemoteScope",
-    `Registered scope "${scope.scopedName}" (${registry.size} total)`
-  );
-}
-function getScope(name) {
-  return getRegistry().get(name);
-}
-function formatRemoteId(scope, path) {
-  return `[${scope.scopedName}] ${path}`;
-}
-function parseRemoteId(id) {
-  const groups = REMOTE_COMPONENT_REGEX.exec(id)?.groups;
-  if (groups?.bundle && groups.id) {
-    return {
-      bundle: groups.bundle,
-      path: groups.id,
-      prefix: groups.prefix ?? ""
-    };
-  }
-  return { bundle: "default", path: id, prefix: "" };
-}
-var init_remote_scope = __esm({
-  "src/runtime/turbopack/remote-scope.ts"() {
-    "use strict";
-    init_constants2();
-    init_namespace();
-    init_patterns();
-    init_utils();
-    init_logger();
-  }
-});
-
-// src/config/webpack/apply-shared-modules.ts
-function applySharedModules(bundle, resolve) {
-  logDebug(
-    "SharedModules",
-    `applySharedModules called for bundle: "${bundle}"`
-  );
-  logDebug(
-    "SharedModules",
-    `Shared modules to resolve: ${Object.keys(resolve)}`
-  );
-  const self = globalThis;
-  const scope = getScope(bundle);
-  const webpackBundle = scope?.webpackRequire ?? self.__remote_webpack_require__?.[bundle];
-  if (webpackBundle) {
-    const modulePaths = Object.keys(
-      self.__remote_webpack_module_map__?.[bundle] ?? webpackBundle.m ?? {}
-    );
-    logDebug(
-      "SharedModules",
-      `Available module paths for bundle "${bundle}": ${modulePaths}`
-    );
-    for (const [key, value] of Object.entries(resolve)) {
-      const exactIds = modulePaths.filter((p) => p === key);
-      const ids = exactIds.length > 0 ? exactIds : modulePaths.filter((p) => p.includes(key));
-      if (ids.length === 0) {
-        logDebug(
-          "SharedModules",
-          `No matching module path found for shared module "${key}"`
-        );
-      }
-      for (const id of ids) {
-        if (webpackBundle.m) {
-          const resolvedId = self.__remote_webpack_module_map__?.[bundle]?.[id] ? `${self.__remote_webpack_module_map__[bundle][id]}` : id;
-          if (resolvedId !== id) {
-            logDebug(
-              "SharedModules",
-              `Mapped module id: "${id}" -> "${resolvedId}"`
-            );
-          }
-          webpackBundle.m[resolvedId] = (module2) => {
-            module2.exports = value;
-          };
-        } else {
-          logWarn(
-            "SharedModules",
-            `webpackBundle.m is not available for bundle "${bundle}" \u2014 ${DEDUPLICATION_SKIPPED}`
-          );
-        }
-      }
-    }
-  } else {
-    logWarn(
-      "SharedModules",
-      `No webpack require found for bundle "${bundle}" \u2014 ${DEDUPLICATION_SKIPPED}`
-    );
-    logDebug(
-      "SharedModules",
-      `Available bundles: ${Object.keys(self.__remote_webpack_require__ ?? {})}`
-    );
-  }
-}
-var DEDUPLICATION_SKIPPED;
-var init_apply_shared_modules = __esm({
-  "src/config/webpack/apply-shared-modules.ts"() {
-    "use strict";
-    init_remote_scope();
-    init_logger();
-    DEDUPLICATION_SKIPPED = "shared module deduplication skipped. The remote may load its own copy of shared dependencies.";
-  }
-});
-
-// src/config/webpack/next-client-pages-loader.ts
-function nextClientPagesLoader(bundle, route, styleContainer = document.head) {
-  const self = globalThis;
-  const nextCssOriginal = document.querySelector(
-    `[id="__next_css__DO_NOT_USE__"]:not([data-bundle="${bundle}"][data-route="${route}"])`
-  );
-  if (nextCssOriginal) {
-    nextCssOriginal.parentNode?.removeChild(nextCssOriginal);
-  }
-  const nextCss = document.createElement("noscript");
-  nextCss.id = "__next_css__DO_NOT_USE__";
-  nextCss.setAttribute("data-bundle", bundle);
-  nextCss.setAttribute("data-route", route);
-  const nextCssEnd = document.createElement("noscript");
-  nextCssEnd.id = "__next_css__DO_NOT_USE_END__";
-  nextCssEnd.setAttribute("data-bundle", bundle);
-  nextCssEnd.setAttribute("data-route", route);
-  document.head.appendChild(nextCssEnd);
-  document.head.appendChild(nextCss);
-  const componentLoaderChunk = Object.keys(self.__remote_webpack_require__?.[bundle]?.m ?? {}).find(
-    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=${encodeURIComponent(route)}!`)
-  ) ?? Object.keys(self.__remote_webpack_require__?.[bundle]?.m ?? {}).find(
-    (key) => key.includes("/next/dist/client/page-loader.js")
-  ) ?? self.__remote_webpack_module_map__?.[bundle]?.[Object.keys(self.__remote_webpack_module_map__[bundle] ?? {}).find(
-    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=${encodeURIComponent(route)}!`)
-  ) ?? Object.keys(self.__remote_webpack_module_map__[bundle] ?? {}).find(
-    (key) => key.includes("/next/dist/client/page-loader.js")
-  ) ?? ""] ?? -1;
-  const appLoaderChunk = Object.keys(self.__remote_webpack_require__?.[bundle]?.m ?? {}).find(
-    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=%2F_app`)
-  ) ?? Object.keys(self.__remote_webpack_require__?.[bundle]?.m ?? {}).find(
-    (key) => key.includes("/next/dist/client/page-loader.js")
-  ) ?? self.__remote_webpack_module_map__?.[bundle]?.[Object.keys(self.__remote_webpack_module_map__[bundle] ?? {}).find(
-    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=%2F_app`)
-  ) ?? Object.keys(self.__remote_webpack_module_map__[bundle] ?? {}).find(
-    (key) => key.includes("/next/dist/client/page-loader.js")
-  ) ?? ""] ?? -1;
-  if (!(componentLoaderChunk && appLoaderChunk)) {
-    throw new RemoteComponentsError(
-      `Next.js client pages loader not found in bundle "${bundle}".`
-    );
-  }
-  const __NEXT_P_ORIGINAL = self.__NEXT_P;
-  const selfOriginal = self;
-  delete selfOriginal.__NEXT_P;
-  self.__remote_webpack_require__?.[bundle]?.(
-    self.__remote_webpack_require__[bundle].type !== "turbopack" ? componentLoaderChunk : `[${bundle}] ${componentLoaderChunk}`
-  );
-  if (typeof appLoaderChunk === "string" || typeof appLoaderChunk === "number" && appLoaderChunk !== -1) {
-    self.__remote_webpack_require__?.[bundle]?.(
-      self.__remote_webpack_require__[bundle].type !== "turbopack" ? appLoaderChunk : `[${bundle}] ${appLoaderChunk}`
-    );
-  }
-  if (self.__NEXT_P) {
-    const [, componentLoader] = self.__NEXT_P[0] ?? [
-      void 0,
-      () => ({ default: null })
-    ];
-    const [, appLoader] = self.__NEXT_P[2] ?? [
-      void 0,
-      () => ({
-        default: null
-      })
-    ];
-    const { default: Component } = componentLoader();
-    const { default: App } = appLoader();
-    const cssCache = getNamespace().cssCache;
-    if (!cssCache[bundle]) {
-      const cssRE = /\.s?css$/;
-      Object.keys(self.__remote_webpack_require__?.[bundle]?.m ?? {}).filter((id) => cssRE.test(id)).forEach((id) => {
-        self.__remote_webpack_require__?.[bundle]?.(id);
-      });
-      Object.keys(self.__remote_webpack_module_map__?.[bundle] ?? {}).filter((path) => cssRE.test(path)).forEach((path) => {
-        const id = self.__remote_webpack_module_map__?.[bundle]?.[path];
-        if (id) {
-          self.__remote_webpack_require__?.[bundle]?.(id);
-        }
-      });
-      const elements = [];
-      let node = nextCss.previousSibling;
-      while (node && node !== nextCssEnd) {
-        elements.push(node);
-        node.remove();
-        node = nextCss.previousSibling;
-      }
-      cssCache[bundle] = elements;
-    }
-    if (styleContainer) {
-      const elements = cssCache[bundle];
-      elements.forEach((el) => {
-        styleContainer.appendChild(el.cloneNode(true));
-      });
-    } else {
-      const elements = cssCache[bundle];
-      elements.forEach((el) => {
-        document.head.appendChild(el);
-      });
-    }
-    delete self.__NEXT_P;
-    self.__NEXT_P = __NEXT_P_ORIGINAL;
-    if (nextCssOriginal) {
-      nextCssOriginal.parentNode?.appendChild(nextCssOriginal);
-    }
-    nextCss.remove();
-    nextCssEnd.remove();
-    return { Component, App };
-  }
-  return { Component: null, App: null };
-}
-var init_next_client_pages_loader = __esm({
-  "src/config/webpack/next-client-pages-loader.ts"() {
-    "use strict";
-    init_namespace();
-    init_error();
-  }
-});
-
-// src/host/shared/remote-image-loader.ts
-function createRemoteImageLoader(bundle, resolveClientUrl) {
-  const loader = Object.assign(
-    ({
-      config,
-      src,
-      width,
-      quality
-    }) => {
-      const q = quality ?? 75;
-      const remoteOrigin = getScope(bundle)?.url.origin ?? "";
-      const isCrossOrigin = remoteOrigin && remoteOrigin !== location.origin;
-      const basePath = isCrossOrigin ? `${remoteOrigin}${config.path ?? "/_next/image"}` : config.path ?? `${remoteOrigin}/_next/image`;
-      const url = `${basePath}?url=${encodeURIComponent(src)}&w=${width}&q=${q}`;
-      return resolveClientUrl?.(url) ?? url;
-    },
-    // Signals to getImgProps that this is a default loader (not a user-defined
-    // one), enabling srcSet generation with device/image sizes from the config.
-    { __next_img_default: true }
-  );
-  return loader;
-}
-var init_remote_image_loader = __esm({
-  "src/host/shared/remote-image-loader.ts"() {
-    "use strict";
-    init_remote_scope();
-  }
-});
-
-// src/host/shared/polyfill.tsx
-function sharedPolyfills(shared, resolveClientUrl) {
-  const hostShared = getNamespace().hostSharedModules;
-  const polyfill = {
-    "next/dist/client/components/navigation": hostShared["next/navigation"] ?? shared?.["next/navigation"] ?? (() => Promise.resolve({
-      useRouter() {
-        return {
-          push: (routerUrl) => {
-            history.pushState({}, "", routerUrl);
-          },
-          replace: (routerUrl) => {
-            history.replaceState({}, "", routerUrl);
-          },
-          back: () => {
-            history.back();
-          }
-        };
-      },
-      usePathname() {
-        return location.pathname;
-      },
-      useParams() {
-        return {};
-      },
-      useSearchParams() {
-        return new URLSearchParams(location.search);
-      },
-      useSelectedLayoutSegment() {
-        return null;
-      },
-      useSelectedLayoutSegments() {
-        return [];
-      },
-      __esModule: true
-    })),
-    "next/dist/client/app-dir/link": hostShared["next/link"] ?? shared?.["next/link"] ?? (() => Promise.resolve({
-      default: ({
-        scroll: _,
-        replace,
-        prefetch,
-        onNavigate,
-        children,
-        ...props
-      }) => {
-        if (prefetch) {
-          logWarn(
-            "Polyfill",
-            "Next.js Link prefetch is not supported in remote components"
-          );
-        }
-        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-          "a",
-          {
-            ...props,
-            href: props.href,
-            onClick: (e) => {
-              e.preventDefault();
-              let preventDefaulted = false;
-              e.preventDefault = () => {
-                preventDefaulted = true;
-                e.defaultPrevented = true;
-              };
-              if (typeof props.onClick === "function") {
-                props.onClick(e);
-              }
-              onNavigate?.(e);
-              if (preventDefaulted) {
-                return;
-              }
-              if (replace) {
-                history.replaceState({}, "", props.href);
-              } else {
-                history.pushState({}, "", props.href);
-              }
-            },
-            suppressHydrationWarning: true,
-            children: children ?? null
-          }
-        );
-      },
-      useLinkStatus() {
-        return { pending: false };
-      },
-      __esModule: true
-    })),
-    "next/dist/client/app-dir/form": hostShared["next/form"] ?? shared?.["next/form"] ?? (() => Promise.resolve({
-      default: () => {
-        throw new Error("Next.js <Form> component not implemented");
-      },
-      __esModule: true
-    })),
-    // Instead of replacing next/image entirely, we let the real Next.js Image
-    // component load from the remote bundle and only replace its default loader.
-    // This gives us full next/image fidelity (fill, priority, srcSet, blur
-    // placeholders, error handling) while routing image optimization through the
-    // remote app's /_next/image endpoint.
-    "next/dist/shared/lib/image-loader": hostShared["next/dist/shared/lib/image-loader"] ?? shared?.["next/dist/shared/lib/image-loader"] ?? ((bundle) => Promise.resolve({
-      default: createRemoteImageLoader(bundle, resolveClientUrl),
-      __esModule: true
-    })),
-    "next/dist/client/script": hostShared["next/script"] ?? shared?.["next/script"] ?? (() => Promise.resolve({
-      // TODO: implement <Script> component for non-Next.js host applications
-      // do not throw an error for now
-      default: () => null,
-      __esModule: true
-    })),
-    "next/router": hostShared["next/router"] ?? shared?.["next/router"] ?? (() => (
-      // TODO: incomplete implementation
-      Promise.resolve({
-        useRouter() {
-          return {
-            push: (routerUrl) => {
-              history.pushState({}, "", routerUrl);
-            },
-            replace: (routerUrl) => {
-              history.replaceState({}, "", routerUrl);
-            },
-            back: () => {
-              history.back();
-            }
-          };
-        },
-        __esModule: true
-      })
-    )),
-    "next/dist/build/polyfills/process": () => Promise.resolve({
-      default: {
-        env: {
-          NODE_ENV: "production"
-        }
-      },
-      __esModule: true
-    })
-  };
-  polyfill["next/navigation"] = polyfill["next/dist/client/components/navigation"];
-  polyfill["next/link"] = polyfill["next/dist/client/app-dir/link"];
-  polyfill["next/form"] = polyfill["next/dist/client/app-dir/form"];
-  polyfill["next/dist/esm/shared/lib/image-loader"] = polyfill["next/dist/shared/lib/image-loader"];
-  polyfill["next/script"] = polyfill["next/dist/client/script"];
-  return polyfill;
-}
-var import_jsx_runtime;
-var init_polyfill = __esm({
-  "src/host/shared/polyfill.tsx"() {
-    "use strict";
-    init_remote_image_loader();
-    init_namespace();
-    init_logger();
-    import_jsx_runtime = require("react/jsx-runtime");
-  }
-});
-
-// src/host/shared/shared-module-resolver.ts
-function buildCoreShared(userShared) {
-  return {
-    react: async () => (await import("react")).default,
-    "react-dom": async () => (await import("react-dom")).default,
-    "react/jsx-dev-runtime": async () => (await import("react/jsx-dev-runtime")).default,
-    "react/jsx-runtime": async () => (await import("react/jsx-runtime")).default,
-    "react-dom/client": async () => (await import("react-dom/client")).default,
-    ...userShared
-  };
-}
-function buildHostShared(userShared, resolveClientUrl, options) {
-  const self = globalThis;
-  const result = {
-    ...sharedPolyfills(userShared, resolveClientUrl),
-    ...self.__remote_component_host_shared_modules__,
-    ...userShared
-  };
-  if (options?.includeRemoteComponentShared) {
-    Object.assign(result, self.__remote_component_shared__);
-  }
-  return result;
-}
-async function buildWebpackResolve(hostShared, remoteShared, bundle, reactModules, callerTag = "SharedModuleResolver") {
-  const resolve = {
-    ...reactModules,
-    ...Object.entries(remoteShared).reduce(
-      (acc, [key, value]) => {
-        if (typeof hostShared[value] !== "undefined") {
-          acc[key.replace(/^\(ssr\)\/(?<relative>\.\/)?/, "")] = hostShared[value];
-        } else {
-          logDebug(
-            callerTag,
-            `Remote requests "${value}" but host doesn't provide it`
-          );
-        }
-        return acc;
-      },
-      {}
-    )
-  };
-  await Promise.all(
-    Object.entries(resolve).map(async ([key, value]) => {
-      if (typeof value === "function") {
-        resolve[key] = await value(bundle);
-      }
-      return Promise.resolve(value);
-    })
-  );
-  return resolve;
-}
-var CORE_REACT_PATH_MAP, VENDOR_SHARED;
-var init_shared_module_resolver = __esm({
-  "src/host/shared/shared-module-resolver.ts"() {
-    "use strict";
-    init_polyfill();
-    init_logger();
-    CORE_REACT_PATH_MAP = {
-      react: "/react/index.js",
-      "react/jsx-dev-runtime": "/react/jsx-dev-runtime.js",
-      "react/jsx-runtime": "/react/jsx-runtime.js",
-      "react-dom": "/react-dom/index.js",
-      "react-dom/client": "/react-dom/client.js"
-    };
-    VENDOR_SHARED = Object.fromEntries(
-      Object.entries(CORE_REACT_PATH_MAP).filter(([key]) => key !== "react-dom/client").map(([key, path]) => [key, `'${path}'`])
-    );
-  }
-});
-
-// src/runtime/loaders/script-loader.ts
-async function loadScripts(scripts, resolveClientUrl) {
-  await Promise.all(
-    scripts.map((script) => {
-      return new Promise((resolve, reject) => {
-        const newSrc = new URL(
-          // remove the remote component bundle name identifier from the script src
-          script.src.replace(NEXT_BUNDLE_PATH_RE, "/_next/"),
-          location.origin
-        ).href;
-        const resolvedSrc = resolveClientUrl?.(newSrc) ?? newSrc;
-        const alreadyLoaded = Array.from(
-          document.querySelectorAll("script[src]")
-        ).some((s) => s.src === resolvedSrc);
-        if (alreadyLoaded) {
-          resolve();
-          return;
-        }
-        const newScript = document.createElement("script");
-        newScript.onload = () => resolve();
-        newScript.onerror = () => {
-          const isProxied = isProxiedUrl(resolvedSrc);
-          if (isProxied) {
-            reject(failedProxiedAssetError("script", newSrc, resolvedSrc));
-          } else {
-            warnCrossOriginFetchError("ScriptLoader", newSrc);
-            reject(
-              new RemoteComponentsError(
-                `Failed to load <script src="${newSrc}"> for Remote Component. Check the URL is correct.`
-              )
-            );
-          }
-        };
-        newScript.src = resolvedSrc;
-        newScript.async = true;
-        document.head.appendChild(newScript);
-      });
-    })
-  );
-}
-var init_script_loader = __esm({
-  "src/runtime/loaders/script-loader.ts"() {
-    "use strict";
-    init_patterns();
-    init_protected_rc_fallback();
-    init_error();
-    init_logger();
-  }
-});
-
-// src/host/html/runtime/webpack.ts
-var webpack_exports = {};
-__export(webpack_exports, {
-  webpackRuntime: () => webpackRuntime
-});
-async function webpackRuntime(bundle, shared, remoteShared, resolveClientUrl) {
-  const self = globalThis;
-  if (!self.__DISABLE_WEBPACK_EXEC__) {
-    self.__DISABLE_WEBPACK_EXEC__ = {};
-  }
-  self.__DISABLE_WEBPACK_EXEC__[bundle] = true;
-  if (typeof self.__webpack_require__ !== "function" && self.__webpack_require_type__ !== "turbopack") {
-    self.__webpack_require__ = (remoteId) => {
-      const re = /\[(?<bundle>[^\]]+)\] (?<id>.*)/;
-      const match = re.exec(remoteId);
-      const remoteBundle = match?.groups?.bundle;
-      const id = match?.groups?.id;
-      if (!(id && remoteBundle)) {
-        throw new RemoteComponentsError(
-          `Remote Component module "${remoteId}" not found. Did you forget to wrap the Next.js config with \`withRemoteComponentsConfig\` on both host and remote?`
-        );
-      }
-      if (typeof self.__remote_webpack_require__?.[remoteBundle] !== "function") {
-        throw new RemoteComponentsError(
-          `Remote Components are not available in "${remoteBundle}". Did you forget to wrap the Next.js config with \`withRemoteComponentsConfig\` on both host and remote?`
-        );
-      }
-      return self.__remote_webpack_require__[remoteBundle](id);
-    };
-    self.__webpack_chunk_load__ = () => {
-      return Promise.resolve([]);
-    };
-  }
-  const {
-    default: { createFromReadableStream }
-  } = await import("react-server-dom-webpack/client.browser");
-  async function preloadScripts(scripts, url, remoteBundle, _) {
-    const scriptSrcs = scripts.flatMap((script) => {
-      const scriptSrc = script.getAttribute("src") || script.getAttribute("data-src");
-      script.parentElement?.removeChild(script);
-      if (!scriptSrc)
-        return [];
-      return [
-        {
-          src: new URL(scriptSrc.replace(NEXT_BUNDLE_PATH_RE, "/_next/"), url).href
-        }
-      ];
-    });
-    await loadScripts(scriptSrcs, resolveClientUrl);
-    const hostShared = buildHostShared(shared, resolveClientUrl);
-    const resolve = await buildWebpackResolve(
-      hostShared,
-      remoteShared ?? {},
-      remoteBundle,
-      {
-        "/react/index.js": (await import("react")).default,
-        "/react/jsx-dev-runtime.js": (await import("react/jsx-dev-runtime")).default,
-        "/react/jsx-runtime.js": (await import("react/jsx-runtime")).default,
-        "/react-dom/index.js": (await import("react-dom")).default,
-        "/react-dom/client.js": (await import("react-dom/client")).default
-      },
-      "WebpackRuntime"
-    );
-    applySharedModules(remoteBundle, resolve);
-  }
-  return {
-    self,
-    createFromReadableStream,
-    applySharedModules,
-    nextClientPagesLoader,
-    preloadScripts
-  };
-}
-var init_webpack = __esm({
-  "src/host/html/runtime/webpack.ts"() {
-    "use strict";
-    init_apply_shared_modules();
-    init_next_client_pages_loader();
-    init_shared_module_resolver();
-    init_script_loader();
-    init_patterns();
-    init_error();
-  }
-});
-
-// src/runtime/turbopack/patterns.ts
-function stripQuotes(value) {
-  if (value.startsWith('"') && value.endsWith('"')) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-function extractGroup(re, input, group) {
-  const raw = re.exec(input)?.groups?.[group];
-  return raw ? stripQuotes(raw) : void 0;
-}
-var MODULE_ID_PATTERN, REMOTE_SHARED_MARKER_RE, REMOTE_SHARED_ASSIGNMENT_RE, ASYNC_MODULE_LOADER_RE, ASYNC_MODULE_CALLBACK_RE, TURBOPACK_GLOBAL_RE;
-var init_patterns2 = __esm({
-  "src/runtime/turbopack/patterns.ts"() {
-    "use strict";
-    MODULE_ID_PATTERN = '"[^"]+"|[0-9]+';
-    REMOTE_SHARED_MARKER_RE = /(?:self|[a-z])\.TURBOPACK_REMOTE_SHARED/;
-    REMOTE_SHARED_ASSIGNMENT_RE = new RegExp(
-      `\\.TURBOPACK_REMOTE_SHARED\\s*=\\s*await (?:__turbopack_context__|[a-z])\\.A\\((?<sharedModuleId>${MODULE_ID_PATTERN})\\)`
-    );
-    ASYNC_MODULE_LOADER_RE = new RegExp(
-      `(?:__turbopack_context__|e)\\.A\\((?<asyncSharedModuleId>${MODULE_ID_PATTERN})\\)`
-    );
-    ASYNC_MODULE_CALLBACK_RE = new RegExp(
-      `(?:parentImport|[a-z])\\((?<sharedModuleId>${MODULE_ID_PATTERN})\\)`
-    );
-    TURBOPACK_GLOBAL_RE = /(?:globalThis|self)\s*(?:\.TURBOPACK|\[\s*["']TURBOPACK["']\s*\])/;
-  }
-});
-
-// src/runtime/turbopack/chunk-loader.ts
-function loadChunkWithScope(scope, chunkId) {
-  logDebug(
-    "ChunkLoader",
-    `loadChunkWithScope: "${chunkId}" (scope: "${scope.scopedName}")`
-  );
-  const self = globalThis;
-  const ns = getNamespace();
-  const { bundle, path, prefix } = parseRemoteId(chunkId);
-  const remoteRuntime = self.__remote_webpack_require__?.[bundle ?? "default"] ? self.__remote_webpack_require__[bundle ?? "default"]?.type || "webpack" : scope.runtime;
-  if (remoteRuntime === RUNTIME_WEBPACK) {
-    return Promise.resolve(void 0);
-  }
-  const rawPath = path ? collapseDoubleSlashes(`${prefix}${path}`) : "/";
-  const url = new URL(rawPath, scope.url).href;
-  if (url.endsWith(".css")) {
-    return;
-  }
-  if (ns.chunkCache[url]) {
-    logDebug("ChunkLoader", `Cache hit for "${chunkId}" (url="${url}")`);
-    return ns.chunkCache[url];
-  }
-  const resolvedUrl = scope.resolveClientUrl?.(url) ?? url;
-  if (resolvedUrl !== url) {
-    logDebug("ChunkLoader", `Proxied chunk URL: "${url}" \u2192 "${resolvedUrl}"`);
-  }
-  ns.chunkCache[url] = new Promise((resolve, reject) => {
-    fetch(resolvedUrl).then((res) => res.text()).then((code) => {
-      const hasTurbopack = TURBOPACK_GLOBAL_RE.test(code);
-      if (hasTurbopack) {
-        return handleTurbopackChunk(code, scope, url);
-      }
-    }).then(resolve).catch((error) => {
-      const isProxied = isProxiedUrl(resolvedUrl);
-      if (isProxied) {
-        reject(failedProxiedAssetError("chunk", url, resolvedUrl));
-      } else {
-        warnCrossOriginFetchError("ChunkLoader", url);
-        reject(error);
-      }
-    });
-  });
-  return ns.chunkCache[url];
-}
-function createChunkDispatcher() {
-  return function __chunk_dispatcher__(chunkId, scriptBundle) {
-    logDebug("ChunkDispatcher", `Dispatching chunk: "${chunkId}"`);
-    const { bundle } = parseRemoteId(chunkId);
-    const bundleName = bundle || scriptBundle || "default";
-    const scope = getScope(bundleName);
-    logDebug(
-      "ChunkDispatcher",
-      `Scope resolution: bundle="${bundleName}", scope=${scope?.scopedName ?? "null"}`
-    );
-    if (!scope) {
-      logWarn("ChunkDispatcher", `No scope found for bundle "${bundleName}"`);
-      return Promise.resolve(void 0);
-    }
-    return loadChunkWithScope(scope, chunkId);
-  };
-}
-async function handleTurbopackChunk(code, scope, url) {
-  if (/importScripts\(\.\.\.self.TURBOPACK_NEXT_CHUNK_URLS/.test(code)) {
-    const preloadLinks = document.querySelectorAll(
-      `link[rel="preload"][href="${new URL(url).pathname}"]`
-    );
-    preloadLinks.forEach((preloadLink) => preloadLink.remove());
-    return;
-  }
-  const self = globalThis;
-  const { globalKey } = scope;
-  const transformedCode = code.replace(
-    /globalThis\[\s*["']TURBOPACK["']\s*\]/g,
-    `globalThis["TURBOPACK_${globalKey}"]`
-  ).replace(
-    /self\[\s*["']TURBOPACK["']\s*\]/g,
-    `self["TURBOPACK_${globalKey}"]`
-  ).replace(/globalThis\.TURBOPACK/g, `globalThis.TURBOPACK_${globalKey}`).replace(/self\.TURBOPACK(?!_)/g, `self.TURBOPACK_${globalKey}`).replace(
-    /TURBOPACK_WORKER_LOCATION/g,
-    `TURBOPACK_WORKER_LOCATION_${globalKey}`
-  ).replace(
-    /TURBOPACK_NEXT_CHUNK_URLS/g,
-    `TURBOPACK_NEXT_CHUNK_URLS_${globalKey}`
-  ).replace(
-    /TURBOPACK_CHUNK_UPDATE_LISTENERS/g,
-    `TURBOPACK_CHUNK_UPDATE_LISTENERS_${globalKey}`
-  ).replace(/__next_require__/g, `__${globalKey}_next_require__`).replace(
-    /\/\/# sourceMappingURL=(?<name>.+)(?<optional>\._)?\.js\.map/g,
-    `//# sourceMappingURL=${new URL(".", new URL(url, scope.url)).href}$1$2.js.map`
-  );
-  if (!self[`TURBOPACK_${globalKey}`]) {
-    const wrapPush = (target) => {
-      const originalPush = target.push;
-      if (typeof originalPush !== "function")
-        return target;
-      target.push = (...items) => {
-        for (const item of items) {
-          if (Array.isArray(item)) {
-            for (const entry of item) {
-              scope.turbopackModules.push(entry);
-            }
-          } else {
-            scope.turbopackModules.push(item);
-          }
-        }
-        return originalPush.apply(target, items);
-      };
-      return target;
-    };
-    const globalProp = `TURBOPACK_${globalKey}`;
-    let currentValue = wrapPush([]);
-    Object.defineProperty(self, globalProp, {
-      get() {
-        return currentValue;
-      },
-      set(newValue) {
-        if (newValue && typeof newValue === "object") {
-          wrapPush(newValue);
-        }
-        currentValue = newValue;
-      },
-      configurable: true,
-      enumerable: true
-    });
-  }
-  await new Promise((scriptResolve, scriptReject) => {
-    const blob = new Blob([transformedCode], {
-      type: "application/javascript; charset=UTF-8"
-    });
-    const scriptUrl = URL.createObjectURL(blob);
-    const script = document.createElement("script");
-    script.setAttribute("data-turbopack-src", url);
-    script.src = scriptUrl;
-    script.async = true;
-    script.onload = () => {
-      URL.revokeObjectURL(scriptUrl);
-      scriptResolve(void 0);
-      script.remove();
-    };
-    script.onerror = () => {
-      URL.revokeObjectURL(scriptUrl);
-      scriptReject(
-        new RemoteComponentsError(
-          `Failed to load <script src="${script.src}"> for Remote Component. Check the URL is correct.`
-        )
-      );
-      script.remove();
-    };
-    document.head.appendChild(script);
-  });
-  const chunkLists = self[`TURBOPACK_${globalKey}_CHUNK_LISTS`];
-  const loadChunkPromises = [];
-  while (chunkLists?.length) {
-    const { chunks } = chunkLists.shift() ?? { chunks: [] };
-    if (chunks.length > 0) {
-      for (const id of chunks) {
-        const baseUrl = url.slice(0, url.indexOf("/_next"));
-        const chunkLoadResult = loadChunkWithScope(
-          scope,
-          formatRemoteId(scope, `${baseUrl}/_next/${id}`)
-        );
-        if (chunkLoadResult) {
-          loadChunkPromises.push(chunkLoadResult);
-        }
-      }
-    }
-  }
-  if (loadChunkPromises.length > 0) {
-    await Promise.all(loadChunkPromises);
-  }
-}
-var init_chunk_loader = __esm({
-  "src/runtime/turbopack/chunk-loader.ts"() {
-    "use strict";
-    init_constants2();
-    init_namespace();
-    init_patterns();
-    init_protected_rc_fallback();
-    init_error();
-    init_logger();
-    init_patterns2();
-    init_remote_scope();
-  }
-});
-
-// src/runtime/turbopack/shared-modules.ts
-function getTurbopackModules(scope) {
-  if (scope.turbopackModules.length > 0) {
-    return scope.turbopackModules;
-  }
-  const self = globalThis;
-  const raw = self[`TURBOPACK_${scope.globalKey}`];
-  if (!raw)
-    return void 0;
-  if (Array.isArray(raw)) {
-    return raw.flat();
-  }
-  return Object.entries(raw).flat();
-}
-async function initializeSharedModules(scope, hostShared = {}, remoteShared = {}) {
-  const allModules = getTurbopackModules(scope);
-  logDebug(
-    "SharedModules",
-    `initializeSharedModules: scope="${scope.scopedName}", allModules=${allModules ? allModules.length : "null"}, hostShared=[${Object.keys(hostShared).join(", ")}], remoteShared=${JSON.stringify(remoteShared)}`
-  );
-  let sharedModuleInitializer = null;
-  if (allModules) {
-    const sharedModuleInitializerIndex = allModules.findIndex((idOrFunc) => {
-      if (typeof idOrFunc !== "function") {
-        return false;
-      }
-      const funcCode = idOrFunc.toString();
-      return REMOTE_SHARED_MARKER_RE.test(funcCode);
-    });
-    if (sharedModuleInitializerIndex > 0) {
-      const sharedModuleInitializerCode = allModules[sharedModuleInitializerIndex].toString();
-      const sharedModuleInitializerId = allModules[sharedModuleInitializerIndex - 1];
-      const sharedModuleId = extractGroup(
-        REMOTE_SHARED_ASSIGNMENT_RE,
-        sharedModuleInitializerCode,
-        "sharedModuleId"
-      );
-      if (sharedModuleId) {
-        const { default: sharedModuleInitializerInstance } = handleTurbopackModule(
-          scope,
-          sharedModuleId,
-          formatRemoteId(scope, String(sharedModuleInitializerId))
-        );
-        sharedModuleInitializer = sharedModuleInitializerInstance;
-      }
-    }
-    if (sharedModuleInitializer) {
-      const { shared } = await sharedModuleInitializer;
-      const sharedModuleIds = extractSharedModuleIds(shared, scope);
-      logDebug(
-        "SharedModules",
-        `Resolved shared modules for scope="${scope.scopedName}": ${JSON.stringify(sharedModuleIds)}`
-      );
-      return Promise.all(
-        Object.entries(sharedModuleIds).map(async ([id, module2]) => {
-          if (hostShared[module2]) {
-            scope.sharedModules[id] = await hostShared[module2](scope.name);
-          } else {
-            logError(
-              "SharedModules",
-              `Host shared module "${module2}" not found for ID ${id}. ${DEDUPLICATION_WARNING}`
-            );
-          }
-        })
-      );
-    }
-    logWarn(
-      "SharedModules",
-      `No shared module initializer found in bundle for scope="${scope.scopedName}" \u2014 falling back to remoteShared mapping`
-    );
-  } else {
-    logWarn(
-      "SharedModules",
-      `No TURBOPACK modules found for scope="${scope.scopedName}" (TURBOPACK_${scope.globalKey} is empty)`
-    );
-  }
-  return Promise.all(
-    Object.entries(remoteShared).map(async ([id, module2]) => {
-      if (hostShared[module2]) {
-        const normalizedId = id.replace("[app-ssr]", "[app-client]");
-        scope.sharedModules[normalizedId] = await hostShared[module2](
-          scope.name
-        );
-      } else {
-        logError(
-          "SharedModules",
-          `Shared module "${module2}" not found for "${scope.name}". ${DEDUPLICATION_WARNING}`
-        );
-      }
-    })
-  );
-}
-function extractSharedModuleIds(shared, scope) {
-  return Object.entries(shared).filter(([, value]) => typeof value === "function").reduce((acc, [key, value]) => {
-    const asyncSharedModuleId = extractGroup(
-      ASYNC_MODULE_LOADER_RE,
-      value.toString(),
-      "asyncSharedModuleId"
-    );
-    if (asyncSharedModuleId) {
-      const asyncSharedModule = findModuleInit(
-        getTurbopackModules(scope),
-        asyncSharedModuleId
-      );
-      if (asyncSharedModule) {
-        const sharedModuleId = extractGroup(
-          ASYNC_MODULE_CALLBACK_RE,
-          asyncSharedModule.toString(),
-          "sharedModuleId"
-        );
-        acc[sharedModuleId ?? asyncSharedModuleId] = key.replace(
-          "__remote_shared_module_",
-          ""
-        );
-      }
-    }
-    return acc;
-  }, {});
-}
-function getSharedModule(scope, id) {
-  const idStr = String(id);
-  if (scope.sharedModules[idStr] !== void 0) {
-    return scope.sharedModules[idStr];
-  }
-  for (const [key, value] of Object.entries(scope.sharedModules)) {
-    if (typeof value !== "undefined" && idStr !== key && idStr.endsWith(key)) {
-      return value;
-    }
-  }
-  return null;
-}
-var DEDUPLICATION_WARNING;
-var init_shared_modules = __esm({
-  "src/runtime/turbopack/shared-modules.ts"() {
-    "use strict";
-    init_logger();
-    init_module();
-    init_patterns2();
-    init_remote_scope();
-    DEDUPLICATION_WARNING = "This module will not be deduplicated \u2014 the remote may load its own copy, which can cause duplicate instance errors (e.g. invalid hook calls if React is loaded twice).";
-  }
-});
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-// src/runtime/turbopack/module.ts
-function requireModule(scope, moduleId, fullId) {
-  const idStr = String(moduleId);
-  if (scope.moduleCache[idStr])
-    return scope.moduleCache[idStr];
-  const sharedModule = getSharedModule(scope, moduleId);
-  if (sharedModule)
-    return sharedModule;
-  return handleTurbopackModule(
-    scope,
-    idStr,
-    fullId ?? formatRemoteId(scope, idStr)
-  );
-}
-function handleTurbopackModule(scope, moduleId, id) {
-  if (scope.moduleCache[moduleId]) {
-    return scope.moduleCache[moduleId];
-  }
-  const modules = getTurbopackModules(scope);
-  if (!modules) {
-    logError(
-      "TurbopackModule",
-      `TURBOPACK_${scope.globalKey} is undefined (scope: "${scope.scopedName}")`
-    );
-  }
-  const moduleInit = findModuleInit(modules, moduleId);
-  const exports = {};
-  const moduleExports = { exports };
-  if (typeof moduleInit !== "function") {
-    throw new Error(
-      `Module ${id} not found in bundle ${scope.name} with id ${moduleId}`
-    );
-  }
-  scope.moduleCache[moduleId] = moduleExports.exports;
-  moduleInit(
-    createTurbopackContext(
-      scope,
-      exports,
-      moduleExports,
-      modules,
-      moduleInit,
-      id
-    ),
-    moduleExports,
-    exports
-  );
-  if (scope.moduleCache[moduleId] !== moduleExports.exports) {
-    scope.moduleCache[moduleId] = moduleExports.exports;
-  }
-  return moduleExports.exports;
-}
-function findModuleInit(modules, moduleId) {
-  if (!modules || typeof modules !== "object")
-    return;
-  if (!Array.isArray(modules)) {
-    const key = moduleId in modules ? moduleId : Object.keys(modules).find((k) => k.startsWith(moduleId));
-    return key !== void 0 ? modules[key] : void 0;
-  }
-  const flat = modules.flat();
-  let idx = flat.findIndex((e) => String(e) === String(moduleId));
-  if (idx < 0) {
-    idx = flat.findIndex(
-      (e) => typeof e === "string" && e.startsWith(moduleId)
-    );
-  }
-  if (idx >= 0) {
-    return flat.slice(idx + 1).find((e) => typeof e === "function");
-  }
-  for (const entry of flat) {
-    if (!entry || typeof entry !== "object")
-      continue;
-    const obj = entry;
-    if (moduleId in obj)
-      return obj[moduleId];
-    const prefixKey = Object.keys(obj).find((k) => k.startsWith(moduleId));
-    if (prefixKey)
-      return obj[prefixKey];
-  }
-  return void 0;
-}
-function createTurbopackContext(scope, exports, moduleExports, modules, moduleInit, id) {
-  const scopedRequire = (moduleId) => requireModule(scope, moduleId, formatRemoteId(scope, String(moduleId)));
-  return {
-    // HMR not implemented for Remote Components
-    k: {
-      register() {
-      },
-      registerExports() {
-      },
-      signature() {
-        return (fn) => fn;
-      }
-    },
-    // ESM exports setup
-    s(bindings, esmId) {
-      let mod = exports;
-      if (typeof esmId === "string" || typeof esmId === "number") {
-        if (!scope.moduleCache[esmId]) {
-          scope.moduleCache[esmId] = {};
-        }
-        mod = scope.moduleCache[esmId];
-      }
-      Object.defineProperty(mod, "__esModule", { value: true });
-      if (Array.isArray(bindings)) {
-        let i = 0;
-        while (i < bindings.length) {
-          const propName = bindings[i++];
-          const tagOrFunc = bindings[i++];
-          if (typeof tagOrFunc === "number") {
-            Object.defineProperty(mod, propName, {
-              value: bindings[i++],
-              enumerable: true,
-              writable: false
-            });
-          } else {
-            const getterFn = tagOrFunc;
-            if (typeof bindings[i] === "function") {
-              const setterFn = bindings[i++];
-              Object.defineProperty(mod, propName, {
-                get: getterFn,
-                set: setterFn,
-                enumerable: true
-              });
-            } else {
-              Object.defineProperty(mod, propName, {
-                get: getterFn,
-                enumerable: true
-              });
-            }
-          }
-        }
-      }
-    },
-    // import — resolves directly via scope, no global dispatch
-    i(importId) {
-      let mod;
-      if (typeof importId === "string") {
-        const { exportSource, exportName } = /\s+<export (?<exportSource>.*?) as (?<exportName>.*?)>$/.exec(
-          importId
-        )?.groups ?? {};
-        const normalizedId = importId.replace(
-          /\s+<export(?<specifier>.*)>$/,
-          ""
-        );
-        mod = scopedRequire(normalizedId);
-        if (mod && exportSource && exportName && (exportSource === "*" || typeof mod[exportSource] !== "undefined") && typeof mod[exportName] === "undefined") {
-          if (exportSource === "*") {
-            mod[exportName] = mod;
-          } else {
-            mod[exportName] = mod[exportSource];
-          }
-        }
-      } else {
-        mod = scopedRequire(importId);
-      }
-      if (typeof mod !== "object" || mod === null) {
-        mod = { default: mod };
-      } else if (!("default" in mod) && // ES module namespace objects have a null prototype, so calling
-      // mod.toString() directly throws. Use Object.prototype.toString
-      // to safely detect them.
-      Object.prototype.toString.call(mod) !== "[object Module]") {
-        try {
-          mod.default = mod;
-        } catch {
-        }
-      }
-      return mod;
-    },
-    // require — resolves directly via scope
-    r(requireId) {
-      return scopedRequire(requireId);
-    },
-    // value exports
-    v(value) {
-      if (typeof value === "function") {
-        exports.default = value((vid) => scopedRequire(vid));
-      } else {
-        moduleExports.exports = value;
-      }
-    },
-    // async module initializer
-    async a(mod) {
-      let result;
-      await mod(
-        () => {
-        },
-        (value) => result = value
-      );
-      exports.default = result;
-    },
-    // async module loader — resolves directly via scope
-    async A(Aid) {
-      const mod = scopedRequire(Aid);
-      return mod.default((parentId) => scopedRequire(parentId));
-    },
-    // dynamic import tracking — no-op for remote components
-    j() {
-    },
-    // chunk loader — loads directly via scope, no global dispatch
-    l(url) {
-      const flatModules = Array.isArray(modules) ? modules : [];
-      const moduleInitIndex = flatModules.indexOf(moduleInit);
-      if (moduleInitIndex !== -1) {
-        const scriptIndex = flatModules.slice(0, moduleInitIndex).findLastIndex((bundleEntry) => bundleEntry instanceof Element);
-        if (scriptIndex !== -1) {
-          const script = flatModules[scriptIndex];
-          const scriptSrc = script.getAttribute("data-turbopack-src") || "";
-          const nextIndex = scriptSrc.indexOf("/_next");
-          const baseUrl = nextIndex !== -1 ? scriptSrc.slice(0, nextIndex) : "";
-          const chunkUrl = `${baseUrl}/_next/${url}`;
-          return loadChunkWithScope(scope, formatRemoteId(scope, chunkUrl));
-        }
-      }
-      throw new Error(
-        `Failed to load Turbopack chunk "${url}" for module "${id}". Check the URL is correct.`
-      );
-    },
-    // globalThis substitute shared across all modules in this scope
-    g: scope.moduleGlobal,
-    m: moduleExports,
-    e: exports
-  };
-}
-var init_module = __esm({
-  "src/runtime/turbopack/module.ts"() {
-    "use strict";
-    init_logger();
-    init_chunk_loader();
-    init_remote_scope();
-    init_shared_modules();
-  }
-});
 
-// src/runtime/turbopack/remote-scope-setup.ts
-async function setupRemoteScope(runtime, scripts = [], url = new URL(location.href), bundle, resolveClientUrl) {
-  const self = globalThis;
-  const ns = getNamespace();
-  const bundleName = bundle ?? "default";
-  const existingScope = getScope(bundleName);
-  if (existingScope && existingScope.url.origin === url.origin) {
-    logDebug(
-      "WebpackRuntime",
-      `Reusing scope "${existingScope.scopedName}" (turbopackModules=${existingScope.turbopackModules.length})`
-    );
-    existingScope.resolveClientUrl = resolveClientUrl;
-    if (runtime === RUNTIME_TURBOPACK) {
-      await Promise.allSettled(
-        scripts.map(
-          (script) => script.src ? loadChunkWithScope(existingScope, script.src) : Promise.resolve(void 0)
-        )
-      );
-    }
-    return existingScope;
-  }
-  const scope = createScope(bundleName, url, runtime, resolveClientUrl);
-  registerScope(scope);
-  if (runtime === RUNTIME_WEBPACK && self.__remote_webpack_require__?.[bundleName]) {
-    scope.webpackRequire = self.__remote_webpack_require__[bundleName];
-  }
-  ns.bundleUrls[bundleName] = url;
-  if (scope.scopedName !== bundleName) {
-    ns.bundleUrls[scope.scopedName] = url;
-  }
-  self.__webpack_get_script_filename__ = () => null;
-  const willCreateDispatchers = typeof self.__webpack_require__ !== "function" || ns.dispatcherRuntime !== "turbopack";
-  if (willCreateDispatchers) {
-    if (!self.__original_webpack_require__ && !self.__original_webpack_chunk_load__) {
-      self.__original_webpack_chunk_load__ = self.__webpack_chunk_load__;
-      self.__original_webpack_require__ = self.__webpack_require__;
-    }
-    self.__webpack_chunk_load__ = createChunkDispatcher();
-    self.__webpack_require__ = createModuleDispatcher(runtime);
-    ns.dispatcherRuntime = runtime;
-    self.__webpack_require_type__ = runtime;
-    if (self.__remote_webpack_require__ && runtime === RUNTIME_TURBOPACK) {
-      self.__remote_webpack_require__[bundleName] = self.__webpack_require__;
-      self.__remote_webpack_require__[bundleName].type = "turbopack";
-    }
-  }
-  if (self.__remote_webpack_require__?.[bundleName] && scope.scopedName !== bundleName) {
-    self.__remote_webpack_require__[scope.scopedName] = self.__remote_webpack_require__[bundleName];
-  }
-  if (runtime === RUNTIME_TURBOPACK) {
-    const results = await Promise.allSettled(
-      scripts.map((script) => {
-        if (script.src) {
-          return loadChunkWithScope(scope, script.src);
-        }
-        return Promise.resolve(void 0);
-      })
-    );
-    for (const result of results) {
-      if (result.status === "rejected") {
-        logWarn(
-          "WebpackRuntime",
-          `Initial chunk load failed: ${String(result.reason)}`
-        );
-      }
-    }
-  }
-  return scope;
-}
-function createModuleDispatcher(runtime) {
-  return (id) => {
-    const self = globalThis;
-    const { bundle, id: moduleId } = id.match(REMOTE_COMPONENT_REGEX)?.groups ?? {
-      bundle: "default",
-      id
-    };
-    const bundleName = bundle ?? "default";
-    const remoteRuntime = self.__remote_webpack_require__?.[bundleName] ? self.__remote_webpack_require__[bundleName]?.type || "webpack" : runtime;
-    logDebug(
-      "ModuleDispatcher",
-      `Resolving "${id}" (bundle: "${bundleName}", runtime: "${remoteRuntime}")`
-    );
-    try {
-      if (remoteRuntime === RUNTIME_WEBPACK && bundle && moduleId) {
-        const scope2 = getScope(bundle);
-        if (scope2?.webpackRequire)
-          return scope2.webpackRequire(moduleId);
-        return self.__remote_webpack_require__?.[bundle]?.(moduleId);
-      }
-      const scope = getScope(bundleName);
-      if (scope) {
-        return requireModule(scope, moduleId ?? id, id);
-      }
-      throw new Error(
-        `Module "${id}" not found \u2014 no scope for bundle "${bundleName}".`
-      );
-    } catch (requireError) {
-      logWarn(
-        "ModuleDispatcher",
-        `Module require failed: ${String(requireError)}`
-      );
-      if (typeof self.__original_webpack_require__ !== "function") {
-        throw new RemoteComponentsError(
-          `Module "${id}" not found in remote component bundle "${bundleName}".`,
-          {
-            cause: requireError instanceof Error ? requireError : void 0
-          }
-        );
-      }
-      try {
-        logDebug(
-          "ModuleDispatcher",
-          "Falling back to original webpack require"
-        );
-        return self.__original_webpack_require__(id);
-      } catch (originalError) {
-        throw new RemoteComponentsError(
-          `Module "${id}" not found in remote component bundle "${bundleName}".`,
-          { cause: originalError instanceof Error ? originalError : void 0 }
-        );
-      }
-    }
-  };
-}
-var init_remote_scope_setup = __esm({
-  "src/runtime/turbopack/remote-scope-setup.ts"() {
-    "use strict";
-    init_constants2();
-    init_namespace();
-    init_patterns();
-    init_error();
-    init_logger();
-    init_chunk_loader();
-    init_module();
-    init_remote_scope();
-  }
-});
 
-// src/host/html/runtime/turbopack.ts
-var turbopack_exports = {};
-__export(turbopack_exports, {
-  turbopackRuntime: () => turbopackRuntime
-});
-async function turbopackRuntime(url, bundle, shared, remoteShared, resolveClientUrl) {
-  const self = globalThis;
-  const hostShared = buildHostShared(shared, resolveClientUrl, {
-    includeRemoteComponentShared: true
-  });
-  await setupRemoteScope("turbopack", [], url, bundle, resolveClientUrl);
-  const {
-    default: { createFromReadableStream }
-  } = await import("react-server-dom-webpack/client.browser");
-  async function preloadScripts(scripts, __) {
-    const scope = await setupRemoteScope(
-      "turbopack",
-      scripts.map((script) => ({
-        src: script.getAttribute("src") || script.getAttribute("data-src") || script.src
-      })),
-      url,
-      bundle,
-      resolveClientUrl
-    );
-    await initializeSharedModules(
-      scope,
-      buildCoreShared(hostShared),
-      remoteShared ?? {}
-    );
-  }
-  return {
-    self,
-    createFromReadableStream,
-    applySharedModules,
-    nextClientPagesLoader,
-    preloadScripts
-  };
-}
-var init_turbopack = __esm({
-  "src/host/html/runtime/turbopack.ts"() {
-    "use strict";
-    init_apply_shared_modules();
-    init_next_client_pages_loader();
-    init_shared_module_resolver();
-    init_remote_scope_setup();
-    init_shared_modules();
-  }
-});
 
-// src/runtime/loaders/static-loader.ts
-async function importViaCallback(absoluteSrc, resolveClientUrl) {
-  const resolvedUrl = resolveClientUrl(absoluteSrc) ?? absoluteSrc;
-  const fetchUrl = new URL(resolvedUrl, location.href).href;
-  const response = await fetch(fetchUrl);
-  if (!response.ok)
-    throw new Error(`Proxied fetch failed: ${response.status}`);
-  const content = (await response.text()).replace(/import\.meta\.url/g, JSON.stringify(absoluteSrc)).replace(
-    /\b(from|import)\s*(["'])(\.\.?\/[^"']+)\2/g,
-    (_, keyword, quote, relativePath) => {
-      const absoluteImportUrl = new URL(relativePath, absoluteSrc).href;
-      const resolvedImportUrl = new URL(
-        resolveClientUrl(absoluteImportUrl) ?? absoluteImportUrl,
-        location.href
-      ).href;
-      return `${keyword} ${quote}${resolvedImportUrl}${quote}`;
-    }
-  );
-  const moduleBlobUrl = URL.createObjectURL(
-    new Blob([content], { type: "text/javascript" })
-  );
-  const wrapperContent = [
-    `import*as m from${JSON.stringify(moduleBlobUrl)};`,
-    `globalThis.__rc_module_registry__=globalThis.__rc_module_registry__||{};`,
-    `globalThis.__rc_module_registry__[${JSON.stringify(absoluteSrc)}]=m;`
-  ].join("");
-  const wrapperBlobUrl = URL.createObjectURL(
-    new Blob([wrapperContent], { type: "text/javascript" })
-  );
-  const scriptEl = document.createElement("script");
-  scriptEl.type = "module";
-  scriptEl.src = wrapperBlobUrl;
-  try {
-    await new Promise((resolve, reject) => {
-      scriptEl.onload = () => resolve();
-      scriptEl.onerror = () => reject(new Error(`Failed to load module for ${absoluteSrc}`));
-      document.head.appendChild(scriptEl);
-    });
-  } finally {
-    scriptEl.remove();
-    URL.revokeObjectURL(moduleBlobUrl);
-    URL.revokeObjectURL(wrapperBlobUrl);
-  }
-  const registry = getNamespace().moduleRegistry;
-  const mod = registry[absoluteSrc] ?? {};
-  delete registry[absoluteSrc];
-  return mod;
-}
-async function importDirectly(absoluteSrc) {
-  try {
-    return await import(
-      /* @vite-ignore */
-      /* webpackIgnore: true */
-      absoluteSrc
-    );
-  } catch (importError) {
-    if (!absoluteSrc.startsWith("blob:")) {
-      warnCrossOriginFetchError("StaticLoader", absoluteSrc);
-    }
-    throw importError;
-  }
-}
-function resolveScriptSrc(script, url) {
-  const rawSrc = typeof script.getAttribute === "function" ? script.getAttribute("src") ?? script.src : script.src;
-  if (!rawSrc && script.textContent) {
-    return URL.createObjectURL(
-      new Blob(
-        [script.textContent.replace(/import\.meta\.url/g, JSON.stringify(url))],
-        { type: "text/javascript" }
-      )
-    );
-  }
-  return rawSrc;
-}
-async function loadStaticRemoteComponent(scripts, url, resolveClientUrl) {
-  const ns = getNamespace();
-  if (ns.mountFns[url.href]) {
-    ns.mountFns[url.href] = /* @__PURE__ */ new Set();
-  }
-  if (ns.unmountFns[url.href]) {
-    ns.unmountFns[url.href] = /* @__PURE__ */ new Set();
-  }
-  const mountUnmountSets = await Promise.all(
-    scripts.map(async (script) => {
-      try {
-        const src = resolveScriptSrc(script, url);
-        const absoluteSrc = new URL(src, url).href;
-        const mod = resolveClientUrl ? await importViaCallback(absoluteSrc, resolveClientUrl) : await importDirectly(absoluteSrc);
-        if (src.startsWith("blob:")) {
-          URL.revokeObjectURL(src);
-        }
-        if (typeof mod.mount === "function" || typeof mod.default?.mount === "function") {
-          if (!ns.mountFns[url.href]) {
-            ns.mountFns[url.href] = /* @__PURE__ */ new Set();
-          }
-          ns.mountFns[url.href]?.add(
-            mod.mount || mod.default?.mount || (() => {
-            })
-          );
-        }
-        if (typeof mod.unmount === "function" || typeof mod.default?.unmount === "function") {
-          if (!ns.unmountFns[url.href]) {
-            ns.unmountFns[url.href] = /* @__PURE__ */ new Set();
-          }
-          ns.unmountFns[url.href]?.add(
-            mod.unmount || mod.default?.unmount || (() => {
-            })
-          );
-        }
-        return {
-          mount: mod.mount || mod.default?.mount,
-          unmount: mod.unmount || mod.default?.unmount
-        };
-      } catch (e) {
-        logError(
-          "StaticLoader",
-          `Error loading remote component script from "${script.src || url.href}".`,
-          e
-        );
-        return {
-          mount: void 0,
-          unmount: void 0
-        };
-      }
-    })
-  );
-  return mountUnmountSets.reduce(
-    (acc, { mount, unmount }) => {
-      if (typeof mount === "function") {
-        acc.mount.add(mount);
-      }
-      if (typeof unmount === "function") {
-        acc.unmount.add(unmount);
-      }
-      return acc;
-    },
-    {
-      mount: /* @__PURE__ */ new Set(),
-      unmount: /* @__PURE__ */ new Set()
-    }
-  );
-}
-var init_static_loader = __esm({
-  "src/runtime/loaders/static-loader.ts"() {
-    "use strict";
-    init_namespace();
-    init_logger();
-  }
-});
 
-// src/host/html/runtime/script.ts
-var script_exports = {};
-__export(script_exports, {
-  scriptRuntime: () => scriptRuntime
-});
-function scriptRuntime(resolveClientUrl) {
-  const self = globalThis;
-  return {
-    self,
-    createFromReadableStream: () => Promise.resolve(null),
-    applySharedModules: () => Promise.resolve(),
-    nextClientPagesLoader: () => ({
-      Component: null,
-      App: null
-    }),
-    preloadScripts: (scripts, url) => loadStaticRemoteComponent(scripts, url, resolveClientUrl)
-  };
-}
-var init_script = __esm({
-  "src/host/html/runtime/script.ts"() {
-    "use strict";
-    init_static_loader();
-  }
-});
 
-// src/host/html/index.tsx
-var html_exports = {};
-__export(html_exports, {
-  registerSharedModules: () => registerSharedModules
-});
-module.exports = __toCommonJS(html_exports);
-var import_react = require("react");
-var import_client = require("react-dom/client");
 
-// src/host/server/fetch-with-hooks.ts
-init_logger();
 
-// src/host/server/fetch-headers.ts
-function remoteFetchHeaders() {
-  return {
-    /**
-     * Authenticates deployment protection for the remote. Needed for SSR and SSG clients.
-     * If the remote component uses vercel deployment protection, ensure the host and remote vercel
-     * projects share a common automation bypass secret, and the shared secret is used as the
-     * VERCEL_AUTOMATION_BYPASS_SECRET env var in the host project.
-     */
-    ...typeof process === "object" && typeof process.env === "object" && typeof process.env.VERCEL_AUTOMATION_BYPASS_SECRET === "string" ? {
-      "x-vercel-protection-bypass": process.env.VERCEL_AUTOMATION_BYPASS_SECRET
-    } : {},
-    Accept: "text/html"
-  };
-}
+var _chunkER73O65Fcjs = require('../chunk-ER73O65F.cjs');
+require('../chunk-6IUP26UK.cjs');
+require('../chunk-F44NODUS.cjs');
+require('../chunk-XCFYWSLD.cjs');
+require('../chunk-CREXMFMF.cjs');
 
-// src/host/server/fetch-with-hooks.ts
-async function fetchWithWarning(url, init) {
-  try {
-    return await fetch(url, init);
-  } catch (error) {
-    warnCrossOriginFetchError("FetchRemoteComponent", url);
-    throw error;
-  }
-}
-async function fetchWithHooks(url, additionalInit, options = {}) {
-  const {
-    onRequest,
-    onResponse,
-    abortController = new AbortController()
-  } = options;
-  const signal = abortController.signal;
-  const hookOptions = {
-    signal,
-    abort: (reason) => abortController.abort(reason)
-  };
-  const init = {
-    method: "GET",
-    headers: remoteFetchHeaders(),
-    signal,
-    ...additionalInit
-  };
-  const res = await onRequest?.(url, init, hookOptions) ?? await fetchWithWarning(url, init);
-  return await onResponse?.(url, res, hookOptions) ?? res;
-}
-
-// src/host/server/get-client-or-server-url.ts
-function getClientOrServerUrl(src, serverFallback) {
-  const fallback = typeof location !== "undefined" ? location.href : serverFallback;
-  if (!src) {
-    return new URL(fallback);
-  }
-  return typeof src === "string" ? new URL(src, fallback) : src;
-}
-
-// src/host/shared/state.ts
-function createHostState() {
-  return {
-    stage: "idle",
-    prevSrc: void 0,
-    prevUrl: void 0,
-    prevName: void 0,
-    prevIsRemoteComponent: false,
-    abortController: void 0
-  };
-}
 
-// src/host/utils/resolve-name-from-src.ts
-function resolveNameFromSrc(src, defaultName) {
-  if (!src) {
-    return defaultName;
-  }
-  const hash = typeof src === "string" ? src : src.hash;
-  const hashIndex = hash.indexOf("#");
-  if (hashIndex < 0) {
-    return defaultName;
-  }
-  const name = hash.slice(hashIndex + 1);
-  return name || defaultName;
-}
 
-// src/host/html/index.tsx
-init_constants2();
 
-// src/runtime/html/html-spec.ts
-var ORIGIN_REWRITE_TAGS = [
-  "img",
-  "source",
-  "video",
-  "audio",
-  "track",
-  "iframe",
-  "embed",
-  "script",
-  "link"
-];
-var ID_SUFFIX_RSC = "_rsc";
-var ID_SUFFIX_SSR = "_ssr";
-var ID_SUFFIX_SHARED = "_shared";
-var DATA_BUNDLE = "data-bundle";
-var DATA_ROUTE = "data-route";
-var DATA_RUNTIME = "data-runtime";
-var DATA_TYPE = "data-type";
-var DATA_SRC = "data-src";
-var DATA_REMOTE_COMPONENTS_SHARED = "data-remote-components-shared";
-var TAG_REMOTE_COMPONENT = "remote-component";
-var NEXT_DATA_ID = "__NEXT_DATA__";
-var REMOTE_NEXT_DATA_ID = "__REMOTE_NEXT_DATA__";
-var NEXT_CONTAINER_ID = "__next";
+var _chunkR4QFK5TNcjs = require('../chunk-R4QFK5TN.cjs');
 
-// src/runtime/html/rewrite-srcset.ts
-function rewriteSrcset(srcset, base, resolve) {
-  return srcset.split(",").map((entry) => {
-    const [url, descriptor] = entry.trim().split(/\s+/);
-    if (!url)
-      return entry;
-    const absoluteUrl = new URL(url, base).href;
-    const resolvedUrl = resolve ? resolve(absoluteUrl) : absoluteUrl;
-    return descriptor ? `${resolvedUrl} ${descriptor}` : resolvedUrl;
-  }).join(", ");
-}
 
-// src/runtime/html/apply-origin.ts
-function applyOriginToNodes(doc, url, resolveClientUrl) {
-  if (url.origin !== location.origin) {
-    const nodes = doc.querySelectorAll(
-      ORIGIN_REWRITE_TAGS.map(
-        (type) => `${type}[src],${type}[srcset],${type}[href],${type}[imagesrcset]`
-      ).join(",")
-    );
-    nodes.forEach((node) => {
-      if (node.hasAttribute("src") && /^[./]+\/?/.test(node.getAttribute("src") ?? "")) {
-        const absoluteSrc = new URL(node.getAttribute("src") ?? "/", url).href;
-        const isScript = node.tagName.toLowerCase() === "script";
-        node.src = isScript ? absoluteSrc : resolveClientUrl?.(absoluteSrc) ?? absoluteSrc;
-      }
-      if (node.hasAttribute("href") && /^[./]+\/?/.test(node.getAttribute("href") ?? "")) {
-        const absoluteHref = new URL(node.getAttribute("href") ?? "/", url).href;
-        node.setAttribute(
-          "href",
-          resolveClientUrl?.(absoluteHref) ?? absoluteHref
-        );
-      }
-      if (node.hasAttribute("srcset")) {
-        const raw = node.getAttribute("srcset");
-        if (raw) {
-          const resolve = resolveClientUrl ? (abs) => resolveClientUrl(abs) ?? abs : void 0;
-          node.setAttribute("srcset", rewriteSrcset(raw, url, resolve));
-        }
-      }
-      if (node.hasAttribute("imagesrcset")) {
-        const raw = node.getAttribute("imagesrcset");
-        if (raw) {
-          const resolve = resolveClientUrl ? (abs) => resolveClientUrl(abs) ?? abs : void 0;
-          node.setAttribute("imagesrcset", rewriteSrcset(raw, url, resolve));
-        }
-      }
-    });
-  }
-}
-
-// src/runtime/html/parse-remote-html.ts
-init_constants2();
-
-// src/runtime/metadata.ts
-init_constants2();
-var VALID_RUNTIMES = /* @__PURE__ */ new Set(["webpack", "turbopack", "script"]);
-var VALID_TYPES = /* @__PURE__ */ new Set([
-  "nextjs",
-  "remote-component",
-  "unknown"
-]);
-function isRuntime(value) {
-  return VALID_RUNTIMES.has(value);
-}
-function isComponentType(value) {
-  return VALID_TYPES.has(value);
-}
-function toRuntime(value) {
-  return value && isRuntime(value) ? value : "webpack";
-}
-function toComponentType(value) {
-  return value && isComponentType(value) ? value : "unknown";
-}
-function buildMetadata(attrs, url) {
-  const id = attrs.id || DEFAULT_COMPONENT_NAME;
-  const bundle = attrs.bundle || process.env.NEXT_PUBLIC_MFE_CURRENT_APPLICATION || DEFAULT_BUNDLE_NAME;
-  return {
-    name: attrs.name || id.replace(/_ssr$/, ""),
-    bundle,
-    route: attrs.route || url.pathname || DEFAULT_ROUTE,
-    runtime: toRuntime(attrs.runtime),
-    id,
-    type: toComponentType(attrs.type)
-  };
-}
+var _chunk7MVFHOIPcjs = require('../chunk-7MVFHOIP.cjs');
 
-// src/runtime/html/parse-remote-html.ts
-init_error();
-function validateSingleComponent(doc, name, url) {
-  if (doc.querySelectorAll(`div[${DATA_BUNDLE}][${DATA_ROUTE}]`).length > 1 && !doc.querySelector(
-    `div[${DATA_BUNDLE}][${DATA_ROUTE}][id^="${name}"]`
-  ) || doc.querySelectorAll(`${TAG_REMOTE_COMPONENT}:not([src])`).length > 1 && !doc.querySelector(`${TAG_REMOTE_COMPONENT}[name="${name}"]`)) {
-    throw multipleRemoteComponentsError(url);
-  }
-}
-function findComponentElement(doc, name) {
-  return doc.querySelector(`div[${DATA_BUNDLE}][${DATA_ROUTE}][id^="${name}"]`) ?? doc.querySelector(`div[${DATA_BUNDLE}][${DATA_ROUTE}]`) ?? doc.querySelector(`div#${NEXT_CONTAINER_ID}`) ?? doc.querySelector(`${TAG_REMOTE_COMPONENT}[name="${name}"]:not([src])`) ?? doc.querySelector(`${TAG_REMOTE_COMPONENT}:not([src])`);
-}
-function parseNextData(doc) {
-  return JSON.parse(
-    (doc.querySelector(`#${NEXT_DATA_ID}`) ?? doc.querySelector(`#${REMOTE_NEXT_DATA_ID}`))?.textContent ?? "null"
-  );
-}
-function resolveComponentName(component, nextData, fallbackName) {
-  const isRemoteComponent = component?.tagName.toLowerCase() === TAG_REMOTE_COMPONENT;
-  const name = component?.getAttribute("id")?.replace(new RegExp(`${ID_SUFFIX_SSR}$`), "") || isRemoteComponent && component?.getAttribute("name") || (nextData ? "__next" : fallbackName);
-  return { name, isRemoteComponent };
-}
-function extractRemoteShared(doc, name, nextData) {
-  const remoteSharedEl = doc.querySelector(
-    `#${name}${ID_SUFFIX_SHARED}[${DATA_REMOTE_COMPONENTS_SHARED}]`
-  );
-  const remoteShared = nextData?.props.__REMOTE_COMPONENT__?.shared ?? (JSON.parse(remoteSharedEl?.textContent ?? "{}") ?? {});
-  remoteSharedEl?.remove();
-  return remoteShared;
-}
-function validateComponentFound(component, rsc, nextData, isRemoteComponent, url, name) {
-  if (!component || !(rsc || nextData || isRemoteComponent)) {
-    throw new RemoteComponentsError(
-      `Remote Component not found on ${url}.${name !== DEFAULT_COMPONENT_NAME ? ` The name for the <RemoteComponent> is "${name}". Check <RemoteComponent> usage.` : ""} Did you forget to wrap the content in <RemoteComponent>?`
-    );
-  }
-}
-function extractLinks(doc, component) {
-  return Array.from(doc.querySelectorAll("link[href]")).filter(
-    (link) => !component.contains(link)
-  );
-}
-function extractScripts(doc, component, isRemoteComponent) {
-  return Array.from(
-    (isRemoteComponent ? component : doc).querySelectorAll(
-      `script[src],script[${DATA_SRC}]`
-    )
-  );
-}
-function parseRemoteComponentDocument(doc, name, url) {
-  validateSingleComponent(doc, name, url.href);
-  const component = findComponentElement(doc, name);
-  const nextData = parseNextData(doc);
-  const { name: resolvedName, isRemoteComponent } = resolveComponentName(
-    component,
-    nextData,
-    name
-  );
-  const rsc = doc.querySelector(`#${resolvedName}${ID_SUFFIX_RSC}`);
-  const metadata = buildMetadata(
-    {
-      name: resolvedName,
-      bundle: component?.getAttribute(DATA_BUNDLE) || nextData?.props.__REMOTE_COMPONENT__?.bundle,
-      route: component?.getAttribute(DATA_ROUTE) ?? nextData?.page,
-      runtime: component?.getAttribute(DATA_RUNTIME) ?? nextData?.props.__REMOTE_COMPONENT__?.runtime ?? RUNTIME_SCRIPT,
-      id: component?.getAttribute("id"),
-      type: component?.getAttribute(DATA_TYPE)
-    },
-    url
-  );
-  const remoteShared = extractRemoteShared(doc, resolvedName, nextData);
-  validateComponentFound(
-    component,
-    rsc,
-    nextData,
-    isRemoteComponent,
-    url.href,
-    resolvedName
-  );
-  const links = extractLinks(doc, component);
-  const scripts = extractScripts(doc, component, isRemoteComponent);
-  return {
-    component,
-    name: resolvedName,
-    isRemoteComponent,
-    metadata,
-    nextData,
-    rsc,
-    remoteShared,
-    links,
-    scripts
-  };
-}
 
-// src/host/html/index.tsx
-init_namespace();
 
-// src/runtime/rsc.ts
-var import_web_streams_polyfill = require("web-streams-polyfill");
-function fixPayload(payload) {
-  if (Array.isArray(payload)) {
-    if (payload[0] === "$") {
-      fixPayload(payload[3]);
-      if (payload.length === 4) {
-        payload.push(null, null, 1);
-      }
-    } else {
-      for (const item of payload) {
-        fixPayload(item);
-      }
-    }
-  } else if (typeof payload === "object" && payload !== null) {
-    for (const key in payload) {
-      fixPayload(payload[key]);
-    }
-  }
-}
-function buildRSCChunks(rscName, data) {
-  const chunks = [];
-  for (const chunk of data) {
-    for (const line of chunk.split("\n")) {
-      const match = /\.push\("(?<rsc>.*)"\);$/.exec(line);
-      if (match?.groups?.rsc) {
-        chunks.push(JSON.parse(`"${match.groups.rsc}"`));
-      }
-    }
-  }
-  return chunks;
-}
-function createRSCStream(rscName, data) {
-  return new import_web_streams_polyfill.ReadableStream({
-    type: "bytes",
-    start(controller) {
-      const encoder = new TextEncoder();
-      const self = globalThis;
-      if (data.length > 0) {
-        const parsed = buildRSCChunks(rscName, data);
-        if (parsed.length > 0) {
-          self[rscName] = self[rscName] ?? [];
-          self[rscName].push(...parsed);
-        }
-      }
-      const allChunks = (self[rscName] ?? [`0:[null]
-`]).join("");
-      self[rscName] = null;
-      allChunks.split("\n").forEach((chunk) => {
-        if (chunk.length > 0) {
-          const { before, id, prefix, payload } = /^(?<before>[^:]*?)?(?<id>[0-9a-zA-Z]+):(?<prefix>[A-Z])?(?<payload>\[.*\])/.exec(
-            chunk
-          )?.groups ?? {};
-          if (payload) {
-            const jsonPayload = JSON.parse(payload);
-            fixPayload(jsonPayload);
-            const reconstruct = `${before ?? ""}${id}:${prefix ?? ""}${JSON.stringify(jsonPayload)}`;
-            controller.enqueue(encoder.encode(`${reconstruct}
-`));
-          } else {
-            controller.enqueue(encoder.encode(`${chunk}
-`));
-          }
-        } else {
-          controller.enqueue(encoder.encode(`${chunk}
-`));
-        }
-      });
-      controller.close();
-    }
-  });
-}
 
-// src/runtime/url/resolve-client-url.ts
-function withRemoteSrc(resolveClientUrl, remoteSrc) {
-  const remoteOrigin = parseOrigin(remoteSrc);
-  return (url) => {
-    const urlOrigin = parseOrigin(url);
-    if (remoteOrigin && urlOrigin && urlOrigin !== remoteOrigin) {
-      return void 0;
-    }
-    return resolveClientUrl(remoteSrc, url);
-  };
-}
-function parseOrigin(url) {
-  try {
-    return new URL(url).origin;
-  } catch {
-    return void 0;
-  }
-}
 
-// src/runtime/url/default-resolve-client-url.ts
-function bindResolveClientUrl(prop, remoteSrc) {
-  return prop ? withRemoteSrc(prop, remoteSrc) : void 0;
-}
+var _chunkRUWR74XQcjs = require('../chunk-RUWR74XQ.cjs');
+require('../chunk-TCFLEBQM.cjs');
+require('../chunk-KE7QPAQ4.cjs');
+require('../chunk-SHFJ5OQA.cjs');
 
 // src/host/html/index.tsx
-init_utils();
-init_abort();
-init_error();
-init_logger();
+var _react = require('react');
+var _client = require('react-dom/client');
 
 // src/host/html/attach-styles.ts
-init_error();
 async function attachStyles({
   doc,
   component,
@@ -2345,9 +56,9 @@ async function attachStyles({
       link.onerror = null;
       link.remove();
     }
-    abortReject?.(new DOMException("Aborted", "AbortError"));
+    _optionalChain([abortReject, 'optionalCall', _2 => _2(new DOMException("Aborted", "AbortError"))]);
   };
-  signal?.addEventListener("abort", abortHandler, { once: true });
+  _optionalChain([signal, 'optionalAccess', _3 => _3.addEventListener, 'call', _4 => _4("abort", abortHandler, { once: true })]);
   try {
     await Promise.all(
       Array.from(links).filter((link) => !component.contains(link)).map((link) => {
@@ -2357,7 +68,7 @@ async function attachStyles({
           if (link.rel === "stylesheet") {
             newLink.onload = () => resolve();
             newLink.onerror = () => reject(
-              new RemoteComponentsError(
+              new (0, _chunkRUWR74XQcjs.RemoteComponentsError)(
                 `Failed to load <link href="${link.href}"> for Remote Component. Check the URL is correct.`
               )
             );
@@ -2369,11 +80,11 @@ async function attachStyles({
           if (attr.name === "href") {
             const absoluteHref = new URL(
               attr.value,
-              baseUrl ?? location.origin
+              _nullishCoalesce(baseUrl, () => ( location.origin))
             ).href;
             newLink.setAttribute(
               attr.name,
-              resolveClientUrl?.(absoluteHref) ?? absoluteHref
+              _nullishCoalesce(_optionalChain([resolveClientUrl, 'optionalCall', _5 => _5(absoluteHref)]), () => ( absoluteHref))
             );
           } else {
             newLink.setAttribute(attr.name, attr.value);
@@ -2385,28 +96,27 @@ async function attachStyles({
             remoteComponentSrc
           );
         }
-        root?.appendChild(newLink);
+        _optionalChain([root, 'optionalAccess', _6 => _6.appendChild, 'call', _7 => _7(newLink)]);
         return Promise.race([loadPromise, abortPromise]);
       })
     );
   } finally {
-    signal?.removeEventListener("abort", abortHandler);
+    _optionalChain([signal, 'optionalAccess', _8 => _8.removeEventListener, 'call', _9 => _9("abort", abortHandler)]);
   }
   const styles = doc.querySelectorAll("style");
   for (const style of styles) {
-    if (style.parentElement?.tagName.toLowerCase() === "head") {
+    if (_optionalChain([style, 'access', _10 => _10.parentElement, 'optionalAccess', _11 => _11.tagName, 'access', _12 => _12.toLowerCase, 'call', _13 => _13()]) === "head") {
       const newStyle = document.createElement("style");
       newStyle.textContent = style.textContent;
       if (remoteComponentSrc) {
         newStyle.setAttribute("data-remote-component-src", remoteComponentSrc);
       }
-      root?.appendChild(newStyle);
+      _optionalChain([root, 'optionalAccess', _14 => _14.appendChild, 'call', _15 => _15(newStyle)]);
     }
   }
 }
 
 // src/host/html/runtime/index.ts
-init_error();
 async function getRuntime(type, url, bundle, shared, remoteShared, resolveClientUrl) {
   if (typeof globalThis.process === "undefined") {
     globalThis.process = {
@@ -2414,11 +124,11 @@ async function getRuntime(type, url, bundle, shared, remoteShared, resolveClient
     };
   }
   if (type === "webpack") {
-    const { webpackRuntime: webpackRuntime2 } = await Promise.resolve().then(() => (init_webpack(), webpack_exports));
-    return webpackRuntime2(bundle, shared, remoteShared, resolveClientUrl);
+    const { webpackRuntime } = await Promise.resolve().then(() => _interopRequireWildcard(require("../webpack-KSCMCL7M.cjs")));
+    return webpackRuntime(bundle, shared, remoteShared, resolveClientUrl);
   } else if (type === "turbopack") {
-    const { turbopackRuntime: turbopackRuntime2 } = await Promise.resolve().then(() => (init_turbopack(), turbopack_exports));
-    return turbopackRuntime2(
+    const { turbopackRuntime } = await Promise.resolve().then(() => _interopRequireWildcard(require("../turbopack-WRMKPNN4.cjs")));
+    return turbopackRuntime(
       url,
       bundle,
       shared,
@@ -2426,32 +136,33 @@ async function getRuntime(type, url, bundle, shared, remoteShared, resolveClient
       resolveClientUrl
     );
   } else if (type === "script") {
-    const { scriptRuntime: scriptRuntime2 } = await Promise.resolve().then(() => (init_script(), script_exports));
-    return scriptRuntime2(resolveClientUrl);
+    const { scriptRuntime } = await Promise.resolve().then(() => _interopRequireWildcard(require("../script-6W5JRBZK.cjs")));
+    return scriptRuntime(resolveClientUrl);
   }
-  throw new RemoteComponentsError(
+  throw new (0, _chunkRUWR74XQcjs.RemoteComponentsError)(
     `Remote Components runtime "${type}" is not supported. Supported runtimes are "webpack", "turbopack", and "script".`
   );
 }
 
 // src/host/html/index.tsx
-var import_jsx_runtime2 = require("react/jsx-runtime");
+var _jsxruntime = require('react/jsx-runtime');
 if (typeof HTMLElement !== "undefined") {
-  class RemoteComponent extends HTMLElement {
-    name = DEFAULT_COMPONENT_NAME;
-    bundle = DEFAULT_BUNDLE_NAME;
-    fallbackSlot;
-    __next = null;
-    fouc = null;
-    hostState = createHostState();
-    root = null;
-    reactRoot;
-    onRequest;
-    onResponse;
-    resolveClientUrl;
+  class RemoteComponent extends HTMLElement {constructor(...args) { super(...args); RemoteComponent.prototype.__init.call(this);RemoteComponent.prototype.__init2.call(this);RemoteComponent.prototype.__init3.call(this);RemoteComponent.prototype.__init4.call(this);RemoteComponent.prototype.__init5.call(this);RemoteComponent.prototype.__init6.call(this);RemoteComponent.prototype.__init7.call(this); }
+    __init() {this.name = _chunkR4QFK5TNcjs.DEFAULT_COMPONENT_NAME}
+    __init2() {this.bundle = _chunkR4QFK5TNcjs.DEFAULT_BUNDLE_NAME}
+    
+    __init3() {this.__next = null}
+    __init4() {this.fouc = null}
+    __init5() {this.hostState = _chunkER73O65Fcjs.createHostState.call(void 0, )}
+    __init6() {this.root = null}
+    
+    __init7() {this.emitter = _chunkER73O65Fcjs.makeEventEmitter.call(void 0, this)}
+    
+    
+    
     // -- ConsumeServerConfig property accessors (attribute-reflected) --
     get src() {
-      return this.getAttribute("src") ?? void 0;
+      return _nullishCoalesce(this.getAttribute("src"), () => ( void 0));
     }
     set src(value) {
       if (value == null) {
@@ -2496,22 +207,15 @@ if (typeof HTMLElement !== "undefined") {
     static get observedAttributes() {
       return ["src", "name", "mode"];
     }
-    dispatchLifecycleEvent(type, detail) {
-      const event = new Event(type, { bubbles: true, composed: true });
-      if (detail) {
-        Object.assign(event, detail);
-      }
-      this.dispatchEvent(event);
-    }
     attributeChangedCallback(name, oldValue, newValue) {
       if ((name === "src" || name === "name") && oldValue !== newValue) {
         if (this.src) {
           this.load().catch((e) => {
-            if (isAbortError(e)) {
+            if (_chunkRUWR74XQcjs.isAbortError.call(void 0, e)) {
               return;
             }
-            logError("HtmlHost", "Error loading remote component.", e);
-            this.dispatchLifecycleEvent("error", { error: e, src: this.src });
+            _chunkRUWR74XQcjs.logError.call(void 0, "HtmlHost", "Error loading remote component.", e);
+            this.emitter.error(e, this.src);
             this.hostState.stage = "error";
           });
         }
@@ -2524,11 +228,11 @@ if (typeof HTMLElement !== "undefined") {
         });
         this.root = newRoot;
         this.load().catch((e) => {
-          if (isAbortError(e)) {
+          if (_chunkRUWR74XQcjs.isAbortError.call(void 0, e)) {
             return;
           }
-          logError("HtmlHost", "Error reloading remote component.", e);
-          this.dispatchLifecycleEvent("error", { error: e, src: this.src });
+          _chunkRUWR74XQcjs.logError.call(void 0, "HtmlHost", "Error reloading remote component.", e);
+          this.emitter.error(e, this.src);
         });
       }
     }
@@ -2539,7 +243,7 @@ if (typeof HTMLElement !== "undefined") {
         });
       });
       if (this.hostState.stage === "loading") {
-        this.hostState.abortController?.abort();
+        _optionalChain([this, 'access', _16 => _16.hostState, 'access', _17 => _17.abortController, 'optionalAccess', _18 => _18.abort, 'call', _19 => _19()]);
         this.hostState.stage = "idle";
         if (this.root && !this.reactRoot) {
           this.root.innerHTML = "";
@@ -2562,50 +266,50 @@ if (typeof HTMLElement !== "undefined") {
       const signal = this.hostState.abortController.signal;
       const isCurrentLoad = () => !signal.aborted && this.src === src;
       const abandonLoad = () => {
-        if (this.hostState.abortController?.signal === signal && this.hostState.stage === "loading") {
+        if (_optionalChain([this, 'access', _20 => _20.hostState, 'access', _21 => _21.abortController, 'optionalAccess', _22 => _22.signal]) === signal && this.hostState.stage === "loading") {
           this.hostState.stage = "idle";
         }
       };
-      this.dispatchLifecycleEvent("beforeload", { src });
+      this.emitter.beforeLoad(_nullishCoalesce(src, () => ( "")));
       const remoteComponentChild = this.querySelector("div#__REMOTE_COMPONENT__") || this.querySelector("div[data-bundle][data-route]");
       if (!src && !remoteComponentChild) {
-        throw new RemoteComponentsError('"src" attribute is required');
+        throw new (0, _chunkRUWR74XQcjs.RemoteComponentsError)('"src" attribute is required');
       }
       let url = null;
       let html = this.innerHTML;
       if (src) {
-        url = getClientOrServerUrl(src, window.location.href);
-        this.name = resolveNameFromSrc(src, this.name);
+        url = _chunkER73O65Fcjs.getClientOrServerUrl.call(void 0, src, window.location.href);
+        this.name = _chunkER73O65Fcjs.resolveNameFromSrc.call(void 0, src, this.name);
       }
-      const resolveClientUrl = url ? bindResolveClientUrl(this.resolveClientUrl, url.href) : void 0;
+      const resolveClientUrl = url ? _chunkER73O65Fcjs.bindResolveClientUrl.call(void 0, this.resolveClientUrl, url.href) : void 0;
       if (!remoteComponentChild && url) {
         const fetchInit = {
           credentials: this.credentials || "same-origin"
         };
         const resolvedUrl = new URL(
-          resolveClientUrl?.(url.href) ?? url.href,
+          _nullishCoalesce(_optionalChain([resolveClientUrl, 'optionalCall', _23 => _23(url.href)]), () => ( url.href)),
           window.location.href
         );
         let res;
         try {
-          res = await fetchWithHooks(resolvedUrl, fetchInit, {
+          res = await _chunkER73O65Fcjs.fetchWithHooks.call(void 0, resolvedUrl, fetchInit, {
             onRequest: this.onRequest,
             onResponse: this.onResponse,
             abortController: this.hostState.abortController
           });
         } catch (e) {
-          if (isAbortError(e)) {
+          if (_chunkRUWR74XQcjs.isAbortError.call(void 0, e)) {
             return abandonLoad();
           }
           throw e;
         }
         if (!res || !res.ok) {
-          throw await errorFromFailedFetch(url.href, resolvedUrl, res);
+          throw await _chunkRUWR74XQcjs.errorFromFailedFetch.call(void 0, url.href, resolvedUrl, res);
         }
         try {
           html = await res.text();
         } catch (e) {
-          if (isAbortError(e)) {
+          if (_chunkRUWR74XQcjs.isAbortError.call(void 0, e)) {
             return abandonLoad();
           }
           throw e;
@@ -2614,13 +318,14 @@ if (typeof HTMLElement !== "undefined") {
           return abandonLoad();
         }
       }
-      const parser = new DOMParser();
-      const doc = parser.parseFromString(html, "text/html");
-      const parsed = parseRemoteComponentDocument(
-        doc,
-        this.name,
-        url ?? new URL(window.location.href)
-      );
+      const effectiveUrl = _nullishCoalesce(url, () => ( new URL(window.location.href)));
+      const { doc, parsed } = _chunkER73O65Fcjs.preparePipeline.call(void 0, {
+        html,
+        name: this.name,
+        url: effectiveUrl,
+        shared: {},
+        resolveClientUrl
+      });
       const {
         component,
         name: resolvedName,
@@ -2638,7 +343,7 @@ if (typeof HTMLElement !== "undefined") {
       this.name = resolvedName;
       this.bundle = parsedMetadata.bundle;
       if (url) {
-        getNamespace().bundleUrls[this.bundle] = url;
+        _chunk7MVFHOIPcjs.getNamespace.call(void 0, ).bundleUrls[this.bundle] = url;
       }
       const metadataEl = document.createElement("script");
       metadataEl.type = "application/json";
@@ -2650,27 +355,22 @@ if (typeof HTMLElement !== "undefined") {
         runtime: parsedMetadata.runtime
       };
       metadataEl.textContent = JSON.stringify(metadataObj);
-      if (this.previousElementSibling?.getAttribute("data-remote-component") !== null) {
-        this.previousElementSibling?.remove();
-      }
-      this.parentElement?.insertBefore(metadataEl, this);
-      if ("__remote_components_missing_shared__" in remoteShared) {
-        throw new RemoteComponentsError(
-          remoteShared.__remote_components_missing_shared__
-        );
+      if (_optionalChain([this, 'access', _24 => _24.previousElementSibling, 'optionalAccess', _25 => _25.getAttribute, 'call', _26 => _26("data-remote-component")]) !== null) {
+        _optionalChain([this, 'access', _27 => _27.previousElementSibling, 'optionalAccess', _28 => _28.remove, 'call', _29 => _29()]);
       }
+      _optionalChain([this, 'access', _30 => _30.parentElement, 'optionalAccess', _31 => _31.insertBefore, 'call', _32 => _32(metadataEl, this)]);
       if (this.hostState.prevIsRemoteComponent) {
         if (this.hostState.prevUrl) {
           const prevUrl = this.hostState.prevUrl;
-          const nsUnmount = getNamespace();
+          const nsUnmount = _chunk7MVFHOIPcjs.getNamespace.call(void 0, );
           if (nsUnmount.unmountFns[prevUrl.href]) {
             await Promise.all(
-              Array.from(nsUnmount.unmountFns[prevUrl.href] ?? []).map(
+              Array.from(_nullishCoalesce(nsUnmount.unmountFns[prevUrl.href], () => ( []))).map(
                 async (unmount) => {
                   try {
                     await unmount(this.root);
                   } catch (e) {
-                    logError(
+                    _chunkRUWR74XQcjs.logError.call(void 0, 
                       "HtmlHost",
                       `Error while calling unmount() for Remote Component from ${prevUrl.href}.`,
                       e
@@ -2687,14 +387,14 @@ if (typeof HTMLElement !== "undefined") {
         this.root.innerHTML = "";
       }
       if (this.hostState.prevSrc !== void 0) {
-        this.dispatchLifecycleEvent("change", {
-          previousSrc: this.hostState.prevSrc,
-          nextSrc: src,
+        this.emitter.change({
+          previousSrc: _nullishCoalesce(this.hostState.prevSrc, () => ( null)),
+          nextSrc: _nullishCoalesce(src, () => ( null)),
           previousName: this.hostState.prevName,
           nextName: this.name
         });
       }
-      this.hostState.prevUrl = url ?? new URL(window.location.href);
+      this.hostState.prevUrl = effectiveUrl;
       this.hostState.prevIsRemoteComponent = isRemoteComponent;
       this.hostState.prevSrc = src;
       this.hostState.prevName = this.name;
@@ -2707,9 +407,9 @@ if (typeof HTMLElement !== "undefined") {
         links,
         signal: void 0,
         // Effects run after load, no abort needed
-        baseUrl: url?.href,
+        baseUrl: _optionalChain([url, 'optionalAccess', _33 => _33.href]),
         remoteComponentSrc,
-        root: this.root ?? null,
+        root: _nullishCoalesce(this.root, () => ( null)),
         resolveClientUrl
       });
       if (!this.reactRoot) {
@@ -2718,7 +418,7 @@ if (typeof HTMLElement !== "undefined") {
           component,
           links,
           signal,
-          baseUrl: url?.href,
+          baseUrl: _optionalChain([url, 'optionalAccess', _34 => _34.href]),
           remoteComponentSrc,
           root: this.root,
           resolveClientUrl
@@ -2727,11 +427,6 @@ if (typeof HTMLElement !== "undefined") {
           return abandonLoad();
         }
       }
-      applyOriginToNodes(
-        doc,
-        url ?? new URL(window.location.href),
-        resolveClientUrl
-      );
       if (!this.reactRoot) {
         Array.from(component.children).forEach((el) => {
           if (!isRemoteComponent && el.tagName.toLowerCase() === "script") {
@@ -2740,11 +435,11 @@ if (typeof HTMLElement !== "undefined") {
               if (attr.name === "src") {
                 const absoluteSrc = new URL(
                   attr.value,
-                  url ?? window.location.origin
+                  _nullishCoalesce(url, () => ( window.location.origin))
                 ).href;
                 newScript.setAttribute(
                   attr.name,
-                  resolveClientUrl?.(absoluteSrc) ?? absoluteSrc
+                  _nullishCoalesce(_optionalChain([resolveClientUrl, 'optionalCall', _35 => _35(absoluteSrc)]), () => ( absoluteSrc))
                 );
               } else {
                 newScript.setAttribute(attr.name, attr.value);
@@ -2757,7 +452,7 @@ if (typeof HTMLElement !== "undefined") {
                 remoteComponentSrc
               );
             }
-            this.root?.appendChild(newScript);
+            _optionalChain([this, 'access', _36 => _36.root, 'optionalAccess', _37 => _37.appendChild, 'call', _38 => _38(newScript)]);
           } else {
             const newEl = el.cloneNode(true);
             for (const attr of el.attributes) {
@@ -2765,16 +460,16 @@ if (typeof HTMLElement !== "undefined") {
                 newEl.setAttribute(attr.name, attr.value);
               }
             }
-            this.root?.appendChild(newEl);
+            _optionalChain([this, 'access', _39 => _39.root, 'optionalAccess', _40 => _40.appendChild, 'call', _41 => _41(newEl)]);
           }
         });
       }
       for (const el of removable) {
-        el.parentElement?.removeChild(el);
+        _optionalChain([el, 'access', _42 => _42.parentElement, 'optionalAccess', _43 => _43.removeChild, 'call', _44 => _44(el)]);
       }
-      this.fallbackSlot?.remove();
+      _optionalChain([this, 'access', _45 => _45.fallbackSlot, 'optionalAccess', _46 => _46.remove, 'call', _47 => _47()]);
       const applyReset = () => {
-        if (this.reset && !this.root?.querySelector("link[data-remote-components-reset]")) {
+        if (this.reset && !_optionalChain([this, 'access', _48 => _48.root, 'optionalAccess', _49 => _49.querySelector, 'call', _50 => _50("link[data-remote-components-reset]")])) {
           const allInitial = document.createElement("link");
           allInitial.setAttribute("data-remote-components-reset", "");
           const css = `:host { all: initial; }`;
@@ -2791,9 +486,9 @@ if (typeof HTMLElement !== "undefined") {
             URL.revokeObjectURL(allInitialHref);
             allInitial.removeAttribute("onload");
           };
-          this.root?.prepend(allInitial);
-        } else if (!this.reset && this.root?.querySelector("link[data-remote-components-reset]")) {
-          this.root.querySelector("link[data-remote-components-reset]")?.remove();
+          _optionalChain([this, 'access', _51 => _51.root, 'optionalAccess', _52 => _52.prepend, 'call', _53 => _53(allInitial)]);
+        } else if (!this.reset && _optionalChain([this, 'access', _54 => _54.root, 'optionalAccess', _55 => _55.querySelector, 'call', _56 => _56("link[data-remote-components-reset]")])) {
+          _optionalChain([this, 'access', _57 => _57.root, 'access', _58 => _58.querySelector, 'call', _59 => _59("link[data-remote-components-reset]"), 'optionalAccess', _60 => _60.remove, 'call', _61 => _61()]);
         }
       };
       if (!this.reactRoot) {
@@ -2802,18 +497,18 @@ if (typeof HTMLElement !== "undefined") {
       const {
         self,
         createFromReadableStream,
-        nextClientPagesLoader: nextClientPagesLoader2,
+        nextClientPagesLoader,
         preloadScripts
       } = await getRuntime(
         metadataObj.runtime,
-        url ?? new URL(window.location.href),
+        effectiveUrl,
         this.bundle,
         {
-          react: async () => (await import("react")).default,
-          "react/jsx-dev-runtime": async () => (await import("react/jsx-dev-runtime")).default,
-          "react/jsx-runtime": async () => (await import("react/jsx-runtime")).default,
-          "react-dom": async () => (await import("react-dom")).default,
-          "react-dom/client": async () => (await import("react-dom/client")).default
+          react: async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("react")))).default,
+          "react/jsx-dev-runtime": async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("react/jsx-dev-runtime")))).default,
+          "react/jsx-runtime": async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("react/jsx-runtime")))).default,
+          "react-dom": async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("react-dom")))).default,
+          "react-dom/client": async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("react-dom/client")))).default
         },
         remoteShared,
         resolveClientUrl
@@ -2826,7 +521,7 @@ if (typeof HTMLElement !== "undefined") {
       );
       if (!url) {
         url = new URL(
-          component.getAttribute("data-route") ?? "/",
+          _nullishCoalesce(component.getAttribute("data-route"), () => ( "/")),
           window.location.href
         );
       }
@@ -2856,30 +551,30 @@ if (typeof HTMLElement !== "undefined") {
         }
       };
       if (rsc) {
-        rsc.parentElement?.removeChild(rsc);
-        const rscName = `__remote_component_rsc_${escapeString(
+        _optionalChain([rsc, 'access', _62 => _62.parentElement, 'optionalAccess', _63 => _63.removeChild, 'call', _64 => _64(rsc)]);
+        const rscName = `__remote_component_rsc_${_chunkR4QFK5TNcjs.escapeString.call(void 0, 
           url.href
-        )}_${escapeString(this.name)}`;
+        )}_${_chunkR4QFK5TNcjs.escapeString.call(void 0, this.name)}`;
         const rscClone = document.createElement("script");
         rscClone.id = `${rscName}_rsc`;
-        rscClone.textContent = rsc.textContent?.replace(
+        rscClone.textContent = _nullishCoalesce(_optionalChain([rsc, 'access', _65 => _65.textContent, 'optionalAccess', _66 => _66.replace, 'call', _67 => _67(
           new RegExp(`self\\["${this.name}"\\]`, "g"),
           `self["${rscName}"]`
-        ) ?? "";
+        )]), () => ( ""));
         document.body.appendChild(rscClone);
         let cache;
         const RemoteComponentFromReadableStream = ({
           name,
           initial
         }) => {
-          const stream = createRSCStream(
+          const stream = _chunkER73O65Fcjs.createRSCStream.call(void 0, 
             rscName,
-            self[rscName] ?? [`0:[null]
-`]
+            _nullishCoalesce(self[rscName], () => ( [`0:[null]
+`]))
           );
-          const Component = cache ?? // cache the component to avoid reloading the RSC flight data
-          (cache = createFromReadableStream(stream));
-          (0, import_react.useLayoutEffect)(() => {
+          const Component = _nullishCoalesce(cache, () => ( // cache the component to avoid reloading the RSC flight data
+          (cache = createFromReadableStream(stream))));
+          _react.useLayoutEffect.call(void 0, () => {
             if (self[name]) {
               delete self[name];
             }
@@ -2891,21 +586,21 @@ if (typeof HTMLElement !== "undefined") {
             applyReset();
             if (!initial) {
               doAttachStyles().catch((e) => {
-                logError("HtmlHost", "Error attaching styles.", e);
+                _chunkRUWR74XQcjs.logError.call(void 0, "HtmlHost", "Error attaching styles.", e);
               });
             }
             if (isCurrentLoad()) {
               this.hostState.stage = "loaded";
             }
-            this.dispatchLifecycleEvent("load", { src: this.src });
+            this.emitter.load(_nullishCoalesce(this.src, () => ( "")));
           }, [initial, name]);
           return Component;
         };
         if (this.reactRoot) {
           const root = this.reactRoot;
-          (0, import_react.startTransition)(() => {
+          _react.startTransition.call(void 0, () => {
             root.render(
-              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
                 RemoteComponentFromReadableStream,
                 {
                   initial: false,
@@ -2916,41 +611,39 @@ if (typeof HTMLElement !== "undefined") {
           });
           return;
         }
-        this.reactRoot = (0, import_client.hydrateRoot)(
+        this.reactRoot = _client.hydrateRoot.call(void 0, 
           // hydrateRoot expects a document or element, but it works for the shadow DOM too
           // @ts-expect-error support for shadow DOM
           this.root,
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(RemoteComponentFromReadableStream, { initial: true, name: this.name })
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, RemoteComponentFromReadableStream, { initial: true, name: this.name })
         );
       } else if (nextData) {
-        const { Component, App } = nextClientPagesLoader2(
+        const { Component, App } = nextClientPagesLoader(
           this.bundle,
-          nextData.page ?? "/",
+          _nullishCoalesce(nextData.page, () => ( "/")),
           this.root
         );
         if (Component) {
           const RemoteComponentFromNext = ((NextApp, NextComponent, remoteComponent = this) => function RemoteComponentNext({ initial }) {
-            (0, import_react.useLayoutEffect)(() => {
+            _react.useLayoutEffect.call(void 0, () => {
               doCleanup();
               if (!initial) {
                 applyReset();
                 doAttachStyles().catch((e) => {
-                  logError("HtmlHost", "Error attaching styles.", e);
+                  _chunkRUWR74XQcjs.logError.call(void 0, "HtmlHost", "Error attaching styles.", e);
                 });
               }
               if (isCurrentLoad()) {
                 remoteComponent.hostState.stage = "loaded";
               }
-              remoteComponent.dispatchLifecycleEvent("load", {
-                src: remoteComponent.src
-              });
+              remoteComponent.emitter.load(_nullishCoalesce(remoteComponent.src, () => ( "")));
             }, [initial, remoteComponent]);
-            return NextApp ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(NextApp, { Component: NextComponent, ...nextData.props }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(NextComponent, { ...nextData.props });
+            return NextApp ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, NextApp, { Component: NextComponent, ...nextData.props }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, NextComponent, { ...nextData.props });
           })(App, Component, this);
           if (this.reactRoot) {
             const root = this.reactRoot;
-            (0, import_react.startTransition)(() => {
-              root.render(/* @__PURE__ */ (0, import_jsx_runtime2.jsx)(RemoteComponentFromNext, { initial: false }));
+            _react.startTransition.call(void 0, () => {
+              root.render(/* @__PURE__ */ _jsxruntime.jsx.call(void 0, RemoteComponentFromNext, { initial: false }));
               doCleanup();
               if (isCurrentLoad()) {
                 this.hostState.stage = "loaded";
@@ -2958,24 +651,24 @@ if (typeof HTMLElement !== "undefined") {
             });
             return;
           }
-          this.reactRoot = (0, import_client.hydrateRoot)(
+          this.reactRoot = _client.hydrateRoot.call(void 0, 
             // hydrateRoot expects a document or element, but it works for the shadow DOM too
             // @ts-expect-error support for shadow DOM
             this.root,
-            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(RemoteComponentFromNext, { initial: true })
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, RemoteComponentFromNext, { initial: true })
           );
         }
         if (this.fouc) {
           this.root.removeChild(this.fouc);
         }
-      } else if (getNamespace().mountFns[url.href]) {
+      } else if (_chunk7MVFHOIPcjs.getNamespace.call(void 0, ).mountFns[url.href]) {
         await Promise.all(
-          Array.from(getNamespace().mountFns[url.href] ?? []).map(
+          Array.from(_nullishCoalesce(_chunk7MVFHOIPcjs.getNamespace.call(void 0, ).mountFns[url.href], () => ( []))).map(
             async (mount) => {
               try {
                 await mount(this.root);
               } catch (e) {
-                logError(
+                _chunkRUWR74XQcjs.logError.call(void 0, 
                   "HtmlHost",
                   `Error while calling mount() for Remote Component from ${url.href}.`,
                   e
@@ -2984,9 +677,9 @@ if (typeof HTMLElement !== "undefined") {
             }
           )
         );
-        this.dispatchLifecycleEvent("load", { src: this.src });
+        this.emitter.load(_nullishCoalesce(this.src, () => ( "")));
       } else {
-        this.dispatchLifecycleEvent("load", { src: this.src });
+        this.emitter.load(_nullishCoalesce(this.src, () => ( "")));
       }
       if (isCurrentLoad()) {
         this.hostState.stage = "loaded";
@@ -2996,13 +689,12 @@ if (typeof HTMLElement !== "undefined") {
   customElements.define("remote-component", RemoteComponent);
 }
 function registerSharedModules(modules = {}) {
-  const ns = getNamespace();
+  const ns = _chunk7MVFHOIPcjs.getNamespace.call(void 0, );
   Object.entries(modules).forEach(([key, value]) => {
     ns.hostSharedModules[key] = value;
   });
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  registerSharedModules
-});
+
+
+exports.registerSharedModules = registerSharedModules;
 //# sourceMappingURL=html.cjs.map