remote-components 0.3.5 → 0.3.7

package/dist/host/nextjs/app/client-only.js

@@ -1,399 +1,31 @@
 "use client";
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 });
-};
-
-// src/utils/constants.ts
-var RC_PROTECTED_REMOTE_FETCH_PATHNAME, MISSING_SHARED_MODULES_MESSAGE, CORS_DOCS_URL;
-var init_constants = __esm({
-  "src/utils/constants.ts"() {
-    "use strict";
-    RC_PROTECTED_REMOTE_FETCH_PATHNAME = "/rc-fetch-protected-remote";
-    MISSING_SHARED_MODULES_MESSAGE = "Remote Components shared modules not found. Did you forget to wrap your config with `withRemoteComponentsConfig` on both host and remote?";
-    CORS_DOCS_URL = "https://vercel.com/docs/remote-components/concepts/cors-external-urls#accessing-cross-site-protected-remote-components";
-  }
-});
-
-// src/host/defaults/shared.ts
-var shared;
-var init_shared = __esm({
-  "src/host/defaults/shared.ts"() {
-    "use strict";
-    init_constants();
-    shared = {
-      __remote_components_missing_shared__: () => Promise.reject(new Error(MISSING_SHARED_MODULES_MESSAGE))
-    };
-  }
-});
-
-// src/host/defaults/app.ts
-var app_exports = {};
-__export(app_exports, {
-  shared: () => shared
-});
-var init_app = __esm({
-  "src/host/defaults/app.ts"() {
-    "use strict";
-    init_shared();
-  }
-});
+import {
+  ConsumeRemoteComponent
+} from "../../../chunk-GBFUPMMI.js";
+import {
+  bindResolveClientUrl
+} from "../../../chunk-NZAB7REE.js";
+import "../../../chunk-SZFCBE54.js";
+import "../../../chunk-QKB74MLO.js";
+import "../../../chunk-52BJ7VFA.js";
+import "../../../chunk-LQ7VQ74E.js";
+import {
+  createRemoteImageLoader,
+  getScope
+} from "../../../chunk-SJM7AAGU.js";
+import "../../../chunk-D5GNZB6O.js";
+import {
+  logWarn
+} from "../../../chunk-S2A4TFLS.js";
+import "../../../chunk-GAXJTFBV.js";
+import "../../../chunk-X6YKUJKH.js";
+import "../../../chunk-ENYGL5CO.js";
 
 // src/host/nextjs/app-client-only.tsx
-import { useMemo as useMemo3 } from "react";
+import { useMemo } from "react";
 
 // src/host/nextjs/image-shared.ts
 import { createElement, forwardRef } from "react";
-
-// 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 attrToProp = {
-  fetchpriority: "fetchPriority",
-  crossorigin: "crossOrigin",
-  imagesrcset: "imageSrcSet",
-  imagesizes: "imageSizes",
-  srcset: "srcSet"
-};
-
-// src/runtime/constants.ts
-var DEFAULT_BUNDLE_NAME = "__vercel_remote_bundle";
-var DEFAULT_COMPONENT_NAME = "__vercel_remote_component";
-var DEFAULT_ROUTE = "/";
-var RUNTIME_WEBPACK = "webpack";
-var RUNTIME_TURBOPACK = "turbopack";
-var RUNTIME_SCRIPT = "script";
-function getBundleKey(bundle) {
-  return escapeString(bundle);
-}
-
-// src/runtime/namespace.ts
-var SHADOW_ROOT_PREFIX = "__remote_components_shadowroot_";
-var 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" }
-];
-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;
-}
-
-// src/runtime/patterns.ts
-var REMOTE_COMPONENT_REGEX = /(?<prefix>.*?)\[(?<bundle>[^\]]+)\](?:%20| )(?<id>.+)/;
-var NEXT_BUNDLE_PATH_RE = /\/_next\/\[.+\](?:%20| )/;
-var DOUBLE_SLASH_RE = /(?<!:)\/\//g;
-function collapseDoubleSlashes(path) {
-  return path.replace(DOUBLE_SLASH_RE, "/");
-}
-
-// src/utils/logger.ts
-init_constants();
-
-// src/runtime/url/protected-rc-fallback.ts
-init_constants();
-function isProxiedUrl(url) {
-  try {
-    return new URL(url, location.href).pathname === RC_PROTECTED_REMOTE_FETCH_PATHNAME;
-  } catch {
-    return false;
-  }
-}
-
-// 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;
-}
-
-// src/utils/error.ts
-init_constants();
-var RemoteComponentsError = class extends Error {
-  code = "REMOTE_COMPONENTS_ERROR";
-  constructor(message, options) {
-    super(message, options);
-    this.name = "RemoteComponentsError";
-  }
-};
-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}`
-  );
-}
-
-// src/utils/logger.ts
-var PREFIX = "remote-components";
-var DEBUG = typeof window !== "undefined" && localStorage.getItem("RC_DEBUG") === "true" || typeof process !== "undefined" && process.env.RC_DEBUG === "true";
-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 {
-  }
-}
-
-// 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: "" };
-}
-
-// 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;
-}
-
-// 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;
-}
-
-// src/host/nextjs/image-shared.ts
 function resolveForBundle(unbound, bundle) {
   if (!unbound)
     return void 0;
@@ -445,8 +77,8 @@ function createImageLoaderSharedEntries({
 // src/host/nextjs/shared-import.ts
 async function tryImportShared() {
   try {
-    const { shared: shared2 } = await Promise.resolve().then(() => (init_app(), app_exports));
-    return shared2;
+    const { shared } = await import("../../../app-63L5THIQ.js");
+    return shared;
   } catch {
     return {};
   }
@@ -455,2501 +87,6 @@ async function tryImportShared() {
 // src/host/nextjs/app-client-only.tsx
 import { RemoteComponentsContext } from "#internal/host/react/context";
 
-// src/host/react/index.tsx
-import {
-  startTransition,
-  useEffect,
-  useId,
-  useLayoutEffect as useLayoutEffect2,
-  useMemo as useMemo2,
-  useRef as useRef2,
-  useState as useState2
-} from "react";
-import { createPortal } from "react-dom";
-import { useRemoteComponentsContext as useRemoteComponentsContext2 } from "#internal/host/react/context";
-
-// 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"
-  };
-}
-
-// 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/lifecycle.ts
-function makeReactEmitter(callbacks) {
-  return {
-    beforeLoad(src) {
-      callbacks.onBeforeLoad?.(src);
-    },
-    load(src) {
-      callbacks.onLoad?.(src);
-    },
-    error(error, _src) {
-      callbacks.onError?.(error);
-    },
-    change(info) {
-      callbacks.onChange?.(info);
-    }
-  };
-}
-
-// src/host/shared/polyfill.tsx
-import { jsx } from "react/jsx-runtime";
-function sharedPolyfills(shared2, resolveClientUrl) {
-  const hostShared = getNamespace().hostSharedModules;
-  const polyfill = {
-    "next/dist/client/components/navigation": hostShared["next/navigation"] ?? shared2?.["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"] ?? shared2?.["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__ */ 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"] ?? shared2?.["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"] ?? shared2?.["next/dist/shared/lib/image-loader"] ?? ((bundle) => Promise.resolve({
-      default: createRemoteImageLoader(bundle, resolveClientUrl),
-      __esModule: true
-    })),
-    "next/dist/client/script": hostShared["next/script"] ?? shared2?.["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"] ?? shared2?.["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;
-}
-
-// src/host/shared/shared-module-resolver.ts
-var 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"
-};
-var VENDOR_SHARED = Object.fromEntries(
-  Object.entries(CORE_REACT_PATH_MAP).filter(([key]) => key !== "react-dom/client").map(([key, path]) => [key, `'${path}'`])
-);
-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;
-}
-
-// 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";
-
-// 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/metadata.ts
-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)
-  };
-}
-
-// src/runtime/html/parse-remote-html.ts
-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/runtime/loaders/component-loader.ts
-import * as React from "react";
-import * as JSXDevRuntime from "react/jsx-dev-runtime";
-import * as JSXRuntime from "react/jsx-runtime";
-import * as ReactDOM from "react-dom";
-import * as ReactDOMClient from "react-dom/client";
-
-// src/config/webpack/apply-shared-modules.ts
-var DEDUPLICATION_SKIPPED = "shared module deduplication skipped. The remote may load its own copy of shared dependencies.";
-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] = (module) => {
-            module.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__ ?? {})}`
-    );
-  }
-}
-
-// 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 };
-}
-
-// src/runtime/rsc.ts
-import { ReadableStream } from "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 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/rsc-imports.ts
-async function importRSCClientBrowser() {
-  try {
-    return await import("next/dist/compiled/react-server-dom-webpack/client.browser");
-  } catch {
-    const mod = await import("react-server-dom-webpack/client.browser");
-    return mod.default ?? mod;
-  }
-}
-
-// src/runtime/turbopack/patterns.ts
-var MODULE_ID_PATTERN = '"[^"]+"|[0-9]+';
-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 REMOTE_SHARED_MARKER_RE = /(?:self|[a-z])\.TURBOPACK_REMOTE_SHARED/;
-var REMOTE_SHARED_ASSIGNMENT_RE = new RegExp(
-  `\\.TURBOPACK_REMOTE_SHARED\\s*=\\s*await (?:__turbopack_context__|[a-z])\\.A\\((?<sharedModuleId>${MODULE_ID_PATTERN})\\)`
-);
-var ASYNC_MODULE_LOADER_RE = new RegExp(
-  `(?:__turbopack_context__|[a-z])\\.A\\((?<asyncSharedModuleId>${MODULE_ID_PATTERN})\\)`
-);
-var ASYNC_MODULE_CALLBACK_RE = new RegExp(
-  `(?:parentImport|[a-z])\\((?<sharedModuleId>${MODULE_ID_PATTERN})\\)`
-);
-var 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);
-  }
-}
-
-// src/runtime/turbopack/shared-modules.ts
-var 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).";
-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: shared2 } = await sharedModuleInitializer;
-      const sharedModuleIds = extractSharedModuleIds(shared2, scope);
-      logDebug(
-        "SharedModules",
-        `Resolved shared modules for scope="${scope.scopedName}": ${JSON.stringify(sharedModuleIds)}`
-      );
-      return Promise.all(
-        Object.entries(sharedModuleIds).map(async ([id, module]) => {
-          if (hostShared[module]) {
-            scope.sharedModules[id] = await hostShared[module](scope.name);
-          } else {
-            logError(
-              "SharedModules",
-              `Host shared module "${module}" 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, module]) => {
-      if (hostShared[module]) {
-        const normalizedId = id.replace("[app-ssr]", "[app-client]");
-        scope.sharedModules[normalizedId] = await hostShared[module](
-          scope.name
-        );
-      } else {
-        logError(
-          "SharedModules",
-          `Shared module "${module}" not found for "${scope.name}". ${DEDUPLICATION_WARNING}`
-        );
-      }
-    })
-  );
-}
-function extractSharedModuleIds(shared2, scope) {
-  return Object.entries(shared2).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;
-}
-
-// 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
-  };
-}
-
-// 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 }
-        );
-      }
-    }
-  };
-}
-
-// 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);
-      });
-    })
-  );
-}
-
-// src/runtime/loaders/component-loader.ts
-async function loadRemoteComponent({
-  url,
-  name,
-  rscName,
-  bundle,
-  route = "/",
-  runtime = "webpack",
-  data,
-  nextData,
-  scripts = [],
-  shared: shared2 = Promise.resolve({}),
-  remoteShared = {},
-  container,
-  resolveClientUrl
-}) {
-  try {
-    if (runtime === "webpack") {
-      const self = globalThis;
-      if (!self.__DISABLE_WEBPACK_EXEC__) {
-        self.__DISABLE_WEBPACK_EXEC__ = {};
-      }
-      self.__DISABLE_WEBPACK_EXEC__[bundle] = true;
-      await loadScripts(scripts, resolveClientUrl);
-    }
-    const hostShared = await shared2;
-    logDebug(
-      "ComponentLoader",
-      `loadRemoteComponent: bundle="${bundle}", name="${name}"`
-    );
-    logDebug(
-      "ComponentLoader",
-      `Host shared modules available: ${Object.keys(hostShared)}`
-    );
-    logDebug(
-      "ComponentLoader",
-      `Remote shared modules requested: ${JSON.stringify(remoteShared)}`
-    );
-    const scope = await setupRemoteScope(
-      runtime,
-      scripts,
-      url,
-      bundle,
-      resolveClientUrl
-    );
-    if (runtime === "turbopack") {
-      await initializeSharedModules(
-        scope,
-        buildCoreShared(hostShared),
-        remoteShared
-      );
-    }
-    if (bundle) {
-      const resolve = await buildWebpackResolve(
-        hostShared,
-        remoteShared,
-        bundle,
-        {
-          "/react/index.js": React,
-          "/react/jsx-dev-runtime.js": JSXDevRuntime,
-          "/react/jsx-runtime.js": JSXRuntime,
-          "/react-dom/index.js": ReactDOM,
-          "/react-dom/client.js": ReactDOMClient
-        },
-        "ComponentLoader"
-      );
-      applySharedModules(bundle, resolve);
-    } else {
-      logWarn(
-        "ComponentLoader",
-        "No bundle specified, skipping shared module setup"
-      );
-    }
-    if (data.length > 0) {
-      return await loadRSCComponent(rscName ?? name, data);
-    } else if (nextData) {
-      return loadNextPagesComponent(bundle, route, nextData, name, container);
-    }
-    return loadRSCComponent(rscName ?? name, [`0:[null]
-`]);
-  } catch (error) {
-    return {
-      component: null,
-      error: new RemoteComponentsError(
-        `Failed to load remote component "${name}".`,
-        {
-          cause: error instanceof Error ? error : new Error(String(error))
-        }
-      )
-    };
-  }
-}
-async function loadRSCComponent(rscName, data) {
-  const { createFromReadableStream } = await importRSCClientBrowser();
-  if (typeof createFromReadableStream !== "function") {
-    throw new RemoteComponentsError(
-      'Failed to import "react-server-dom-webpack". Is Next.js installed correctly?'
-    );
-  }
-  const stream = createRSCStream(rscName, data);
-  const component = createFromReadableStream(stream);
-  return { component };
-}
-function loadNextPagesComponent(bundle, route, nextData, name, container) {
-  const { Component, App } = nextClientPagesLoader(bundle, route, container);
-  if (!Component) {
-    throw new RemoteComponentsError(
-      `Remote Component "${name}" is trying to load the component for route "${route}" but it is not available.`
-    );
-  }
-  const component = App ? React.createElement(App, { Component, ...nextData.props }) : React.createElement(Component, nextData.props);
-  return { component };
-}
-
-// 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()
-    }
-  );
-}
-
-// src/host/shared/pipeline.ts
-function preparePipeline(input) {
-  const parser = new DOMParser();
-  const doc = parser.parseFromString(input.html, "text/html");
-  const parsed = parseRemoteComponentDocument(doc, input.name, input.url);
-  const remoteShared = input.remoteShared ?? parsed.remoteShared;
-  if ("__remote_components_missing_shared__" in remoteShared) {
-    throw new RemoteComponentsError(
-      remoteShared.__remote_components_missing_shared__
-    );
-  }
-  applyOriginToNodes(doc, input.url, input.resolveClientUrl);
-  const scriptDescriptors = buildScriptDescriptors(parsed.scripts, input.url);
-  return { doc, parsed, scriptDescriptors };
-}
-async function loadPrepared(input) {
-  const { prepared, url, signal, resolveClientUrl, container, rscName } = input;
-  const { doc, parsed, scriptDescriptors } = prepared;
-  if (signal.aborted) {
-    return { status: "aborted" };
-  }
-  const userShared = await input.shared;
-  if (signal.aborted) {
-    return { status: "aborted" };
-  }
-  if (parsed.isRemoteComponent) {
-    return loadStaticPath({
-      parsed,
-      doc,
-      url,
-      resolveClientUrl
-    });
-  }
-  return loadDynamicPath({
-    parsed,
-    doc,
-    url,
-    scriptDescriptors,
-    shared: userShared,
-    resolveClientUrl,
-    container,
-    rscName
-  });
-}
-function buildScriptDescriptors(scripts, url) {
-  return scripts.map((script) => {
-    const scriptSrc = script.getAttribute("data-src") || script.getAttribute("src") || script.src;
-    const { prefix, id: path } = REMOTE_COMPONENT_REGEX.exec(scriptSrc)?.groups ?? {
-      prefix: void 0,
-      id: scriptSrc
-    };
-    return {
-      src: new URL(collapseDoubleSlashes(`${prefix ?? ""}${path}`), url).href
-    };
-  });
-}
-async function loadStaticPath(input) {
-  const { parsed, doc, url, resolveClientUrl } = input;
-  const scripts = Array.from(
-    parsed.component.querySelectorAll("script")
-  );
-  const { mount, unmount } = await loadStaticRemoteComponent(
-    scripts,
-    url,
-    resolveClientUrl
-  );
-  return {
-    status: "static",
-    mount,
-    unmount,
-    metadata: parsed.metadata,
-    parsed,
-    doc
-  };
-}
-async function loadDynamicPath(input) {
-  const {
-    parsed,
-    doc,
-    url,
-    scriptDescriptors,
-    shared: shared2,
-    resolveClientUrl,
-    container
-  } = input;
-  const rscName = input.rscName ?? (parsed.rsc ? `__remote_component_rsc_${escapeString(url.href)}_${escapeString(parsed.name)}` : void 0);
-  const rscData = parsed.rsc ? (parsed.rsc.textContent || "").split("\n").filter(Boolean) : [];
-  const result = await loadRemoteComponent({
-    url,
-    name: parsed.name,
-    rscName,
-    bundle: parsed.metadata.bundle,
-    route: parsed.metadata.route,
-    runtime: parsed.metadata.runtime,
-    data: rscData,
-    nextData: parsed.nextData,
-    scripts: scriptDescriptors,
-    shared: buildHostShared(shared2, resolveClientUrl),
-    remoteShared: parsed.remoteShared,
-    container,
-    resolveClientUrl
-  });
-  if (result.error) {
-    return { status: "error", error: result.error };
-  }
-  return {
-    status: "loaded",
-    component: result.component,
-    metadata: parsed.metadata,
-    parsed,
-    doc
-  };
-}
-
-// 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/runtime/html/set-attributes-from-props.ts
-var DOMAttributeNames = {
-  acceptCharset: "accept-charset",
-  className: "class",
-  htmlFor: "for",
-  httpEquiv: "http-equiv",
-  noModule: "noModule"
-};
-var ignoreProps = [
-  "onLoad",
-  "onReady",
-  "dangerouslySetInnerHTML",
-  "children",
-  "onError",
-  "strategy",
-  "stylesheets"
-];
-function isBooleanScriptAttribute(attr) {
-  return ["async", "defer", "noModule"].includes(attr);
-}
-function setAttributesFromProps(el, props) {
-  for (const [p, value] of Object.entries(props)) {
-    if (!Object.hasOwn(props, p))
-      continue;
-    if (ignoreProps.includes(p))
-      continue;
-    if (value === void 0) {
-      continue;
-    }
-    const attr = DOMAttributeNames[p] || p.toLowerCase();
-    if (el.tagName === "SCRIPT" && isBooleanScriptAttribute(attr)) {
-      el[attr] = Boolean(value);
-    } else {
-      el.setAttribute(attr, String(value));
-    }
-    if (value === false || el.tagName === "SCRIPT" && isBooleanScriptAttribute(attr) && (!value || value === "false")) {
-      el.setAttribute(attr, "");
-      el.removeAttribute(attr);
-    }
-  }
-}
-
-// src/host/react/hooks/use-resolve-client-url.ts
-import { useMemo } from "react";
-import { useRemoteComponentsContext } from "#internal/host/react/context";
-function useResolveClientUrl(prop, urlHref) {
-  const { resolveClientUrl: contextValue } = useRemoteComponentsContext();
-  const raw = prop ?? contextValue;
-  return useMemo(() => bindResolveClientUrl(raw, urlHref), [raw, urlHref]);
-}
-
-// src/host/react/hooks/use-shadow-root.ts
-import { useLayoutEffect, useRef, useState } from "react";
-function useShadowRoot({
-  isolate,
-  mode,
-  keySuffix
-}) {
-  const shadowRootContainerRef = useRef(null);
-  const [shadowRoot, setShadowRoot] = useState(() => {
-    const shadowRoots = getNamespace().shadowRoots;
-    const ssrShadowRoot = typeof document !== "undefined" ? document.querySelector(
-      `[data-remote-component-id="shadowroot_${keySuffix}"]`
-    )?.shadowRoot ?? shadowRoots[keySuffix] ?? null : null;
-    shadowRoots[keySuffix] = null;
-    return ssrShadowRoot;
-  });
-  useLayoutEffect(() => {
-    const shadowRoots = getNamespace().shadowRoots;
-    if (isolate !== false && typeof document !== "undefined" && (!shadowRoot || !shadowRoot.isConnected)) {
-      let shadowRootElement = null;
-      const element = document.querySelector(
-        `[data-remote-component-id="shadowroot_${keySuffix}"]`
-      );
-      shadowRootElement = shadowRoots[keySuffix] ?? element?.shadowRoot ?? null;
-      if (!shadowRootElement && element) {
-        try {
-          shadowRootElement = element.attachShadow({ mode });
-          shadowRoots[keySuffix] = shadowRootElement;
-        } catch {
-        }
-      }
-      if (shadowRootElement) {
-        shadowRootElement.querySelectorAll("*:not(link)").forEach((node) => {
-          node.remove();
-        });
-        setShadowRoot(shadowRootElement);
-      }
-    } else if (isolate === false && shadowRoot) {
-      shadowRoots[keySuffix] = null;
-      setShadowRoot(null);
-    }
-  }, [isolate, shadowRoot, mode, keySuffix]);
-  return { shadowRoot, shadowRootContainerRef };
-}
-
-// src/host/react/utils/extract-remote-html.ts
-var DUMMY_FALLBACK = "http://remote-components-dummy-fallback";
-function getRemoteComponentHtml(html) {
-  if (typeof document === "undefined")
-    return html;
-  const parser = new DOMParser();
-  const temp = parser.parseFromString(html, "text/html");
-  const ssrRemoteComponentContainer = temp.querySelector(
-    'div[id^="__REMOTE_COMPONENT"]'
-  );
-  if (ssrRemoteComponentContainer) {
-    return ssrRemoteComponentContainer.innerHTML;
-  }
-  const remoteComponentContainer = temp.querySelectorAll(
-    `div[data-bundle][data-route][data-runtime][id^="${DEFAULT_COMPONENT_NAME}"],div[data-bundle][data-route],div#__next,remote-component:not([src])`
-  );
-  if (remoteComponentContainer.length > 0) {
-    return `${Array.from(temp.querySelectorAll("link,script")).map((link) => link.outerHTML).join("")}${Array.from(remoteComponentContainer).map((container) => container.outerHTML).join("")}`;
-  }
-  return "";
-}
-
-// src/host/react/index.tsx
-import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
-import { createElement as createElement3 } from "react";
-function ConsumeRemoteComponent({
-  src,
-  isolate,
-  mode = "open",
-  reset,
-  credentials: credentialsProp,
-  name: nameProp = DEFAULT_COMPONENT_NAME,
-  shared: sharedProp,
-  children,
-  onBeforeLoad,
-  onLoad,
-  onError,
-  onChange,
-  onRequest,
-  onResponse,
-  resolveClientUrl: resolveClientUrlProp
-}) {
-  const instanceId = useId();
-  const { credentials: contextCredentials, shared: contextShared } = useRemoteComponentsContext2();
-  const credentials = credentialsProp ?? contextCredentials ?? "same-origin";
-  const shared2 = sharedProp ?? contextShared ?? {};
-  const emitter = useMemo2(
-    () => makeReactEmitter({ onBeforeLoad, onLoad, onError, onChange }),
-    [onBeforeLoad, onLoad, onError, onChange]
-  );
-  const name = useMemo2(
-    () => resolveNameFromSrc(src, nameProp),
-    [src, nameProp]
-  );
-  const [data, setData] = useState2(
-    null
-  );
-  const url = useMemo2(() => getClientOrServerUrl(src, DUMMY_FALLBACK), [src]);
-  const resolveClientUrl = useResolveClientUrl(resolveClientUrlProp, url.href);
-  const id = url.origin === (typeof location !== "undefined" ? location.origin : DUMMY_FALLBACK) ? url.pathname : url.href;
-  const keySuffix = `${escapeString(id)}_${escapeString(
-    data?.name ?? name
-  )}_${escapeString(instanceId)}`;
-  const [remoteComponent, setRemoteComponent] = useState2(null);
-  const { shadowRoot, shadowRootContainerRef } = useShadowRoot({
-    isolate,
-    mode,
-    keySuffix
-  });
-  const htmlRef = useRef2(
-    typeof document !== "undefined" ? document.querySelector(
-      `[data-remote-component-id="shadowroot_${keySuffix}"]`
-    )?.shadowRoot?.innerHTML ?? document.getElementById(`__REMOTE_COMPONENT${name}`)?.innerHTML ?? document.querySelector(`div[data-bundle][data-route][id^="${name}"]`)?.innerHTML ?? document.querySelector("div[data-bundle][data-route]")?.innerHTML : null
-  );
-  const endTemplateRef = useRef2(null);
-  const childrenRef = useRef2(
-    typeof document !== "undefined" ? (() => {
-      let el = document.querySelector(`template[id="${name}_start"]`);
-      const elements = [];
-      while (el && el.id !== `${name}_end`) {
-        if (el.id !== `${name}_start` && !el.getAttribute("data-remote-component")) {
-          elements.push(el);
-        }
-        el = el.nextElementSibling;
-      }
-      return elements;
-    })() : []
-  );
-  const hostStateRef = useRef2(createHostState());
-  const componentHydrationHtml = useRef2(null);
-  const prevRemoteComponentContainerRef = useRef2(null);
-  const unmountRef = useRef2(null);
-  useLayoutEffect2(() => {
-    return () => {
-      delete getNamespace().shadowRoots[keySuffix];
-    };
-  }, [keySuffix]);
-  useLayoutEffect2(() => {
-    if (childrenRef.current.length > 0 && remoteComponent) {
-      childrenRef.current.forEach((el) => {
-        el.remove();
-      });
-      childrenRef.current = [];
-    }
-  }, [remoteComponent]);
-  useLayoutEffect2(() => {
-    if (shadowRoot && remoteComponent) {
-      const resetStyles = shadowRoot.querySelectorAll(
-        "style[data-remote-components-reset]"
-      );
-      if (resetStyles.length > 1) {
-        resetStyles.forEach((style, index) => {
-          if (index > 0 && style.getAttribute("data-remote-components-reset") !== "react") {
-            style.remove();
-          }
-        });
-      }
-      htmlRef.current = null;
-      let el = shadowRoot.childNodes[0] ?? null;
-      while (el && (!("id" in el) || el.id !== `${name}_start`)) {
-        const nextEl = el.nextSibling;
-        if (el.nodeName !== "LINK" && el.nodeName !== "STYLE") {
-          el.parentNode?.removeChild(el);
-        }
-        el = nextEl;
-      }
-    }
-  }, [shadowRoot, remoteComponent, name]);
-  useEffect(() => {
-    if (src && src !== hostStateRef.current.prevSrc) {
-      const previousSrc = hostStateRef.current.prevSrc;
-      const previousName = hostStateRef.current.prevName;
-      hostStateRef.current.prevSrc = src;
-      if (previousSrc !== null) {
-        htmlRef.current = null;
-      }
-      hostStateRef.current.abortController?.abort();
-      hostStateRef.current.abortController = new AbortController();
-      const { signal } = hostStateRef.current.abortController;
-      emitter.beforeLoad(src);
-      hostStateRef.current.stage = "loading";
-      startTransition(async () => {
-        try {
-          let html = getRemoteComponentHtml(
-            htmlRef.current ?? (endTemplateRef.current?.previousElementSibling?.tagName === "div" ? endTemplateRef.current.previousElementSibling.innerHTML : "")
-          );
-          if (!html && src) {
-            const fetchInit = {
-              credentials
-            };
-            const resolvedUrl = new URL(
-              resolveClientUrl?.(url.href) ?? url.href,
-              location.href
-            );
-            const res = await fetchWithHooks(resolvedUrl, fetchInit, {
-              onRequest,
-              onResponse,
-              abortController: hostStateRef.current.abortController
-            });
-            if (!res || !res.ok) {
-              throw await errorFromFailedFetch(url.href, resolvedUrl, res);
-            }
-            const remoteHtml = await res.text();
-            if (signal.aborted)
-              return;
-            htmlRef.current = remoteHtml;
-            html = getRemoteComponentHtml(remoteHtml);
-          }
-          if (signal.aborted)
-            return;
-          const userShared = await shared2;
-          if (signal.aborted)
-            return;
-          const prepared = preparePipeline({
-            html,
-            name,
-            url,
-            shared: userShared,
-            resolveClientUrl
-          });
-          const { doc, parsed } = prepared;
-          const {
-            component,
-            name: remoteName,
-            isRemoteComponent,
-            metadata,
-            rsc,
-            remoteShared,
-            links: linkElements
-          } = parsed;
-          if (hostStateRef.current.prevIsRemoteComponent) {
-            if (shadowRoot) {
-              shadowRoot.innerHTML = "";
-            }
-            const prevUrl = hostStateRef.current.prevUrl;
-            if (prevUrl && getNamespace().unmountFns[prevUrl.href]) {
-              const unmountPromises = Promise.all(
-                Array.from(unmountRef.current ?? []).map(
-                  async (unmount) => unmount(
-                    shadowRoot ?? prevRemoteComponentContainerRef.current
-                  )
-                )
-              );
-              unmountRef.current = null;
-              await unmountPromises;
-            }
-          }
-          hostStateRef.current.prevIsRemoteComponent = isRemoteComponent;
-          hostStateRef.current.prevUrl = url;
-          hostStateRef.current.prevName = remoteName;
-          const links = linkElements.map((link) => ({
-            href: new URL(link.getAttribute("href") ?? link.href, url).href,
-            ...link.getAttributeNames().reduce((acc, key) => {
-              if (key !== "href") {
-                acc[attrToProp[key] ?? key] = link.getAttribute(key) ?? "";
-              }
-              return acc;
-            }, {})
-          }));
-          const inlineScripts = (isRemoteComponent ? component : doc).querySelectorAll(
-            "script:not([src]):not([data-src]):not([id*='_rsc']):not([id='__NEXT_DATA__']):not([id='__REMOTE_NEXT_DATA__'])"
-          );
-          if (!isRemoteComponent) {
-            const self = globalThis;
-            const prevNextScripts = self.__next_s;
-            const nextScripts = [];
-            self.__next_s = nextScripts;
-            await Promise.all(
-              Array.from(inlineScripts).filter(
-                (script) => !(script.id.endsWith("_shared") && script.getAttribute("type") === "application/json" && typeof script.getAttribute(
-                  "data-remote-components-shared"
-                ) === "string")
-              ).map((script) => {
-                return new Promise((resolve) => {
-                  if (script.textContent && !script.textContent.includes("self.__next_f=") && !script.textContent.includes("self.__next_f.push")) {
-                    if (!script.getAttribute("type") || script.getAttribute("type") === "text/javascript" || script.getAttribute("type") === "application/javascript") {
-                      const newScript = document.createElement("script");
-                      const blob = new Blob([script.textContent], {
-                        type: "application/javascript"
-                      });
-                      const blobUrl = URL.createObjectURL(blob);
-                      newScript.onload = () => {
-                        resolve(void 0);
-                        URL.revokeObjectURL(blobUrl);
-                        newScript.remove();
-                      };
-                      newScript.onerror = () => {
-                        URL.revokeObjectURL(blobUrl);
-                        newScript.remove();
-                        resolve(void 0);
-                      };
-                      newScript.src = blobUrl;
-                      document.body.appendChild(newScript);
-                    } else {
-                      resolve(void 0);
-                      document.body.appendChild(script);
-                    }
-                  } else {
-                    resolve(void 0);
-                  }
-                });
-              })
-            );
-            nextScripts.forEach(([scriptSrc, props]) => {
-              const script = document.createElement("script");
-              if (scriptSrc) {
-                script.src = scriptSrc;
-              }
-              if (typeof props.children === "string") {
-                script.textContent = props.children;
-              }
-              setAttributesFromProps(script, props);
-              document.head.appendChild(script);
-            });
-            self.__next_s = prevNextScripts;
-          }
-          const rscName = rsc ? `__remote_component_rsc_${escapeString(id)}_${escapeString(
-            remoteName
-          )}` : void 0;
-          if (rsc) {
-            rsc.textContent = rsc.textContent?.replace(
-              new RegExp(`self\\["${remoteName}"\\]`, "g"),
-              `self["${rscName}"]`
-            ) ?? "";
-            document.body.appendChild(rsc);
-          }
-          const newData = {
-            ...metadata,
-            links,
-            remoteShared,
-            src: typeof src === "string" ? src : src.href,
-            serverUrl: url.href,
-            data: rsc ? (rsc.textContent || "").split("\n").filter(Boolean) : []
-          };
-          componentHydrationHtml.current = `${Array.from(
-            doc.querySelectorAll("link,style")
-          ).map((link) => link.outerHTML).join("")}${reset ? `<style data-remote-components-reset="">:host { all: initial; }</style>` : ""}${component.innerHTML}`;
-          if (isRemoteComponent) {
-            if (previousSrc !== void 0) {
-              emitter.change({
-                previousSrc: previousSrc ?? null,
-                nextSrc: src,
-                previousName,
-                nextName: remoteName
-              });
-            }
-            setData(newData);
-            if (shadowRoot) {
-              const shadowRootHtml = reset ? `<style data-remote-components-reset="">:host { all: initial; }</style>${component.innerHTML}` : component.innerHTML;
-              shadowRoot.innerHTML = shadowRootHtml;
-              htmlRef.current = null;
-              setRemoteComponent(null);
-              const { mount, unmount } = await loadStaticRemoteComponent(
-                Array.from(shadowRoot.querySelectorAll("script")),
-                url,
-                resolveClientUrl
-              );
-              unmountRef.current = unmount;
-              await Promise.all(
-                Array.from(mount).map((mountFn) => mountFn(shadowRoot))
-              );
-              emitter.load(src);
-            } else if (isolate === false) {
-              setRemoteComponent(
-                // TODO: remove wrapper div by converting HTML to RSC or React tree
-                /* @__PURE__ */ jsx2(
-                  "div",
-                  {
-                    dangerouslySetInnerHTML: { __html: component.innerHTML },
-                    ref: prevRemoteComponentContainerRef
-                  }
-                )
-              );
-              htmlRef.current = null;
-              const { mount, unmount } = await loadStaticRemoteComponent(
-                Array.from(component.querySelectorAll("script")),
-                url,
-                resolveClientUrl
-              );
-              unmountRef.current = unmount;
-              await Promise.all(
-                Array.from(mount).map(
-                  (mountFn) => mountFn(prevRemoteComponentContainerRef.current)
-                )
-              );
-              emitter.load(src);
-            }
-            hostStateRef.current.stage = "loaded";
-          } else {
-            const result = await loadPrepared({
-              prepared,
-              url,
-              signal,
-              shared: userShared,
-              resolveClientUrl,
-              container: shadowRoot,
-              rscName
-            });
-            if (rsc) {
-              rsc.remove();
-            }
-            setData(newData);
-            if (previousSrc !== void 0) {
-              emitter.change({
-                previousSrc: previousSrc ?? null,
-                nextSrc: src,
-                previousName,
-                nextName: remoteName
-              });
-            }
-            if (result.status === "aborted") {
-              return;
-            }
-            if (result.status === "error") {
-              hostStateRef.current.stage = "error";
-              setRemoteComponent(result.error);
-              emitter.error(result.error);
-            } else if (result.status === "loaded") {
-              hostStateRef.current.stage = "loaded";
-              setRemoteComponent(result.component);
-              emitter.load(src);
-            }
-          }
-        } catch (error) {
-          if (isAbortError(error)) {
-            hostStateRef.current.stage = "idle";
-            return;
-          }
-          hostStateRef.current.stage = "error";
-          setRemoteComponent(error);
-          emitter.error(error);
-        }
-      });
-    }
-  }, [
-    url,
-    src,
-    isolate,
-    credentials,
-    name,
-    shared2,
-    shadowRoot,
-    reset,
-    id,
-    emitter.beforeLoad,
-    emitter.load,
-    emitter.error,
-    emitter.change,
-    onRequest,
-    onResponse,
-    resolveClientUrl
-  ]);
-  if (remoteComponent instanceof Error) {
-    throw remoteComponent;
-  }
-  const metadataJson = /* @__PURE__ */ jsx2("script", { "data-remote-component": true, type: "application/json", children: JSON.stringify({
-    name: data?.name || name,
-    bundle: data?.bundle || "default",
-    route: data?.route || DEFAULT_ROUTE,
-    runtime: hostStateRef.current.prevIsRemoteComponent ? RUNTIME_SCRIPT : data?.runtime || RUNTIME_WEBPACK
-  }) });
-  const resetStyle = reset ? /* @__PURE__ */ jsx2("style", { "data-remote-components-reset": "react", children: `:host { all: initial; }` }) : null;
-  const linksToRender = data?.links?.map((link) => /* @__PURE__ */ createElement3(
-    "link",
-    {
-      ...link,
-      href: new URL(link.href, url).href,
-      key: JSON.stringify(link)
-    }
-  )) || null;
-  const componentToRender = /* @__PURE__ */ jsxs(Fragment, { children: [
-    resetStyle,
-    linksToRender,
-    remoteComponent ?? children
-  ] });
-  if (componentHydrationHtml.current && shadowRoot && !shadowRoot.innerHTML) {
-    shadowRoot.innerHTML = componentHydrationHtml.current;
-    componentHydrationHtml.current = null;
-    if (hostStateRef.current.prevIsRemoteComponent) {
-      loadStaticRemoteComponent(
-        Array.from(shadowRoot.querySelectorAll("script")),
-        url,
-        resolveClientUrl
-      ).then(({ mount }) => {
-        return Promise.all(
-          Array.from(mount).map((mountFn) => mountFn(shadowRoot))
-        );
-      }).then(() => {
-        if (src) {
-          emitter.load(src);
-        }
-      }).catch((e) => {
-        const error = new RemoteComponentsError(
-          `Error mounting remote component from "${url.href}"`,
-          {
-            cause: e
-          }
-        );
-        setRemoteComponent(error);
-        emitter.error(error);
-      });
-    }
-  }
-  if (isolate !== false) {
-    const shadowRemoteComponentHtml = shadowRoot?.querySelector(`#__REMOTE_COMPONENT${name}`) ?? shadowRoot?.querySelector("div[data-bundle][data-route]");
-    if (shadowRemoteComponentHtml) {
-      shadowRemoteComponentHtml.remove();
-    }
-    return /* @__PURE__ */ jsxs(Fragment, { children: [
-      metadataJson,
-      /* @__PURE__ */ jsxs(
-        "div",
-        {
-          "data-remote-component-id": `shadowroot_${keySuffix}`,
-          id: `shadowroot_${data?.name ?? name}`,
-          ref: shadowRootContainerRef,
-          children: [
-            typeof document === "undefined" ? (
-              // eslint-disable-next-line react/no-unknown-property
-              /* @__PURE__ */ jsxs("template", { shadowrootmode: mode, children: [
-                typeof document === "undefined" ? /* @__PURE__ */ jsx2(
-                  "div",
-                  {
-                    dangerouslySetInnerHTML: {
-                      __html: `<img
-      alt="" decoding="async" style="display:none"
-      src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw=="
-      onload="(function(el){
-        // Capture the shadow root during SSR hydration so the client-side
-        // useShadowRoot hook can find it.
-        const root = el.getRootNode();
-        globalThis.__remote_components_shadowroot_${keySuffix}=root;
-        el.parentElement.remove();
-      })(this)"
-    />`
-                    }
-                  }
-                ) : null,
-                resetStyle,
-                linksToRender,
-                children
-              ] })
-            ) : null,
-            shadowRoot && remoteComponent ? createPortal(
-              /* @__PURE__ */ jsxs(Fragment, { children: [
-                /* @__PURE__ */ jsx2("template", { id: `${name}_start` }),
-                resetStyle,
-                linksToRender,
-                remoteComponent,
-                /* @__PURE__ */ jsx2("template", { id: `${name}_end`, ref: endTemplateRef })
-              ] }),
-              shadowRoot
-            ) : null
-          ]
-        }
-      )
-    ] });
-  }
-  htmlRef.current = null;
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx2("template", { id: `${name}_start` }),
-    metadataJson,
-    componentToRender,
-    /* @__PURE__ */ jsx2("template", { id: `${name}_end`, ref: endTemplateRef })
-  ] });
-}
-
 // src/host/nextjs/app-compat.tsx
 import { usePathname, useSearchParams } from "next/navigation";
 var routerImpl = async () => {
@@ -3016,7 +153,7 @@ var routerImpl = async () => {
 };
 
 // src/host/nextjs/app-client-only.tsx
-import { jsx as jsx3 } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 var sharedModules = async (userShared, resolveClientUrl) => {
   const [resolvedShared, resolvedUserShared] = await Promise.all([
     tryImportShared(),
@@ -3030,16 +167,16 @@ var sharedModules = async (userShared, resolveClientUrl) => {
   };
 };
 function RemoteComponentsClientProvider({
-  shared: shared2,
+  shared,
   resolveClientUrl,
   children,
   ...props
 }) {
-  const mergedShared = useMemo3(
-    () => sharedModules(shared2, resolveClientUrl),
-    [shared2, resolveClientUrl]
+  const mergedShared = useMemo(
+    () => sharedModules(shared, resolveClientUrl),
+    [shared, resolveClientUrl]
   );
-  return /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx(
     RemoteComponentsContext,
     {
       value: { shared: mergedShared, resolveClientUrl, ...props },
@@ -3051,7 +188,7 @@ function ConsumeRemoteComponent2(props) {
   if (typeof props.src !== "string" && !(props.src instanceof URL)) {
     return props.children ?? null;
   }
-  return /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx(
     ConsumeRemoteComponent,
     {
       ...props,