remote-components 0.3.5 → 0.3.6

package/dist/host/html.js

@@ -1,2376 +1,40 @@
-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, CORS_DOCS_URL;
-var init_constants = __esm({
-  "src/utils/constants.ts"() {
-    "use strict";
-    RC_PROTECTED_REMOTE_FETCH_PATHNAME = "/rc-fetch-protected-remote";
-    CORS_DOCS_URL = "https://vercel.com/docs/remote-components/concepts/cors-external-urls#accessing-cross-site-protected-remote-components";
-  }
-});
-
-// src/runtime/url/protected-rc-fallback.ts
-function isProxiedUrl(url) {
-  try {
-    return new URL(url, location.href).pathname === RC_PROTECTED_REMOTE_FETCH_PATHNAME;
-  } catch {
-    return false;
-  }
-}
-var init_protected_rc_fallback = __esm({
-  "src/runtime/url/protected-rc-fallback.ts"() {
-    "use strict";
-    init_constants();
-  }
-});
-
-// src/utils/abort.ts
-function isAbortError(error) {
-  if (error instanceof DOMException && error.name === "AbortError") {
-    return true;
-  }
-  if (error !== null && typeof error === "object" && "name" in error && error.name === "AbortError" && "message" in error && typeof error.message === "string") {
-    const e = error;
-    return typeof e.code === "number" || e.constructor?.name === "DOMException";
-  }
-  return false;
-}
-var init_abort = __esm({
-  "src/utils/abort.ts"() {
-    "use strict";
-  }
-});
-
-// src/utils/error.ts
-function multipleRemoteComponentsError(url) {
-  return new RemoteComponentsError(
-    `Multiple Remote Components found at "${url}". When a page exposes multiple Remote Components you must specify the "name" prop to select which one to load.`
-  );
-}
-function failedToFetchRemoteComponentError(url, { status, statusText }, help = "Is the URL correct and accessible?") {
-  return new RemoteComponentsError(
-    `Failed to fetch Remote Component from "${url}". ${help}`,
-    { cause: new Error(`${status} ${statusText}`) }
-  );
-}
-async function errorFromFailedFetch(originalUrl, resolvedUrl, res) {
-  const isProxied = isProxiedUrl(resolvedUrl.href);
-  if (isProxied && res) {
-    const body = await res.text().catch(() => "");
-    return failedProxyFetchError(
-      originalUrl,
-      resolvedUrl.href,
-      res.status,
-      body
-    );
-  }
-  const fallback = failedToFetchRemoteComponentError(
-    originalUrl,
-    res ?? { status: 0, statusText: "No Response" }
-  );
-  if (!res)
-    return fallback;
-  try {
-    const body = await res.text();
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(body, "text/html");
-    const errorTemplate = doc.querySelector(
-      "template[data-next-error-message]"
-    );
-    const errorMessage = errorTemplate?.getAttribute("data-next-error-message");
-    if (errorMessage) {
-      const error = new RemoteComponentsError(errorMessage);
-      const errorStack = errorTemplate?.getAttribute("data-next-error-stack");
-      if (errorStack) {
-        error.stack = errorStack;
-      }
-      return error;
-    }
-  } catch (parseError) {
-    if (isAbortError(parseError))
-      throw parseError;
-  }
-  return fallback;
-}
-function failedProxiedAssetError(kind, url, resolvedUrl) {
-  return new RemoteComponentsError(
-    `Failed to load ${kind} "${url}" via proxy "${resolvedUrl}". Ensure withRemoteComponentsHostProxy middleware is configured, "${RC_PROTECTED_REMOTE_FETCH_PATHNAME}" is in the matcher, and the remote URL is included in allowedProxyUrls. See: ${CORS_DOCS_URL}`
-  );
-}
-function failedProxyFetchError(originalUrl, proxyUrl, status, responseBody) {
-  if (status === 404) {
-    return new RemoteComponentsError(
-      `Could not proxy the request to "${originalUrl}" \u2014 the proxy endpoint "${RC_PROTECTED_REMOTE_FETCH_PATHNAME}" returned 404.
-
-The host server needs middleware or a route that handles "${RC_PROTECTED_REMOTE_FETCH_PATHNAME}".
-
-Proxying requires two pieces:
-  1. resolveClientUrl={routeThroughHostProxy} on <RemoteComponent>
-  2. Middleware or a route for "${RC_PROTECTED_REMOTE_FETCH_PATHNAME}" on the host server
-
-Docs: ${CORS_DOCS_URL}`
-    );
-  }
-  if (status === 403) {
-    const detail = responseBody ? ` ${responseBody}` : "";
-    return new RemoteComponentsError(
-      `Proxied request to "${proxyUrl}" was forbidden.${detail} See: ${CORS_DOCS_URL}`
-    );
-  }
-  return new RemoteComponentsError(
-    `Proxied request for "${originalUrl}" via "${proxyUrl}" failed with status ${status}. See: ${CORS_DOCS_URL}`
-  );
-}
-var RemoteComponentsError;
-var init_error = __esm({
-  "src/utils/error.ts"() {
-    "use strict";
-    init_protected_rc_fallback();
-    init_abort();
-    init_constants();
-    RemoteComponentsError = class extends Error {
-      code = "REMOTE_COMPONENTS_ERROR";
-      constructor(message, options) {
-        super(message, options);
-        this.name = "RemoteComponentsError";
-      }
-    };
-  }
-});
-
-// src/utils/logger.ts
-function logDebug(location2, message) {
-  if (DEBUG) {
-    console.debug(`[${PREFIX}:${location2}]: ${message}`);
-  }
-}
-function logWarn(location2, message) {
-  console.warn(`[${PREFIX}:${location2}]: ${message}`);
-}
-function logError(location2, message, cause) {
-  console.error(
-    new RemoteComponentsError(`[${PREFIX}:${location2}]: ${message}`, {
-      cause
-    })
-  );
-}
-function warnCrossOriginFetchError(logLocation, url) {
-  try {
-    const parsed = typeof url === "string" ? new URL(url) : url;
-    if (typeof location === "undefined" || parsed.origin === location.origin) {
-      return;
-    }
-    logWarn(
-      logLocation,
-      `Failed to fetch cross-origin resource "${parsed.href}". To load assets from a protected deployment, two steps are required: (1) configure withRemoteComponentsHostProxy middleware in your host with the remote URL in allowedProxyUrls, and (2) provide a resolveClientUrl prop that rewrites cross-origin asset URLs to go through the proxy. See: ${CORS_DOCS_URL}`
-    );
-  } catch {
-  }
-}
-var PREFIX, DEBUG;
-var init_logger = __esm({
-  "src/utils/logger.ts"() {
-    "use strict";
-    init_constants();
-    init_error();
-    PREFIX = "remote-components";
-    DEBUG = typeof window !== "undefined" && localStorage.getItem("RC_DEBUG") === "true" || typeof process !== "undefined" && process.env.RC_DEBUG === "true";
-  }
-});
-
-// src/utils/index.ts
-function escapeString(str) {
-  return str.replace(/[^a-z0-9]/g, "_");
-}
-function computeScopedName(name, options) {
-  return options.isCrossOrigin ? `${name}_${escapeString(options.remoteHost.toLowerCase())}` : name;
-}
-var init_utils = __esm({
-  "src/utils/index.ts"() {
-    "use strict";
-  }
-});
-
-// src/runtime/constants.ts
-function getBundleKey(bundle) {
-  return escapeString(bundle);
-}
-var DEFAULT_BUNDLE_NAME, DEFAULT_COMPONENT_NAME, DEFAULT_ROUTE, RUNTIME_WEBPACK, RUNTIME_TURBOPACK, RUNTIME_SCRIPT;
-var init_constants2 = __esm({
-  "src/runtime/constants.ts"() {
-    "use strict";
-    init_utils();
-    DEFAULT_BUNDLE_NAME = "__vercel_remote_bundle";
-    DEFAULT_COMPONENT_NAME = "__vercel_remote_component";
-    DEFAULT_ROUTE = "/";
-    RUNTIME_WEBPACK = "webpack";
-    RUNTIME_TURBOPACK = "turbopack";
-    RUNTIME_SCRIPT = "script";
-  }
-});
-
-// src/runtime/namespace.ts
-function getNamespace() {
-  const g = globalThis;
-  const existing = g.__remote_components__;
-  if (existing) {
-    return existing;
-  }
-  const ns = {
-    scopes: /* @__PURE__ */ new Map(),
-    chunkCache: {},
-    mountFns: {},
-    unmountFns: {},
-    bundleUrls: {},
-    moduleRegistry: {},
-    dispatcherRuntime: void 0,
-    hostSharedModules: {},
-    cssCache: {},
-    shadowRoots: {}
-  };
-  const nsRecord = ns;
-  for (const { global, prop } of LEGACY_ALIASES) {
-    const legacyValue = g[global];
-    if (legacyValue != null) {
-      nsRecord[prop] = legacyValue;
-    }
-    g[global] = ns[prop];
-  }
-  const gRecord = g;
-  for (const key of Object.keys(gRecord)) {
-    if (key.startsWith(SHADOW_ROOT_PREFIX)) {
-      const suffix = key.slice(SHADOW_ROOT_PREFIX.length);
-      ns.shadowRoots[suffix] = gRecord[key];
-      delete gRecord[key];
-    }
-  }
-  g.__remote_components__ = ns;
-  return ns;
-}
-var SHADOW_ROOT_PREFIX, LEGACY_ALIASES;
-var init_namespace = __esm({
-  "src/runtime/namespace.ts"() {
-    "use strict";
-    SHADOW_ROOT_PREFIX = "__remote_components_shadowroot_";
-    LEGACY_ALIASES = [
-      { global: "__remote_component_scopes__", prop: "scopes" },
-      {
-        global: "__remote_components_turbopack_chunk_loader_promise__",
-        prop: "chunkCache"
-      },
-      { global: "__remote_script_entrypoint_mount__", prop: "mountFns" },
-      { global: "__remote_script_entrypoint_unmount__", prop: "unmountFns" },
-      { global: "__remote_bundle_url__", prop: "bundleUrls" },
-      { global: "__rc_module_registry__", prop: "moduleRegistry" },
-      {
-        global: "__remote_component_host_shared_modules__",
-        prop: "hostSharedModules"
-      },
-      { global: "__remote_next_css__", prop: "cssCache" }
-    ];
-  }
-});
-
-// src/runtime/patterns.ts
-function collapseDoubleSlashes(path) {
-  return path.replace(DOUBLE_SLASH_RE, "/");
-}
-var REMOTE_COMPONENT_REGEX, NEXT_BUNDLE_PATH_RE, DOUBLE_SLASH_RE;
-var init_patterns = __esm({
-  "src/runtime/patterns.ts"() {
-    "use strict";
-    REMOTE_COMPONENT_REGEX = /(?<prefix>.*?)\[(?<bundle>[^\]]+)\](?:%20| )(?<id>.+)/;
-    NEXT_BUNDLE_PATH_RE = /\/_next\/\[.+\](?:%20| )/;
-    DOUBLE_SLASH_RE = /(?<!:)\/\//g;
-  }
-});
-
-// src/runtime/turbopack/remote-scope.ts
-function getRegistry() {
-  return getNamespace().scopes;
-}
-function createScope(name, url, runtime, resolveClientUrl) {
-  const isCrossOrigin = url.origin !== location.origin;
-  const scopedName = computeScopedName(name, {
-    remoteHost: url.host,
-    isCrossOrigin
-  });
-  const globalKey = getBundleKey(scopedName);
-  return {
-    name,
-    scopedName,
-    globalKey,
-    url,
-    runtime,
-    resolveClientUrl,
-    moduleCache: {},
-    sharedModules: {},
-    moduleGlobal: {},
-    turbopackModules: []
-  };
-}
-function registerScope(scope) {
-  const registry = getRegistry();
-  registry.set(scope.scopedName, scope);
-  if (scope.scopedName !== scope.name) {
-    const existing = registry.get(scope.name);
-    if (existing && existing.scopedName !== scope.scopedName) {
-      logWarn(
-        "RemoteScope",
-        `Plain name "${scope.name}" already registered by scope "${existing.scopedName}" \u2014 overwriting with "${scope.scopedName}". Static hosts will only resolve the latest one.`
-      );
-    }
-    registry.set(scope.name, scope);
-  }
-  logDebug(
-    "RemoteScope",
-    `Registered scope "${scope.scopedName}" (${registry.size} total)`
-  );
-}
-function getScope(name) {
-  return getRegistry().get(name);
-}
-function formatRemoteId(scope, path) {
-  return `[${scope.scopedName}] ${path}`;
-}
-function parseRemoteId(id) {
-  const groups = REMOTE_COMPONENT_REGEX.exec(id)?.groups;
-  if (groups?.bundle && groups.id) {
-    return {
-      bundle: groups.bundle,
-      path: groups.id,
-      prefix: groups.prefix ?? ""
-    };
-  }
-  return { bundle: "default", path: id, prefix: "" };
-}
-var init_remote_scope = __esm({
-  "src/runtime/turbopack/remote-scope.ts"() {
-    "use strict";
-    init_constants2();
-    init_namespace();
-    init_patterns();
-    init_utils();
-    init_logger();
-  }
-});
-
-// src/host/shared/remote-image-loader.ts
-function createRemoteImageLoader(bundle, resolveClientUrl) {
-  const loader = Object.assign(
-    ({
-      config,
-      src,
-      width,
-      quality
-    }) => {
-      const q = quality ?? 75;
-      const remoteOrigin = getScope(bundle)?.url.origin ?? "";
-      const isCrossOrigin = remoteOrigin && remoteOrigin !== location.origin;
-      const basePath = isCrossOrigin ? `${remoteOrigin}${config.path ?? "/_next/image"}` : config.path ?? `${remoteOrigin}/_next/image`;
-      const url = `${basePath}?url=${encodeURIComponent(src)}&w=${width}&q=${q}`;
-      return resolveClientUrl?.(url) ?? url;
-    },
-    // Signals to getImgProps that this is a default loader (not a user-defined
-    // one), enabling srcSet generation with device/image sizes from the config.
-    { __next_img_default: true }
-  );
-  return loader;
-}
-var init_remote_image_loader = __esm({
-  "src/host/shared/remote-image-loader.ts"() {
-    "use strict";
-    init_remote_scope();
-  }
-});
-
-// src/host/shared/polyfill.tsx
-import { jsx } from "react/jsx-runtime";
-function sharedPolyfills(shared, resolveClientUrl) {
-  const hostShared = getNamespace().hostSharedModules;
-  const polyfill = {
-    "next/dist/client/components/navigation": hostShared["next/navigation"] ?? shared?.["next/navigation"] ?? (() => Promise.resolve({
-      useRouter() {
-        return {
-          push: (routerUrl) => {
-            history.pushState({}, "", routerUrl);
-          },
-          replace: (routerUrl) => {
-            history.replaceState({}, "", routerUrl);
-          },
-          back: () => {
-            history.back();
-          }
-        };
-      },
-      usePathname() {
-        return location.pathname;
-      },
-      useParams() {
-        return {};
-      },
-      useSearchParams() {
-        return new URLSearchParams(location.search);
-      },
-      useSelectedLayoutSegment() {
-        return null;
-      },
-      useSelectedLayoutSegments() {
-        return [];
-      },
-      __esModule: true
-    })),
-    "next/dist/client/app-dir/link": hostShared["next/link"] ?? shared?.["next/link"] ?? (() => Promise.resolve({
-      default: ({
-        scroll: _,
-        replace,
-        prefetch,
-        onNavigate,
-        children,
-        ...props
-      }) => {
-        if (prefetch) {
-          logWarn(
-            "Polyfill",
-            "Next.js Link prefetch is not supported in remote components"
-          );
-        }
-        return /* @__PURE__ */ jsx(
-          "a",
-          {
-            ...props,
-            href: props.href,
-            onClick: (e) => {
-              e.preventDefault();
-              let preventDefaulted = false;
-              e.preventDefault = () => {
-                preventDefaulted = true;
-                e.defaultPrevented = true;
-              };
-              if (typeof props.onClick === "function") {
-                props.onClick(e);
-              }
-              onNavigate?.(e);
-              if (preventDefaulted) {
-                return;
-              }
-              if (replace) {
-                history.replaceState({}, "", props.href);
-              } else {
-                history.pushState({}, "", props.href);
-              }
-            },
-            suppressHydrationWarning: true,
-            children: children ?? null
-          }
-        );
-      },
-      useLinkStatus() {
-        return { pending: false };
-      },
-      __esModule: true
-    })),
-    "next/dist/client/app-dir/form": hostShared["next/form"] ?? shared?.["next/form"] ?? (() => Promise.resolve({
-      default: () => {
-        throw new Error("Next.js <Form> component not implemented");
-      },
-      __esModule: true
-    })),
-    // Instead of replacing next/image entirely, we let the real Next.js Image
-    // component load from the remote bundle and only replace its default loader.
-    // This gives us full next/image fidelity (fill, priority, srcSet, blur
-    // placeholders, error handling) while routing image optimization through the
-    // remote app's /_next/image endpoint.
-    "next/dist/shared/lib/image-loader": hostShared["next/dist/shared/lib/image-loader"] ?? shared?.["next/dist/shared/lib/image-loader"] ?? ((bundle) => Promise.resolve({
-      default: createRemoteImageLoader(bundle, resolveClientUrl),
-      __esModule: true
-    })),
-    "next/dist/client/script": hostShared["next/script"] ?? shared?.["next/script"] ?? (() => Promise.resolve({
-      // TODO: implement <Script> component for non-Next.js host applications
-      // do not throw an error for now
-      default: () => null,
-      __esModule: true
-    })),
-    "next/router": hostShared["next/router"] ?? shared?.["next/router"] ?? (() => (
-      // TODO: incomplete implementation
-      Promise.resolve({
-        useRouter() {
-          return {
-            push: (routerUrl) => {
-              history.pushState({}, "", routerUrl);
-            },
-            replace: (routerUrl) => {
-              history.replaceState({}, "", routerUrl);
-            },
-            back: () => {
-              history.back();
-            }
-          };
-        },
-        __esModule: true
-      })
-    )),
-    "next/dist/build/polyfills/process": () => Promise.resolve({
-      default: {
-        env: {
-          NODE_ENV: "production"
-        }
-      },
-      __esModule: true
-    })
-  };
-  polyfill["next/navigation"] = polyfill["next/dist/client/components/navigation"];
-  polyfill["next/link"] = polyfill["next/dist/client/app-dir/link"];
-  polyfill["next/form"] = polyfill["next/dist/client/app-dir/form"];
-  polyfill["next/dist/esm/shared/lib/image-loader"] = polyfill["next/dist/shared/lib/image-loader"];
-  polyfill["next/script"] = polyfill["next/dist/client/script"];
-  return polyfill;
-}
-var init_polyfill = __esm({
-  "src/host/shared/polyfill.tsx"() {
-    "use strict";
-    init_remote_image_loader();
-    init_namespace();
-    init_logger();
-  }
-});
-
-// src/host/shared/shared-module-resolver.ts
-function buildCoreShared(userShared) {
-  return {
-    react: async () => (await import("react")).default,
-    "react-dom": async () => (await import("react-dom")).default,
-    "react/jsx-dev-runtime": async () => (await import("react/jsx-dev-runtime")).default,
-    "react/jsx-runtime": async () => (await import("react/jsx-runtime")).default,
-    "react-dom/client": async () => (await import("react-dom/client")).default,
-    ...userShared
-  };
-}
-function buildHostShared(userShared, resolveClientUrl, options) {
-  const self = globalThis;
-  const result = {
-    ...sharedPolyfills(userShared, resolveClientUrl),
-    ...self.__remote_component_host_shared_modules__,
-    ...userShared
-  };
-  if (options?.includeRemoteComponentShared) {
-    Object.assign(result, self.__remote_component_shared__);
-  }
-  return result;
-}
-async function buildWebpackResolve(hostShared, remoteShared, bundle, reactModules, callerTag = "SharedModuleResolver") {
-  const resolve = {
-    ...reactModules,
-    ...Object.entries(remoteShared).reduce(
-      (acc, [key, value]) => {
-        if (typeof hostShared[value] !== "undefined") {
-          acc[key.replace(/^\(ssr\)\/(?<relative>\.\/)?/, "")] = hostShared[value];
-        } else {
-          logDebug(
-            callerTag,
-            `Remote requests "${value}" but host doesn't provide it`
-          );
-        }
-        return acc;
-      },
-      {}
-    )
-  };
-  await Promise.all(
-    Object.entries(resolve).map(async ([key, value]) => {
-      if (typeof value === "function") {
-        resolve[key] = await value(bundle);
-      }
-      return Promise.resolve(value);
-    })
-  );
-  return resolve;
-}
-var CORE_REACT_PATH_MAP, VENDOR_SHARED;
-var init_shared_module_resolver = __esm({
-  "src/host/shared/shared-module-resolver.ts"() {
-    "use strict";
-    init_polyfill();
-    init_logger();
-    CORE_REACT_PATH_MAP = {
-      react: "/react/index.js",
-      "react/jsx-dev-runtime": "/react/jsx-dev-runtime.js",
-      "react/jsx-runtime": "/react/jsx-runtime.js",
-      "react-dom": "/react-dom/index.js",
-      "react-dom/client": "/react-dom/client.js"
-    };
-    VENDOR_SHARED = Object.fromEntries(
-      Object.entries(CORE_REACT_PATH_MAP).filter(([key]) => key !== "react-dom/client").map(([key, path]) => [key, `'${path}'`])
-    );
-  }
-});
-
-// src/config/webpack/apply-shared-modules.ts
-function applySharedModules(bundle, resolve) {
-  logDebug(
-    "SharedModules",
-    `applySharedModules called for bundle: "${bundle}"`
-  );
-  logDebug(
-    "SharedModules",
-    `Shared modules to resolve: ${Object.keys(resolve)}`
-  );
-  const self = globalThis;
-  const scope = getScope(bundle);
-  const webpackBundle = scope?.webpackRequire ?? self.__remote_webpack_require__?.[bundle];
-  if (webpackBundle) {
-    const modulePaths = Object.keys(
-      self.__remote_webpack_module_map__?.[bundle] ?? webpackBundle.m ?? {}
-    );
-    logDebug(
-      "SharedModules",
-      `Available module paths for bundle "${bundle}": ${modulePaths}`
-    );
-    for (const [key, value] of Object.entries(resolve)) {
-      const exactIds = modulePaths.filter((p) => p === key);
-      const ids = exactIds.length > 0 ? exactIds : modulePaths.filter((p) => p.includes(key));
-      if (ids.length === 0) {
-        logDebug(
-          "SharedModules",
-          `No matching module path found for shared module "${key}"`
-        );
-      }
-      for (const id of ids) {
-        if (webpackBundle.m) {
-          const resolvedId = self.__remote_webpack_module_map__?.[bundle]?.[id] ? `${self.__remote_webpack_module_map__[bundle][id]}` : id;
-          if (resolvedId !== id) {
-            logDebug(
-              "SharedModules",
-              `Mapped module id: "${id}" -> "${resolvedId}"`
-            );
-          }
-          webpackBundle.m[resolvedId] = (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__ ?? {})}`
-    );
-  }
-}
-var DEDUPLICATION_SKIPPED;
-var init_apply_shared_modules = __esm({
-  "src/config/webpack/apply-shared-modules.ts"() {
-    "use strict";
-    init_remote_scope();
-    init_logger();
-    DEDUPLICATION_SKIPPED = "shared module deduplication skipped. The remote may load its own copy of shared dependencies.";
-  }
-});
-
-// src/config/webpack/next-client-pages-loader.ts
-function nextClientPagesLoader(bundle, route, styleContainer = document.head) {
-  const self = globalThis;
-  const nextCssOriginal = document.querySelector(
-    `[id="__next_css__DO_NOT_USE__"]:not([data-bundle="${bundle}"][data-route="${route}"])`
-  );
-  if (nextCssOriginal) {
-    nextCssOriginal.parentNode?.removeChild(nextCssOriginal);
-  }
-  const nextCss = document.createElement("noscript");
-  nextCss.id = "__next_css__DO_NOT_USE__";
-  nextCss.setAttribute("data-bundle", bundle);
-  nextCss.setAttribute("data-route", route);
-  const nextCssEnd = document.createElement("noscript");
-  nextCssEnd.id = "__next_css__DO_NOT_USE_END__";
-  nextCssEnd.setAttribute("data-bundle", bundle);
-  nextCssEnd.setAttribute("data-route", route);
-  document.head.appendChild(nextCssEnd);
-  document.head.appendChild(nextCss);
-  const componentLoaderChunk = Object.keys(self.__remote_webpack_require__?.[bundle]?.m ?? {}).find(
-    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=${encodeURIComponent(route)}!`)
-  ) ?? Object.keys(self.__remote_webpack_require__?.[bundle]?.m ?? {}).find(
-    (key) => key.includes("/next/dist/client/page-loader.js")
-  ) ?? self.__remote_webpack_module_map__?.[bundle]?.[Object.keys(self.__remote_webpack_module_map__[bundle] ?? {}).find(
-    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=${encodeURIComponent(route)}!`)
-  ) ?? Object.keys(self.__remote_webpack_module_map__[bundle] ?? {}).find(
-    (key) => key.includes("/next/dist/client/page-loader.js")
-  ) ?? ""] ?? -1;
-  const appLoaderChunk = Object.keys(self.__remote_webpack_require__?.[bundle]?.m ?? {}).find(
-    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=%2F_app`)
-  ) ?? Object.keys(self.__remote_webpack_require__?.[bundle]?.m ?? {}).find(
-    (key) => key.includes("/next/dist/client/page-loader.js")
-  ) ?? self.__remote_webpack_module_map__?.[bundle]?.[Object.keys(self.__remote_webpack_module_map__[bundle] ?? {}).find(
-    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=%2F_app`)
-  ) ?? Object.keys(self.__remote_webpack_module_map__[bundle] ?? {}).find(
-    (key) => key.includes("/next/dist/client/page-loader.js")
-  ) ?? ""] ?? -1;
-  if (!(componentLoaderChunk && appLoaderChunk)) {
-    throw new RemoteComponentsError(
-      `Next.js client pages loader not found in bundle "${bundle}".`
-    );
-  }
-  const __NEXT_P_ORIGINAL = self.__NEXT_P;
-  const selfOriginal = self;
-  delete selfOriginal.__NEXT_P;
-  self.__remote_webpack_require__?.[bundle]?.(
-    self.__remote_webpack_require__[bundle].type !== "turbopack" ? componentLoaderChunk : `[${bundle}] ${componentLoaderChunk}`
-  );
-  if (typeof appLoaderChunk === "string" || typeof appLoaderChunk === "number" && appLoaderChunk !== -1) {
-    self.__remote_webpack_require__?.[bundle]?.(
-      self.__remote_webpack_require__[bundle].type !== "turbopack" ? appLoaderChunk : `[${bundle}] ${appLoaderChunk}`
-    );
-  }
-  if (self.__NEXT_P) {
-    const [, componentLoader] = self.__NEXT_P[0] ?? [
-      void 0,
-      () => ({ default: null })
-    ];
-    const [, appLoader] = self.__NEXT_P[2] ?? [
-      void 0,
-      () => ({
-        default: null
-      })
-    ];
-    const { default: Component } = componentLoader();
-    const { default: App } = appLoader();
-    const cssCache = getNamespace().cssCache;
-    if (!cssCache[bundle]) {
-      const cssRE = /\.s?css$/;
-      Object.keys(self.__remote_webpack_require__?.[bundle]?.m ?? {}).filter((id) => cssRE.test(id)).forEach((id) => {
-        self.__remote_webpack_require__?.[bundle]?.(id);
-      });
-      Object.keys(self.__remote_webpack_module_map__?.[bundle] ?? {}).filter((path) => cssRE.test(path)).forEach((path) => {
-        const id = self.__remote_webpack_module_map__?.[bundle]?.[path];
-        if (id) {
-          self.__remote_webpack_require__?.[bundle]?.(id);
-        }
-      });
-      const elements = [];
-      let node = nextCss.previousSibling;
-      while (node && node !== nextCssEnd) {
-        elements.push(node);
-        node.remove();
-        node = nextCss.previousSibling;
-      }
-      cssCache[bundle] = elements;
-    }
-    if (styleContainer) {
-      const elements = cssCache[bundle];
-      elements.forEach((el) => {
-        styleContainer.appendChild(el.cloneNode(true));
-      });
-    } else {
-      const elements = cssCache[bundle];
-      elements.forEach((el) => {
-        document.head.appendChild(el);
-      });
-    }
-    delete self.__NEXT_P;
-    self.__NEXT_P = __NEXT_P_ORIGINAL;
-    if (nextCssOriginal) {
-      nextCssOriginal.parentNode?.appendChild(nextCssOriginal);
-    }
-    nextCss.remove();
-    nextCssEnd.remove();
-    return { Component, App };
-  }
-  return { Component: null, App: null };
-}
-var init_next_client_pages_loader = __esm({
-  "src/config/webpack/next-client-pages-loader.ts"() {
-    "use strict";
-    init_namespace();
-    init_error();
-  }
-});
-
-// src/runtime/turbopack/patterns.ts
-function stripQuotes(value) {
-  if (value.startsWith('"') && value.endsWith('"')) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-function extractGroup(re, input, group) {
-  const raw = re.exec(input)?.groups?.[group];
-  return raw ? stripQuotes(raw) : void 0;
-}
-var MODULE_ID_PATTERN, REMOTE_SHARED_MARKER_RE, REMOTE_SHARED_ASSIGNMENT_RE, ASYNC_MODULE_LOADER_RE, ASYNC_MODULE_CALLBACK_RE, TURBOPACK_GLOBAL_RE;
-var init_patterns2 = __esm({
-  "src/runtime/turbopack/patterns.ts"() {
-    "use strict";
-    MODULE_ID_PATTERN = '"[^"]+"|[0-9]+';
-    REMOTE_SHARED_MARKER_RE = /(?:self|[a-z])\.TURBOPACK_REMOTE_SHARED/;
-    REMOTE_SHARED_ASSIGNMENT_RE = new RegExp(
-      `\\.TURBOPACK_REMOTE_SHARED\\s*=\\s*await (?:__turbopack_context__|[a-z])\\.A\\((?<sharedModuleId>${MODULE_ID_PATTERN})\\)`
-    );
-    ASYNC_MODULE_LOADER_RE = new RegExp(
-      `(?:__turbopack_context__|[a-z])\\.A\\((?<asyncSharedModuleId>${MODULE_ID_PATTERN})\\)`
-    );
-    ASYNC_MODULE_CALLBACK_RE = new RegExp(
-      `(?:parentImport|[a-z])\\((?<sharedModuleId>${MODULE_ID_PATTERN})\\)`
-    );
-    TURBOPACK_GLOBAL_RE = /(?:globalThis|self)\s*(?:\.TURBOPACK|\[\s*["']TURBOPACK["']\s*\])/;
-  }
-});
-
-// src/runtime/turbopack/chunk-loader.ts
-function loadChunkWithScope(scope, chunkId) {
-  logDebug(
-    "ChunkLoader",
-    `loadChunkWithScope: "${chunkId}" (scope: "${scope.scopedName}")`
-  );
-  const self = globalThis;
-  const ns = getNamespace();
-  const { bundle, path, prefix } = parseRemoteId(chunkId);
-  const remoteRuntime = self.__remote_webpack_require__?.[bundle ?? "default"] ? self.__remote_webpack_require__[bundle ?? "default"]?.type || "webpack" : scope.runtime;
-  if (remoteRuntime === RUNTIME_WEBPACK) {
-    return Promise.resolve(void 0);
-  }
-  const rawPath = path ? collapseDoubleSlashes(`${prefix}${path}`) : "/";
-  const url = new URL(rawPath, scope.url).href;
-  if (url.endsWith(".css")) {
-    return;
-  }
-  if (ns.chunkCache[url]) {
-    logDebug("ChunkLoader", `Cache hit for "${chunkId}" (url="${url}")`);
-    return ns.chunkCache[url];
-  }
-  const resolvedUrl = scope.resolveClientUrl?.(url) ?? url;
-  if (resolvedUrl !== url) {
-    logDebug("ChunkLoader", `Proxied chunk URL: "${url}" \u2192 "${resolvedUrl}"`);
-  }
-  ns.chunkCache[url] = new Promise((resolve, reject) => {
-    fetch(resolvedUrl).then((res) => res.text()).then((code) => {
-      const hasTurbopack = TURBOPACK_GLOBAL_RE.test(code);
-      if (hasTurbopack) {
-        return handleTurbopackChunk(code, scope, url);
-      }
-    }).then(resolve).catch((error) => {
-      const isProxied = isProxiedUrl(resolvedUrl);
-      if (isProxied) {
-        reject(failedProxiedAssetError("chunk", url, resolvedUrl));
-      } else {
-        warnCrossOriginFetchError("ChunkLoader", url);
-        reject(error);
-      }
-    });
-  });
-  return ns.chunkCache[url];
-}
-function createChunkDispatcher() {
-  return function __chunk_dispatcher__(chunkId, scriptBundle) {
-    logDebug("ChunkDispatcher", `Dispatching chunk: "${chunkId}"`);
-    const { bundle } = parseRemoteId(chunkId);
-    const bundleName = bundle || scriptBundle || "default";
-    const scope = getScope(bundleName);
-    logDebug(
-      "ChunkDispatcher",
-      `Scope resolution: bundle="${bundleName}", scope=${scope?.scopedName ?? "null"}`
-    );
-    if (!scope) {
-      logWarn("ChunkDispatcher", `No scope found for bundle "${bundleName}"`);
-      return Promise.resolve(void 0);
-    }
-    return loadChunkWithScope(scope, chunkId);
-  };
-}
-async function handleTurbopackChunk(code, scope, url) {
-  if (/importScripts\(\.\.\.self.TURBOPACK_NEXT_CHUNK_URLS/.test(code)) {
-    const preloadLinks = document.querySelectorAll(
-      `link[rel="preload"][href="${new URL(url).pathname}"]`
-    );
-    preloadLinks.forEach((preloadLink) => preloadLink.remove());
-    return;
-  }
-  const self = globalThis;
-  const { globalKey } = scope;
-  const transformedCode = code.replace(
-    /globalThis\[\s*["']TURBOPACK["']\s*\]/g,
-    `globalThis["TURBOPACK_${globalKey}"]`
-  ).replace(
-    /self\[\s*["']TURBOPACK["']\s*\]/g,
-    `self["TURBOPACK_${globalKey}"]`
-  ).replace(/globalThis\.TURBOPACK/g, `globalThis.TURBOPACK_${globalKey}`).replace(/self\.TURBOPACK(?!_)/g, `self.TURBOPACK_${globalKey}`).replace(
-    /TURBOPACK_WORKER_LOCATION/g,
-    `TURBOPACK_WORKER_LOCATION_${globalKey}`
-  ).replace(
-    /TURBOPACK_NEXT_CHUNK_URLS/g,
-    `TURBOPACK_NEXT_CHUNK_URLS_${globalKey}`
-  ).replace(
-    /TURBOPACK_CHUNK_UPDATE_LISTENERS/g,
-    `TURBOPACK_CHUNK_UPDATE_LISTENERS_${globalKey}`
-  ).replace(/__next_require__/g, `__${globalKey}_next_require__`).replace(
-    /\/\/# sourceMappingURL=(?<name>.+)(?<optional>\._)?\.js\.map/g,
-    `//# sourceMappingURL=${new URL(".", new URL(url, scope.url)).href}$1$2.js.map`
-  );
-  if (!self[`TURBOPACK_${globalKey}`]) {
-    const wrapPush = (target) => {
-      const originalPush = target.push;
-      if (typeof originalPush !== "function")
-        return target;
-      target.push = (...items) => {
-        for (const item of items) {
-          if (Array.isArray(item)) {
-            for (const entry of item) {
-              scope.turbopackModules.push(entry);
-            }
-          } else {
-            scope.turbopackModules.push(item);
-          }
-        }
-        return originalPush.apply(target, items);
-      };
-      return target;
-    };
-    const globalProp = `TURBOPACK_${globalKey}`;
-    let currentValue = wrapPush([]);
-    Object.defineProperty(self, globalProp, {
-      get() {
-        return currentValue;
-      },
-      set(newValue) {
-        if (newValue && typeof newValue === "object") {
-          wrapPush(newValue);
-        }
-        currentValue = newValue;
-      },
-      configurable: true,
-      enumerable: true
-    });
-  }
-  await new Promise((scriptResolve, scriptReject) => {
-    const blob = new Blob([transformedCode], {
-      type: "application/javascript; charset=UTF-8"
-    });
-    const scriptUrl = URL.createObjectURL(blob);
-    const script = document.createElement("script");
-    script.setAttribute("data-turbopack-src", url);
-    script.src = scriptUrl;
-    script.async = true;
-    script.onload = () => {
-      URL.revokeObjectURL(scriptUrl);
-      scriptResolve(void 0);
-      script.remove();
-    };
-    script.onerror = () => {
-      URL.revokeObjectURL(scriptUrl);
-      scriptReject(
-        new RemoteComponentsError(
-          `Failed to load <script src="${script.src}"> for Remote Component. Check the URL is correct.`
-        )
-      );
-      script.remove();
-    };
-    document.head.appendChild(script);
-  });
-  const chunkLists = self[`TURBOPACK_${globalKey}_CHUNK_LISTS`];
-  const loadChunkPromises = [];
-  while (chunkLists?.length) {
-    const { chunks } = chunkLists.shift() ?? { chunks: [] };
-    if (chunks.length > 0) {
-      for (const id of chunks) {
-        const baseUrl = url.slice(0, url.indexOf("/_next"));
-        const chunkLoadResult = loadChunkWithScope(
-          scope,
-          formatRemoteId(scope, `${baseUrl}/_next/${id}`)
-        );
-        if (chunkLoadResult) {
-          loadChunkPromises.push(chunkLoadResult);
-        }
-      }
-    }
-  }
-  if (loadChunkPromises.length > 0) {
-    await Promise.all(loadChunkPromises);
-  }
-}
-var init_chunk_loader = __esm({
-  "src/runtime/turbopack/chunk-loader.ts"() {
-    "use strict";
-    init_constants2();
-    init_namespace();
-    init_patterns();
-    init_protected_rc_fallback();
-    init_error();
-    init_logger();
-    init_patterns2();
-    init_remote_scope();
-  }
-});
-
-// src/runtime/turbopack/shared-modules.ts
-function getTurbopackModules(scope) {
-  if (scope.turbopackModules.length > 0) {
-    return scope.turbopackModules;
-  }
-  const self = globalThis;
-  const raw = self[`TURBOPACK_${scope.globalKey}`];
-  if (!raw)
-    return void 0;
-  if (Array.isArray(raw)) {
-    return raw.flat();
-  }
-  return Object.entries(raw).flat();
-}
-async function initializeSharedModules(scope, hostShared = {}, remoteShared = {}) {
-  const allModules = getTurbopackModules(scope);
-  logDebug(
-    "SharedModules",
-    `initializeSharedModules: scope="${scope.scopedName}", allModules=${allModules ? allModules.length : "null"}, hostShared=[${Object.keys(hostShared).join(", ")}], remoteShared=${JSON.stringify(remoteShared)}`
-  );
-  let sharedModuleInitializer = null;
-  if (allModules) {
-    const sharedModuleInitializerIndex = allModules.findIndex((idOrFunc) => {
-      if (typeof idOrFunc !== "function") {
-        return false;
-      }
-      const funcCode = idOrFunc.toString();
-      return REMOTE_SHARED_MARKER_RE.test(funcCode);
-    });
-    if (sharedModuleInitializerIndex > 0) {
-      const sharedModuleInitializerCode = allModules[sharedModuleInitializerIndex].toString();
-      const sharedModuleInitializerId = allModules[sharedModuleInitializerIndex - 1];
-      const sharedModuleId = extractGroup(
-        REMOTE_SHARED_ASSIGNMENT_RE,
-        sharedModuleInitializerCode,
-        "sharedModuleId"
-      );
-      if (sharedModuleId) {
-        const { default: sharedModuleInitializerInstance } = handleTurbopackModule(
-          scope,
-          sharedModuleId,
-          formatRemoteId(scope, String(sharedModuleInitializerId))
-        );
-        sharedModuleInitializer = sharedModuleInitializerInstance;
-      }
-    }
-    if (sharedModuleInitializer) {
-      const { shared } = await sharedModuleInitializer;
-      const sharedModuleIds = extractSharedModuleIds(shared, scope);
-      logDebug(
-        "SharedModules",
-        `Resolved shared modules for scope="${scope.scopedName}": ${JSON.stringify(sharedModuleIds)}`
-      );
-      return Promise.all(
-        Object.entries(sharedModuleIds).map(async ([id, 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(shared, scope) {
-  return Object.entries(shared).filter(([, value]) => typeof value === "function").reduce((acc, [key, value]) => {
-    const asyncSharedModuleId = extractGroup(
-      ASYNC_MODULE_LOADER_RE,
-      value.toString(),
-      "asyncSharedModuleId"
-    );
-    if (asyncSharedModuleId) {
-      const asyncSharedModule = findModuleInit(
-        getTurbopackModules(scope),
-        asyncSharedModuleId
-      );
-      if (asyncSharedModule) {
-        const sharedModuleId = extractGroup(
-          ASYNC_MODULE_CALLBACK_RE,
-          asyncSharedModule.toString(),
-          "sharedModuleId"
-        );
-        acc[sharedModuleId ?? asyncSharedModuleId] = key.replace(
-          "__remote_shared_module_",
-          ""
-        );
-      }
-    }
-    return acc;
-  }, {});
-}
-function getSharedModule(scope, id) {
-  const idStr = String(id);
-  if (scope.sharedModules[idStr] !== void 0) {
-    return scope.sharedModules[idStr];
-  }
-  for (const [key, value] of Object.entries(scope.sharedModules)) {
-    if (typeof value !== "undefined" && idStr !== key && idStr.endsWith(key)) {
-      return value;
-    }
-  }
-  return null;
-}
-var DEDUPLICATION_WARNING;
-var init_shared_modules = __esm({
-  "src/runtime/turbopack/shared-modules.ts"() {
-    "use strict";
-    init_logger();
-    init_module();
-    init_patterns2();
-    init_remote_scope();
-    DEDUPLICATION_WARNING = "This module will not be deduplicated \u2014 the remote may load its own copy, which can cause duplicate instance errors (e.g. invalid hook calls if React is loaded twice).";
-  }
-});
-
-// src/runtime/turbopack/module.ts
-function requireModule(scope, moduleId, fullId) {
-  const idStr = String(moduleId);
-  if (scope.moduleCache[idStr])
-    return scope.moduleCache[idStr];
-  const sharedModule = getSharedModule(scope, moduleId);
-  if (sharedModule)
-    return sharedModule;
-  return handleTurbopackModule(
-    scope,
-    idStr,
-    fullId ?? formatRemoteId(scope, idStr)
-  );
-}
-function handleTurbopackModule(scope, moduleId, id) {
-  if (scope.moduleCache[moduleId]) {
-    return scope.moduleCache[moduleId];
-  }
-  const modules = getTurbopackModules(scope);
-  if (!modules) {
-    logError(
-      "TurbopackModule",
-      `TURBOPACK_${scope.globalKey} is undefined (scope: "${scope.scopedName}")`
-    );
-  }
-  const moduleInit = findModuleInit(modules, moduleId);
-  const exports = {};
-  const moduleExports = { exports };
-  if (typeof moduleInit !== "function") {
-    throw new Error(
-      `Module ${id} not found in bundle ${scope.name} with id ${moduleId}`
-    );
-  }
-  scope.moduleCache[moduleId] = moduleExports.exports;
-  moduleInit(
-    createTurbopackContext(
-      scope,
-      exports,
-      moduleExports,
-      modules,
-      moduleInit,
-      id
-    ),
-    moduleExports,
-    exports
-  );
-  if (scope.moduleCache[moduleId] !== moduleExports.exports) {
-    scope.moduleCache[moduleId] = moduleExports.exports;
-  }
-  return moduleExports.exports;
-}
-function findModuleInit(modules, moduleId) {
-  if (!modules || typeof modules !== "object")
-    return;
-  if (!Array.isArray(modules)) {
-    const key = moduleId in modules ? moduleId : Object.keys(modules).find((k) => k.startsWith(moduleId));
-    return key !== void 0 ? modules[key] : void 0;
-  }
-  const flat = modules.flat();
-  let idx = flat.findIndex((e) => String(e) === String(moduleId));
-  if (idx < 0) {
-    idx = flat.findIndex(
-      (e) => typeof e === "string" && e.startsWith(moduleId)
-    );
-  }
-  if (idx >= 0) {
-    return flat.slice(idx + 1).find((e) => typeof e === "function");
-  }
-  for (const entry of flat) {
-    if (!entry || typeof entry !== "object")
-      continue;
-    const obj = entry;
-    if (moduleId in obj)
-      return obj[moduleId];
-    const prefixKey = Object.keys(obj).find((k) => k.startsWith(moduleId));
-    if (prefixKey)
-      return obj[prefixKey];
-  }
-  return void 0;
-}
-function createTurbopackContext(scope, exports, moduleExports, modules, moduleInit, id) {
-  const scopedRequire = (moduleId) => requireModule(scope, moduleId, formatRemoteId(scope, String(moduleId)));
-  return {
-    // HMR not implemented for Remote Components
-    k: {
-      register() {
-      },
-      registerExports() {
-      },
-      signature() {
-        return (fn) => fn;
-      }
-    },
-    // ESM exports setup
-    s(bindings, esmId) {
-      let mod = exports;
-      if (typeof esmId === "string" || typeof esmId === "number") {
-        if (!scope.moduleCache[esmId]) {
-          scope.moduleCache[esmId] = {};
-        }
-        mod = scope.moduleCache[esmId];
-      }
-      Object.defineProperty(mod, "__esModule", { value: true });
-      if (Array.isArray(bindings)) {
-        let i = 0;
-        while (i < bindings.length) {
-          const propName = bindings[i++];
-          const tagOrFunc = bindings[i++];
-          if (typeof tagOrFunc === "number") {
-            Object.defineProperty(mod, propName, {
-              value: bindings[i++],
-              enumerable: true,
-              writable: false
-            });
-          } else {
-            const getterFn = tagOrFunc;
-            if (typeof bindings[i] === "function") {
-              const setterFn = bindings[i++];
-              Object.defineProperty(mod, propName, {
-                get: getterFn,
-                set: setterFn,
-                enumerable: true
-              });
-            } else {
-              Object.defineProperty(mod, propName, {
-                get: getterFn,
-                enumerable: true
-              });
-            }
-          }
-        }
-      }
-    },
-    // import — resolves directly via scope, no global dispatch
-    i(importId) {
-      let mod;
-      if (typeof importId === "string") {
-        const { exportSource, exportName } = /\s+<export (?<exportSource>.*?) as (?<exportName>.*?)>$/.exec(
-          importId
-        )?.groups ?? {};
-        const normalizedId = importId.replace(
-          /\s+<export(?<specifier>.*)>$/,
-          ""
-        );
-        mod = scopedRequire(normalizedId);
-        if (mod && exportSource && exportName && (exportSource === "*" || typeof mod[exportSource] !== "undefined") && typeof mod[exportName] === "undefined") {
-          if (exportSource === "*") {
-            mod[exportName] = mod;
-          } else {
-            mod[exportName] = mod[exportSource];
-          }
-        }
-      } else {
-        mod = scopedRequire(importId);
-      }
-      if (typeof mod !== "object" || mod === null) {
-        mod = { default: mod };
-      } else if (!("default" in mod) && // ES module namespace objects have a null prototype, so calling
-      // mod.toString() directly throws. Use Object.prototype.toString
-      // to safely detect them.
-      Object.prototype.toString.call(mod) !== "[object Module]") {
-        try {
-          mod.default = mod;
-        } catch {
-        }
-      }
-      return mod;
-    },
-    // require — resolves directly via scope
-    r(requireId) {
-      return scopedRequire(requireId);
-    },
-    // value exports
-    v(value) {
-      if (typeof value === "function") {
-        exports.default = value((vid) => scopedRequire(vid));
-      } else {
-        moduleExports.exports = value;
-      }
-    },
-    // async module initializer
-    async a(mod) {
-      let result;
-      await mod(
-        () => {
-        },
-        (value) => result = value
-      );
-      exports.default = result;
-    },
-    // async module loader — resolves directly via scope
-    async A(Aid) {
-      const mod = scopedRequire(Aid);
-      return mod.default((parentId) => scopedRequire(parentId));
-    },
-    // dynamic import tracking — no-op for remote components
-    j() {
-    },
-    // chunk loader — loads directly via scope, no global dispatch
-    l(url) {
-      const flatModules = Array.isArray(modules) ? modules : [];
-      const moduleInitIndex = flatModules.indexOf(moduleInit);
-      if (moduleInitIndex !== -1) {
-        const scriptIndex = flatModules.slice(0, moduleInitIndex).findLastIndex((bundleEntry) => bundleEntry instanceof Element);
-        if (scriptIndex !== -1) {
-          const script = flatModules[scriptIndex];
-          const scriptSrc = script.getAttribute("data-turbopack-src") || "";
-          const nextIndex = scriptSrc.indexOf("/_next");
-          const baseUrl = nextIndex !== -1 ? scriptSrc.slice(0, nextIndex) : "";
-          const chunkUrl = `${baseUrl}/_next/${url}`;
-          return loadChunkWithScope(scope, formatRemoteId(scope, chunkUrl));
-        }
-      }
-      throw new Error(
-        `Failed to load Turbopack chunk "${url}" for module "${id}". Check the URL is correct.`
-      );
-    },
-    // globalThis substitute shared across all modules in this scope
-    g: scope.moduleGlobal,
-    m: moduleExports,
-    e: exports
-  };
-}
-var init_module = __esm({
-  "src/runtime/turbopack/module.ts"() {
-    "use strict";
-    init_logger();
-    init_chunk_loader();
-    init_remote_scope();
-    init_shared_modules();
-  }
-});
-
-// src/runtime/turbopack/remote-scope-setup.ts
-async function setupRemoteScope(runtime, scripts = [], url = new URL(location.href), bundle, resolveClientUrl) {
-  const self = globalThis;
-  const ns = getNamespace();
-  const bundleName = bundle ?? "default";
-  const existingScope = getScope(bundleName);
-  if (existingScope && existingScope.url.origin === url.origin) {
-    logDebug(
-      "WebpackRuntime",
-      `Reusing scope "${existingScope.scopedName}" (turbopackModules=${existingScope.turbopackModules.length})`
-    );
-    existingScope.resolveClientUrl = resolveClientUrl;
-    if (runtime === RUNTIME_TURBOPACK) {
-      await Promise.allSettled(
-        scripts.map(
-          (script) => script.src ? loadChunkWithScope(existingScope, script.src) : Promise.resolve(void 0)
-        )
-      );
-    }
-    return existingScope;
-  }
-  const scope = createScope(bundleName, url, runtime, resolveClientUrl);
-  registerScope(scope);
-  if (runtime === RUNTIME_WEBPACK && self.__remote_webpack_require__?.[bundleName]) {
-    scope.webpackRequire = self.__remote_webpack_require__[bundleName];
-  }
-  ns.bundleUrls[bundleName] = url;
-  if (scope.scopedName !== bundleName) {
-    ns.bundleUrls[scope.scopedName] = url;
-  }
-  self.__webpack_get_script_filename__ = () => null;
-  const willCreateDispatchers = typeof self.__webpack_require__ !== "function" || ns.dispatcherRuntime !== "turbopack";
-  if (willCreateDispatchers) {
-    if (!self.__original_webpack_require__ && !self.__original_webpack_chunk_load__) {
-      self.__original_webpack_chunk_load__ = self.__webpack_chunk_load__;
-      self.__original_webpack_require__ = self.__webpack_require__;
-    }
-    self.__webpack_chunk_load__ = createChunkDispatcher();
-    self.__webpack_require__ = createModuleDispatcher(runtime);
-    ns.dispatcherRuntime = runtime;
-    self.__webpack_require_type__ = runtime;
-    if (self.__remote_webpack_require__ && runtime === RUNTIME_TURBOPACK) {
-      self.__remote_webpack_require__[bundleName] = self.__webpack_require__;
-      self.__remote_webpack_require__[bundleName].type = "turbopack";
-    }
-  }
-  if (self.__remote_webpack_require__?.[bundleName] && scope.scopedName !== bundleName) {
-    self.__remote_webpack_require__[scope.scopedName] = self.__remote_webpack_require__[bundleName];
-  }
-  if (runtime === RUNTIME_TURBOPACK) {
-    const results = await Promise.allSettled(
-      scripts.map((script) => {
-        if (script.src) {
-          return loadChunkWithScope(scope, script.src);
-        }
-        return Promise.resolve(void 0);
-      })
-    );
-    for (const result of results) {
-      if (result.status === "rejected") {
-        logWarn(
-          "WebpackRuntime",
-          `Initial chunk load failed: ${String(result.reason)}`
-        );
-      }
-    }
-  }
-  return scope;
-}
-function createModuleDispatcher(runtime) {
-  return (id) => {
-    const self = globalThis;
-    const { bundle, id: moduleId } = id.match(REMOTE_COMPONENT_REGEX)?.groups ?? {
-      bundle: "default",
-      id
-    };
-    const bundleName = bundle ?? "default";
-    const remoteRuntime = self.__remote_webpack_require__?.[bundleName] ? self.__remote_webpack_require__[bundleName]?.type || "webpack" : runtime;
-    logDebug(
-      "ModuleDispatcher",
-      `Resolving "${id}" (bundle: "${bundleName}", runtime: "${remoteRuntime}")`
-    );
-    try {
-      if (remoteRuntime === RUNTIME_WEBPACK && bundle && moduleId) {
-        const scope2 = getScope(bundle);
-        if (scope2?.webpackRequire)
-          return scope2.webpackRequire(moduleId);
-        return self.__remote_webpack_require__?.[bundle]?.(moduleId);
-      }
-      const scope = getScope(bundleName);
-      if (scope) {
-        return requireModule(scope, moduleId ?? id, id);
-      }
-      throw new Error(
-        `Module "${id}" not found \u2014 no scope for bundle "${bundleName}".`
-      );
-    } catch (requireError) {
-      logWarn(
-        "ModuleDispatcher",
-        `Module require failed: ${String(requireError)}`
-      );
-      if (typeof self.__original_webpack_require__ !== "function") {
-        throw new RemoteComponentsError(
-          `Module "${id}" not found in remote component bundle "${bundleName}".`,
-          {
-            cause: requireError instanceof Error ? requireError : void 0
-          }
-        );
-      }
-      try {
-        logDebug(
-          "ModuleDispatcher",
-          "Falling back to original webpack require"
-        );
-        return self.__original_webpack_require__(id);
-      } catch (originalError) {
-        throw new RemoteComponentsError(
-          `Module "${id}" not found in remote component bundle "${bundleName}".`,
-          { cause: originalError instanceof Error ? originalError : void 0 }
-        );
-      }
-    }
-  };
-}
-var init_remote_scope_setup = __esm({
-  "src/runtime/turbopack/remote-scope-setup.ts"() {
-    "use strict";
-    init_constants2();
-    init_namespace();
-    init_patterns();
-    init_error();
-    init_logger();
-    init_chunk_loader();
-    init_module();
-    init_remote_scope();
-  }
-});
-
-// src/runtime/loaders/script-loader.ts
-async function loadScripts(scripts, resolveClientUrl) {
-  await Promise.all(
-    scripts.map((script) => {
-      return new Promise((resolve, reject) => {
-        const newSrc = new URL(
-          // remove the remote component bundle name identifier from the script src
-          script.src.replace(NEXT_BUNDLE_PATH_RE, "/_next/"),
-          location.origin
-        ).href;
-        const resolvedSrc = resolveClientUrl?.(newSrc) ?? newSrc;
-        const alreadyLoaded = Array.from(
-          document.querySelectorAll("script[src]")
-        ).some((s) => s.src === resolvedSrc);
-        if (alreadyLoaded) {
-          resolve();
-          return;
-        }
-        const newScript = document.createElement("script");
-        newScript.onload = () => resolve();
-        newScript.onerror = () => {
-          const isProxied = isProxiedUrl(resolvedSrc);
-          if (isProxied) {
-            reject(failedProxiedAssetError("script", newSrc, resolvedSrc));
-          } else {
-            warnCrossOriginFetchError("ScriptLoader", newSrc);
-            reject(
-              new RemoteComponentsError(
-                `Failed to load <script src="${newSrc}"> for Remote Component. Check the URL is correct.`
-              )
-            );
-          }
-        };
-        newScript.src = resolvedSrc;
-        newScript.async = true;
-        document.head.appendChild(newScript);
-      });
-    })
-  );
-}
-var init_script_loader = __esm({
-  "src/runtime/loaders/script-loader.ts"() {
-    "use strict";
-    init_patterns();
-    init_protected_rc_fallback();
-    init_error();
-    init_logger();
-  }
-});
-
-// src/runtime/loaders/static-loader.ts
-async function importViaCallback(absoluteSrc, resolveClientUrl) {
-  const resolvedUrl = resolveClientUrl(absoluteSrc) ?? absoluteSrc;
-  const fetchUrl = new URL(resolvedUrl, location.href).href;
-  const response = await fetch(fetchUrl);
-  if (!response.ok)
-    throw new Error(`Proxied fetch failed: ${response.status}`);
-  const content = (await response.text()).replace(/import\.meta\.url/g, JSON.stringify(absoluteSrc)).replace(
-    /\b(from|import)\s*(["'])(\.\.?\/[^"']+)\2/g,
-    (_, keyword, quote, relativePath) => {
-      const absoluteImportUrl = new URL(relativePath, absoluteSrc).href;
-      const resolvedImportUrl = new URL(
-        resolveClientUrl(absoluteImportUrl) ?? absoluteImportUrl,
-        location.href
-      ).href;
-      return `${keyword} ${quote}${resolvedImportUrl}${quote}`;
-    }
-  );
-  const moduleBlobUrl = URL.createObjectURL(
-    new Blob([content], { type: "text/javascript" })
-  );
-  const wrapperContent = [
-    `import*as m from${JSON.stringify(moduleBlobUrl)};`,
-    `globalThis.__rc_module_registry__=globalThis.__rc_module_registry__||{};`,
-    `globalThis.__rc_module_registry__[${JSON.stringify(absoluteSrc)}]=m;`
-  ].join("");
-  const wrapperBlobUrl = URL.createObjectURL(
-    new Blob([wrapperContent], { type: "text/javascript" })
-  );
-  const scriptEl = document.createElement("script");
-  scriptEl.type = "module";
-  scriptEl.src = wrapperBlobUrl;
-  try {
-    await new Promise((resolve, reject) => {
-      scriptEl.onload = () => resolve();
-      scriptEl.onerror = () => reject(new Error(`Failed to load module for ${absoluteSrc}`));
-      document.head.appendChild(scriptEl);
-    });
-  } finally {
-    scriptEl.remove();
-    URL.revokeObjectURL(moduleBlobUrl);
-    URL.revokeObjectURL(wrapperBlobUrl);
-  }
-  const registry = getNamespace().moduleRegistry;
-  const mod = registry[absoluteSrc] ?? {};
-  delete registry[absoluteSrc];
-  return mod;
-}
-async function importDirectly(absoluteSrc) {
-  try {
-    return await import(
-      /* @vite-ignore */
-      /* webpackIgnore: true */
-      absoluteSrc
-    );
-  } catch (importError) {
-    if (!absoluteSrc.startsWith("blob:")) {
-      warnCrossOriginFetchError("StaticLoader", absoluteSrc);
-    }
-    throw importError;
-  }
-}
-function resolveScriptSrc(script, url) {
-  const rawSrc = typeof script.getAttribute === "function" ? script.getAttribute("src") ?? script.src : script.src;
-  if (!rawSrc && script.textContent) {
-    return URL.createObjectURL(
-      new Blob(
-        [script.textContent.replace(/import\.meta\.url/g, JSON.stringify(url))],
-        { type: "text/javascript" }
-      )
-    );
-  }
-  return rawSrc;
-}
-async function loadStaticRemoteComponent(scripts, url, resolveClientUrl) {
-  const ns = getNamespace();
-  if (ns.mountFns[url.href]) {
-    ns.mountFns[url.href] = /* @__PURE__ */ new Set();
-  }
-  if (ns.unmountFns[url.href]) {
-    ns.unmountFns[url.href] = /* @__PURE__ */ new Set();
-  }
-  const mountUnmountSets = await Promise.all(
-    scripts.map(async (script) => {
-      try {
-        const src = resolveScriptSrc(script, url);
-        const absoluteSrc = new URL(src, url).href;
-        const mod = resolveClientUrl ? await importViaCallback(absoluteSrc, resolveClientUrl) : await importDirectly(absoluteSrc);
-        if (src.startsWith("blob:")) {
-          URL.revokeObjectURL(src);
-        }
-        if (typeof mod.mount === "function" || typeof mod.default?.mount === "function") {
-          if (!ns.mountFns[url.href]) {
-            ns.mountFns[url.href] = /* @__PURE__ */ new Set();
-          }
-          ns.mountFns[url.href]?.add(
-            mod.mount || mod.default?.mount || (() => {
-            })
-          );
-        }
-        if (typeof mod.unmount === "function" || typeof mod.default?.unmount === "function") {
-          if (!ns.unmountFns[url.href]) {
-            ns.unmountFns[url.href] = /* @__PURE__ */ new Set();
-          }
-          ns.unmountFns[url.href]?.add(
-            mod.unmount || mod.default?.unmount || (() => {
-            })
-          );
-        }
-        return {
-          mount: mod.mount || mod.default?.mount,
-          unmount: mod.unmount || mod.default?.unmount
-        };
-      } catch (e) {
-        logError(
-          "StaticLoader",
-          `Error loading remote component script from "${script.src || url.href}".`,
-          e
-        );
-        return {
-          mount: void 0,
-          unmount: void 0
-        };
-      }
-    })
-  );
-  return mountUnmountSets.reduce(
-    (acc, { mount, unmount }) => {
-      if (typeof mount === "function") {
-        acc.mount.add(mount);
-      }
-      if (typeof unmount === "function") {
-        acc.unmount.add(unmount);
-      }
-      return acc;
-    },
-    {
-      mount: /* @__PURE__ */ new Set(),
-      unmount: /* @__PURE__ */ new Set()
-    }
-  );
-}
-var init_static_loader = __esm({
-  "src/runtime/loaders/static-loader.ts"() {
-    "use strict";
-    init_namespace();
-    init_logger();
-  }
-});
-
-// src/host/html/runtime/webpack.ts
-var webpack_exports = {};
-__export(webpack_exports, {
-  webpackRuntime: () => webpackRuntime
-});
-async function webpackRuntime(bundle, shared, remoteShared, resolveClientUrl) {
-  const self = globalThis;
-  if (!self.__DISABLE_WEBPACK_EXEC__) {
-    self.__DISABLE_WEBPACK_EXEC__ = {};
-  }
-  self.__DISABLE_WEBPACK_EXEC__[bundle] = true;
-  if (typeof self.__webpack_require__ !== "function" && self.__webpack_require_type__ !== "turbopack") {
-    self.__webpack_require__ = (remoteId) => {
-      const re = /\[(?<bundle>[^\]]+)\] (?<id>.*)/;
-      const match = re.exec(remoteId);
-      const remoteBundle = match?.groups?.bundle;
-      const id = match?.groups?.id;
-      if (!(id && remoteBundle)) {
-        throw new RemoteComponentsError(
-          `Remote Component module "${remoteId}" not found. Did you forget to wrap the Next.js config with \`withRemoteComponentsConfig\` on both host and remote?`
-        );
-      }
-      if (typeof self.__remote_webpack_require__?.[remoteBundle] !== "function") {
-        throw new RemoteComponentsError(
-          `Remote Components are not available in "${remoteBundle}". Did you forget to wrap the Next.js config with \`withRemoteComponentsConfig\` on both host and remote?`
-        );
-      }
-      return self.__remote_webpack_require__[remoteBundle](id);
-    };
-    self.__webpack_chunk_load__ = () => {
-      return Promise.resolve([]);
-    };
-  }
-  const {
-    default: { createFromReadableStream }
-  } = await import("react-server-dom-webpack/client.browser");
-  async function preloadScripts(scripts, url, remoteBundle, _) {
-    const scriptSrcs = scripts.flatMap((script) => {
-      const scriptSrc = script.getAttribute("src") || script.getAttribute("data-src");
-      script.parentElement?.removeChild(script);
-      if (!scriptSrc)
-        return [];
-      return [
-        {
-          src: new URL(scriptSrc.replace(NEXT_BUNDLE_PATH_RE, "/_next/"), url).href
-        }
-      ];
-    });
-    await loadScripts(scriptSrcs, resolveClientUrl);
-    const hostShared = buildHostShared(shared, resolveClientUrl);
-    const resolve = await buildWebpackResolve(
-      hostShared,
-      remoteShared ?? {},
-      remoteBundle,
-      {
-        "/react/index.js": (await import("react")).default,
-        "/react/jsx-dev-runtime.js": (await import("react/jsx-dev-runtime")).default,
-        "/react/jsx-runtime.js": (await import("react/jsx-runtime")).default,
-        "/react-dom/index.js": (await import("react-dom")).default,
-        "/react-dom/client.js": (await import("react-dom/client")).default
-      },
-      "WebpackRuntime"
-    );
-    applySharedModules(remoteBundle, resolve);
-  }
-  return {
-    self,
-    createFromReadableStream,
-    applySharedModules,
-    nextClientPagesLoader,
-    preloadScripts
-  };
-}
-var init_webpack = __esm({
-  "src/host/html/runtime/webpack.ts"() {
-    "use strict";
-    init_apply_shared_modules();
-    init_next_client_pages_loader();
-    init_shared_module_resolver();
-    init_script_loader();
-    init_patterns();
-    init_error();
-  }
-});
-
-// src/host/html/runtime/turbopack.ts
-var turbopack_exports = {};
-__export(turbopack_exports, {
-  turbopackRuntime: () => turbopackRuntime
-});
-async function turbopackRuntime(url, bundle, shared, remoteShared, resolveClientUrl) {
-  const self = globalThis;
-  const hostShared = buildHostShared(shared, resolveClientUrl, {
-    includeRemoteComponentShared: true
-  });
-  await setupRemoteScope("turbopack", [], url, bundle, resolveClientUrl);
-  const {
-    default: { createFromReadableStream }
-  } = await import("react-server-dom-webpack/client.browser");
-  async function preloadScripts(scripts, __) {
-    const scope = await setupRemoteScope(
-      "turbopack",
-      scripts.map((script) => ({
-        src: script.getAttribute("src") || script.getAttribute("data-src") || script.src
-      })),
-      url,
-      bundle,
-      resolveClientUrl
-    );
-    await initializeSharedModules(
-      scope,
-      buildCoreShared(hostShared),
-      remoteShared ?? {}
-    );
-  }
-  return {
-    self,
-    createFromReadableStream,
-    applySharedModules,
-    nextClientPagesLoader,
-    preloadScripts
-  };
-}
-var init_turbopack = __esm({
-  "src/host/html/runtime/turbopack.ts"() {
-    "use strict";
-    init_apply_shared_modules();
-    init_next_client_pages_loader();
-    init_shared_module_resolver();
-    init_remote_scope_setup();
-    init_shared_modules();
-  }
-});
-
-// src/host/html/runtime/script.ts
-var script_exports = {};
-__export(script_exports, {
-  scriptRuntime: () => scriptRuntime
-});
-function scriptRuntime(resolveClientUrl) {
-  const self = globalThis;
-  return {
-    self,
-    createFromReadableStream: () => Promise.resolve(null),
-    applySharedModules: () => Promise.resolve(),
-    nextClientPagesLoader: () => ({
-      Component: null,
-      App: null
-    }),
-    preloadScripts: (scripts, url) => loadStaticRemoteComponent(scripts, url, resolveClientUrl)
-  };
-}
-var init_script = __esm({
-  "src/host/html/runtime/script.ts"() {
-    "use strict";
-    init_static_loader();
-  }
-});
+import {
+  bindResolveClientUrl,
+  createHostState,
+  createRSCStream,
+  fetchWithHooks,
+  getClientOrServerUrl,
+  makeEventEmitter,
+  preparePipeline,
+  resolveNameFromSrc
+} from "../chunk-42N2ZLE2.js";
+import "../chunk-ZPMTZ3KJ.js";
+import "../chunk-KYJWRZ2B.js";
+import "../chunk-2VQGCACH.js";
+import "../chunk-OO4AMJWO.js";
+import {
+  DEFAULT_BUNDLE_NAME,
+  DEFAULT_COMPONENT_NAME,
+  escapeString
+} from "../chunk-HNZVEIKN.js";
+import {
+  getNamespace
+} from "../chunk-KEPHL25S.js";
+import {
+  RemoteComponentsError,
+  errorFromFailedFetch,
+  isAbortError,
+  logError
+} from "../chunk-S2A4TFLS.js";
+import "../chunk-GAXJTFBV.js";
+import "../chunk-X6YKUJKH.js";
+import "../chunk-ENYGL5CO.js";
 
 // src/host/html/index.tsx
 import { startTransition, useLayoutEffect } from "react";
 import { hydrateRoot } from "react-dom/client";
 
-// src/host/server/fetch-with-hooks.ts
-init_logger();
-
-// src/host/server/fetch-headers.ts
-function remoteFetchHeaders() {
-  return {
-    /**
-     * Authenticates deployment protection for the remote. Needed for SSR and SSG clients.
-     * If the remote component uses vercel deployment protection, ensure the host and remote vercel
-     * projects share a common automation bypass secret, and the shared secret is used as the
-     * VERCEL_AUTOMATION_BYPASS_SECRET env var in the host project.
-     */
-    ...typeof process === "object" && typeof process.env === "object" && typeof process.env.VERCEL_AUTOMATION_BYPASS_SECRET === "string" ? {
-      "x-vercel-protection-bypass": process.env.VERCEL_AUTOMATION_BYPASS_SECRET
-    } : {},
-    Accept: "text/html"
-  };
-}
-
-// 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 makeEventEmitter(element) {
-  function dispatch(type, detail) {
-    const event = new Event(type, { bubbles: true, composed: true });
-    if (detail) {
-      Object.assign(event, detail);
-    }
-    element.dispatchEvent(event);
-  }
-  return {
-    beforeLoad(src) {
-      dispatch("beforeload", { src });
-    },
-    load(src) {
-      dispatch("load", { src });
-    },
-    error(error, src) {
-      dispatch("error", src != null ? { error, src } : { error });
-    },
-    change(info) {
-      dispatch("change", info);
-    }
-  };
-}
-
-// src/host/shared/pipeline.ts
-init_shared_module_resolver();
-
-// 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/html/parse-remote-html.ts
-init_constants2();
-
-// src/runtime/metadata.ts
-init_constants2();
-var VALID_RUNTIMES = /* @__PURE__ */ new Set(["webpack", "turbopack", "script"]);
-var VALID_TYPES = /* @__PURE__ */ new Set([
-  "nextjs",
-  "remote-component",
-  "unknown"
-]);
-function isRuntime(value) {
-  return VALID_RUNTIMES.has(value);
-}
-function isComponentType(value) {
-  return VALID_TYPES.has(value);
-}
-function toRuntime(value) {
-  return value && isRuntime(value) ? value : "webpack";
-}
-function toComponentType(value) {
-  return value && isComponentType(value) ? value : "unknown";
-}
-function buildMetadata(attrs, url) {
-  const id = attrs.id || DEFAULT_COMPONENT_NAME;
-  const bundle = attrs.bundle || process.env.NEXT_PUBLIC_MFE_CURRENT_APPLICATION || DEFAULT_BUNDLE_NAME;
-  return {
-    name: attrs.name || id.replace(/_ssr$/, ""),
-    bundle,
-    route: attrs.route || url.pathname || DEFAULT_ROUTE,
-    runtime: toRuntime(attrs.runtime),
-    id,
-    type: toComponentType(attrs.type)
-  };
-}
-
-// src/runtime/html/parse-remote-html.ts
-init_error();
-function validateSingleComponent(doc, name, url) {
-  if (doc.querySelectorAll(`div[${DATA_BUNDLE}][${DATA_ROUTE}]`).length > 1 && !doc.querySelector(
-    `div[${DATA_BUNDLE}][${DATA_ROUTE}][id^="${name}"]`
-  ) || doc.querySelectorAll(`${TAG_REMOTE_COMPONENT}:not([src])`).length > 1 && !doc.querySelector(`${TAG_REMOTE_COMPONENT}[name="${name}"]`)) {
-    throw multipleRemoteComponentsError(url);
-  }
-}
-function findComponentElement(doc, name) {
-  return doc.querySelector(`div[${DATA_BUNDLE}][${DATA_ROUTE}][id^="${name}"]`) ?? doc.querySelector(`div[${DATA_BUNDLE}][${DATA_ROUTE}]`) ?? doc.querySelector(`div#${NEXT_CONTAINER_ID}`) ?? doc.querySelector(`${TAG_REMOTE_COMPONENT}[name="${name}"]:not([src])`) ?? doc.querySelector(`${TAG_REMOTE_COMPONENT}:not([src])`);
-}
-function parseNextData(doc) {
-  return JSON.parse(
-    (doc.querySelector(`#${NEXT_DATA_ID}`) ?? doc.querySelector(`#${REMOTE_NEXT_DATA_ID}`))?.textContent ?? "null"
-  );
-}
-function resolveComponentName(component, nextData, fallbackName) {
-  const isRemoteComponent = component?.tagName.toLowerCase() === TAG_REMOTE_COMPONENT;
-  const name = component?.getAttribute("id")?.replace(new RegExp(`${ID_SUFFIX_SSR}$`), "") || isRemoteComponent && component?.getAttribute("name") || (nextData ? "__next" : fallbackName);
-  return { name, isRemoteComponent };
-}
-function extractRemoteShared(doc, name, nextData) {
-  const remoteSharedEl = doc.querySelector(
-    `#${name}${ID_SUFFIX_SHARED}[${DATA_REMOTE_COMPONENTS_SHARED}]`
-  );
-  const remoteShared = nextData?.props.__REMOTE_COMPONENT__?.shared ?? (JSON.parse(remoteSharedEl?.textContent ?? "{}") ?? {});
-  remoteSharedEl?.remove();
-  return remoteShared;
-}
-function validateComponentFound(component, rsc, nextData, isRemoteComponent, url, name) {
-  if (!component || !(rsc || nextData || isRemoteComponent)) {
-    throw new RemoteComponentsError(
-      `Remote Component not found on ${url}.${name !== DEFAULT_COMPONENT_NAME ? ` The name for the <RemoteComponent> is "${name}". Check <RemoteComponent> usage.` : ""} Did you forget to wrap the content in <RemoteComponent>?`
-    );
-  }
-}
-function extractLinks(doc, component) {
-  return Array.from(doc.querySelectorAll("link[href]")).filter(
-    (link) => !component.contains(link)
-  );
-}
-function extractScripts(doc, component, isRemoteComponent) {
-  return Array.from(
-    (isRemoteComponent ? component : doc).querySelectorAll(
-      `script[src],script[${DATA_SRC}]`
-    )
-  );
-}
-function parseRemoteComponentDocument(doc, name, url) {
-  validateSingleComponent(doc, name, url.href);
-  const component = findComponentElement(doc, name);
-  const nextData = parseNextData(doc);
-  const { name: resolvedName, isRemoteComponent } = resolveComponentName(
-    component,
-    nextData,
-    name
-  );
-  const rsc = doc.querySelector(`#${resolvedName}${ID_SUFFIX_RSC}`);
-  const metadata = buildMetadata(
-    {
-      name: resolvedName,
-      bundle: component?.getAttribute(DATA_BUNDLE) || nextData?.props.__REMOTE_COMPONENT__?.bundle,
-      route: component?.getAttribute(DATA_ROUTE) ?? nextData?.page,
-      runtime: component?.getAttribute(DATA_RUNTIME) ?? nextData?.props.__REMOTE_COMPONENT__?.runtime ?? RUNTIME_SCRIPT,
-      id: component?.getAttribute("id"),
-      type: component?.getAttribute(DATA_TYPE)
-    },
-    url
-  );
-  const remoteShared = extractRemoteShared(doc, resolvedName, nextData);
-  validateComponentFound(
-    component,
-    rsc,
-    nextData,
-    isRemoteComponent,
-    url.href,
-    resolvedName
-  );
-  const links = extractLinks(doc, component);
-  const scripts = extractScripts(doc, component, isRemoteComponent);
-  return {
-    component,
-    name: resolvedName,
-    isRemoteComponent,
-    metadata,
-    nextData,
-    rsc,
-    remoteShared,
-    links,
-    scripts
-  };
-}
-
-// src/runtime/loaders/component-loader.ts
-init_apply_shared_modules();
-init_next_client_pages_loader();
-init_shared_module_resolver();
-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/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/loaders/component-loader.ts
-init_remote_scope_setup();
-init_shared_modules();
-init_error();
-init_logger();
-init_script_loader();
-
-// src/host/shared/pipeline.ts
-init_static_loader();
-init_patterns();
-init_utils();
-init_error();
-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 };
-}
-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
-    };
-  });
-}
-
-// src/host/shared/state.ts
-function createHostState() {
-  return {
-    stage: "idle",
-    prevSrc: void 0,
-    prevUrl: void 0,
-    prevName: void 0,
-    prevIsRemoteComponent: false,
-    abortController: void 0
-  };
-}
-
-// src/host/utils/resolve-name-from-src.ts
-function resolveNameFromSrc(src, defaultName) {
-  if (!src) {
-    return defaultName;
-  }
-  const hash = typeof src === "string" ? src : src.hash;
-  const hashIndex = hash.indexOf("#");
-  if (hashIndex < 0) {
-    return defaultName;
-  }
-  const name = hash.slice(hashIndex + 1);
-  return name || defaultName;
-}
-
-// src/host/html/index.tsx
-init_constants2();
-init_namespace();
-
-// 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/html/index.tsx
-init_utils();
-init_abort();
-init_error();
-init_logger();
-
 // src/host/html/attach-styles.ts
-init_error();
 async function attachStyles({
   doc,
   component,
@@ -2453,7 +117,6 @@ async function attachStyles({
 }
 
 // src/host/html/runtime/index.ts
-init_error();
 async function getRuntime(type, url, bundle, shared, remoteShared, resolveClientUrl) {
   if (typeof globalThis.process === "undefined") {
     globalThis.process = {
@@ -2461,11 +124,11 @@ async function getRuntime(type, url, bundle, shared, remoteShared, resolveClient
     };
   }
   if (type === "webpack") {
-    const { webpackRuntime: webpackRuntime2 } = await Promise.resolve().then(() => (init_webpack(), webpack_exports));
-    return webpackRuntime2(bundle, shared, remoteShared, resolveClientUrl);
+    const { webpackRuntime } = await import("../webpack-DUBHPYD6.js");
+    return webpackRuntime(bundle, shared, remoteShared, resolveClientUrl);
   } else if (type === "turbopack") {
-    const { turbopackRuntime: turbopackRuntime2 } = await Promise.resolve().then(() => (init_turbopack(), turbopack_exports));
-    return turbopackRuntime2(
+    const { turbopackRuntime } = await import("../turbopack-NPGO3MWS.js");
+    return turbopackRuntime(
       url,
       bundle,
       shared,
@@ -2473,8 +136,8 @@ async function getRuntime(type, url, bundle, shared, remoteShared, resolveClient
       resolveClientUrl
     );
   } else if (type === "script") {
-    const { scriptRuntime: scriptRuntime2 } = await Promise.resolve().then(() => (init_script(), script_exports));
-    return scriptRuntime2(resolveClientUrl);
+    const { scriptRuntime } = await import("../script-IFEBOLIA.js");
+    return scriptRuntime(resolveClientUrl);
   }
   throw new RemoteComponentsError(
     `Remote Components runtime "${type}" is not supported. Supported runtimes are "webpack", "turbopack", and "script".`
@@ -2482,7 +145,7 @@ async function getRuntime(type, url, bundle, shared, remoteShared, resolveClient
 }
 
 // src/host/html/index.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 if (typeof HTMLElement !== "undefined") {
   class RemoteComponent extends HTMLElement {
     name = DEFAULT_COMPONENT_NAME;
@@ -2834,7 +497,7 @@ if (typeof HTMLElement !== "undefined") {
       const {
         self,
         createFromReadableStream,
-        nextClientPagesLoader: nextClientPagesLoader2,
+        nextClientPagesLoader,
         preloadScripts
       } = await getRuntime(
         metadataObj.runtime,
@@ -2937,7 +600,7 @@ if (typeof HTMLElement !== "undefined") {
           const root = this.reactRoot;
           startTransition(() => {
             root.render(
-              /* @__PURE__ */ jsx2(
+              /* @__PURE__ */ jsx(
                 RemoteComponentFromReadableStream,
                 {
                   initial: false,
@@ -2952,10 +615,10 @@ if (typeof HTMLElement !== "undefined") {
           // hydrateRoot expects a document or element, but it works for the shadow DOM too
           // @ts-expect-error support for shadow DOM
           this.root,
-          /* @__PURE__ */ jsx2(RemoteComponentFromReadableStream, { initial: true, name: this.name })
+          /* @__PURE__ */ jsx(RemoteComponentFromReadableStream, { initial: true, name: this.name })
         );
       } else if (nextData) {
-        const { Component, App } = nextClientPagesLoader2(
+        const { Component, App } = nextClientPagesLoader(
           this.bundle,
           nextData.page ?? "/",
           this.root
@@ -2975,12 +638,12 @@ if (typeof HTMLElement !== "undefined") {
               }
               remoteComponent.emitter.load(remoteComponent.src ?? "");
             }, [initial, remoteComponent]);
-            return NextApp ? /* @__PURE__ */ jsx2(NextApp, { Component: NextComponent, ...nextData.props }) : /* @__PURE__ */ jsx2(NextComponent, { ...nextData.props });
+            return NextApp ? /* @__PURE__ */ jsx(NextApp, { Component: NextComponent, ...nextData.props }) : /* @__PURE__ */ jsx(NextComponent, { ...nextData.props });
           })(App, Component, this);
           if (this.reactRoot) {
             const root = this.reactRoot;
             startTransition(() => {
-              root.render(/* @__PURE__ */ jsx2(RemoteComponentFromNext, { initial: false }));
+              root.render(/* @__PURE__ */ jsx(RemoteComponentFromNext, { initial: false }));
               doCleanup();
               if (isCurrentLoad()) {
                 this.hostState.stage = "loaded";
@@ -2992,7 +655,7 @@ if (typeof HTMLElement !== "undefined") {
             // hydrateRoot expects a document or element, but it works for the shadow DOM too
             // @ts-expect-error support for shadow DOM
             this.root,
-            /* @__PURE__ */ jsx2(RemoteComponentFromNext, { initial: true })
+            /* @__PURE__ */ jsx(RemoteComponentFromNext, { initial: true })
           );
         }
         if (this.fouc) {