remote-components 0.1.0 → 0.2.0

package/dist/internal/shared/client/remote-component.js

@@ -1,1385 +0,0 @@
-// src/shared/constants.ts
-var RC_PROTECTED_REMOTE_FETCH_PATHNAME = "/rc-fetch-protected-remote";
-var CORS_DOCS_URL = "https://vercel.com/docs/remote-components/concepts/cors-external-urls#accessing-cross-site-protected-remote-components";
-
-// src/shared/client/protected-rc-fallback.ts
-function generateProtectedRcFallbackSrc(url) {
-  return `${RC_PROTECTED_REMOTE_FETCH_PATHNAME}?url=${encodeURIComponent(url)}`;
-}
-function isProxiedUrl(url) {
-  try {
-    return new URL(url, location.href).pathname === RC_PROTECTED_REMOTE_FETCH_PATHNAME;
-  } catch {
-    return false;
-  }
-}
-
-// src/shared/error.ts
-var RemoteComponentsError = class extends Error {
-  code = "REMOTE_COMPONENTS_ERROR";
-  constructor(message, options) {
-    super(message, options);
-    this.name = "RemoteComponentsError";
-  }
-};
-
-// src/shared/client/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/shared/utils/logger.ts
-var PREFIX = "remote-components";
-var DEBUG = typeof window !== "undefined" && localStorage.getItem("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}". If this is a protected deployment, ensure withRemoteComponentsHost middleware is configured in your host and that the remote URL is included in allowedProxyUrls. See: ${CORS_DOCS_URL}`
-    );
-  } catch {
-  }
-}
-
-// src/shared/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();
-    if (!self.__remote_next_css__) {
-      self.__remote_next_css__ = {};
-    }
-    if (!self.__remote_next_css__[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;
-      }
-      self.__remote_next_css__[bundle] = elements;
-    }
-    if (styleContainer) {
-      const elements = self.__remote_next_css__[bundle];
-      elements.forEach((el) => {
-        styleContainer.appendChild(el.cloneNode(true));
-      });
-    } else {
-      const elements = self.__remote_next_css__[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/shared/webpack/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;
-  if (self.__remote_webpack_require__?.[bundle]) {
-    const modulePaths = Object.keys(
-      self.__remote_webpack_module_map__?.[bundle] ?? self.__remote_webpack_require__[bundle].m ?? {}
-    );
-    logDebug(
-      "SharedModules",
-      `Available module paths in __remote_webpack_require__[${bundle}]: ${modulePaths}`
-    );
-    for (const [key, value] of Object.entries(resolve)) {
-      let ids = modulePaths.filter((p) => p === key);
-      if (ids.length === 0) {
-        ids = modulePaths.filter((p) => p.includes(key));
-      }
-      if (ids.length === 0) {
-        logDebug(
-          "SharedModules",
-          `No matching module path found for shared module "${key}"`
-        );
-      }
-      for (let id of ids) {
-        const webpackBundle = self.__remote_webpack_require__[bundle];
-        if (webpackBundle.m) {
-          if (self.__remote_webpack_module_map__?.[bundle]?.[id]) {
-            const mappedId = `${self.__remote_webpack_module_map__[bundle][id]}`;
-            logDebug(
-              "SharedModules",
-              `Mapped module id: "${id}" -> "${mappedId}"`
-            );
-            id = mappedId;
-          }
-          webpackBundle.m[id] = (module) => {
-            module.exports = value;
-          };
-        } else {
-          logWarn(
-            "SharedModules",
-            `webpackBundle.m is not available for bundle "${bundle}"`
-          );
-        }
-      }
-    }
-  } else {
-    logWarn("SharedModules", `No webpack require found for bundle "${bundle}"`);
-    logDebug(
-      "SharedModules",
-      `Available bundles: ${Object.keys(self.__remote_webpack_require__ ?? {})}`
-    );
-  }
-}
-
-// src/shared/client/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 createRSCStream(rscName, data) {
-  return new ReadableStream({
-    type: "bytes",
-    start(controller) {
-      const encoder = new TextEncoder();
-      const self = globalThis;
-      if (data.length > 0) {
-        data.forEach((chunk) => {
-          const lines = chunk.split("\n");
-          for (const line of lines) {
-            const match = /\.push\("(?<rsc>.*)"\);$/.exec(line);
-            if (match?.groups?.rsc) {
-              self[rscName] = self[rscName] ?? [];
-              self[rscName].push(JSON.parse(`"${match.groups.rsc}"`));
-            }
-          }
-        });
-      }
-      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/shared/client/webpack-patterns.ts
-var NEXT_BUNDLE_PATH_RE = /\/_next\/\[.+\](?:%20| )/;
-
-// src/shared/client/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 newScript = document.createElement("script");
-        newScript.onload = () => resolve();
-        newScript.onerror = () => {
-          const isProxied = isProxiedUrl(resolvedSrc);
-          if (isProxied) {
-            reject(
-              new RemoteComponentsError(
-                `Failed to load script "${newSrc}" via proxy "${resolvedSrc}". Ensure withRemoteComponentsHost middleware is configured and "${RC_PROTECTED_REMOTE_FETCH_PATHNAME}" is in the matcher. See: ${CORS_DOCS_URL}`
-              )
-            );
-          } 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/shared/utils/index.ts
-function escapeString(str) {
-  return str.replace(/[^a-z0-9]/g, "_");
-}
-
-// src/shared/client/const.ts
-var DEFAULT_ROUTE = "/";
-var RUNTIME_WEBPACK = "webpack";
-var RUNTIME_TURBOPACK = "turbopack";
-var RUNTIME_SCRIPT = "script";
-var REMOTE_COMPONENT_REGEX = /(?<prefix>.*?)\[(?<bundle>[^\]]+)\](?:%20| )(?<id>.+)/;
-function getBundleKey(bundle) {
-  return escapeString(bundle);
-}
-
-// src/shared/client/turbopack-patterns.ts
-var REMOTE_SHARED_MARKER_RE = /(?:self|[a-z])\.TURBOPACK_REMOTE_SHARED/;
-var REMOTE_SHARED_ASSIGNMENT_RE = /\.TURBOPACK_REMOTE_SHARED=await (?:__turbopack_context__|e)\.A\((?<sharedModuleId>[0-9]+)\)/;
-var ASYNC_MODULE_LOADER_RE = /(?:__turbopack_context__|e)\.A\((?<asyncSharedModuleId>[0-9]+)\)/;
-var ASYNC_MODULE_RESOLVE_RE = /(?<ctx>__turbopack_context__|e)=>\{\k<ctx>\.v\((?<inner>parentImport|e)=>Promise\.resolve\(\)\.then\(\(\)=>\k<inner>\((?<sharedModuleId>[0-9]+)\)\)\)\}/;
-var ASYNC_MODULE_ALL_RE = /(?<ctx>__turbopack_context__|e)=>\{\k<ctx>\.v\((?<vCb>parentImport|t)=>Promise\.all\(\["[^"]+"\]\.map\((?<mapCb>chunk|t)=>\k<ctx>\.l\(\k<mapCb>\)\)\)\.then\(\(\)=>\k<vCb>\((?<sharedModuleId>[0-9]+)\)\)\)\}/;
-var TURBOPACK_GLOBAL_RE = /(?:globalThis|self)\s*(?:\.TURBOPACK|\[\s*["']TURBOPACK["']\s*\])/;
-
-// src/shared/client/chunk-loader.ts
-function createChunkLoader(runtime, resolveClientUrl) {
-  return function __turbopack_chunk_load__(chunkId, scriptBundle) {
-    logDebug("ChunkLoader", `Loading chunk: "${chunkId}"`);
-    const self = globalThis;
-    const {
-      bundle,
-      id: path,
-      prefix
-    } = REMOTE_COMPONENT_REGEX.exec(chunkId)?.groups ?? {
-      bundle: scriptBundle ?? "",
-      id: chunkId
-    };
-    logDebug(
-      "ChunkLoader",
-      `Parsed chunk - bundle: "${bundle}", path: "${path}", prefix: "${prefix}"`
-    );
-    const remoteRuntime = self.__remote_webpack_require__?.[bundle ?? "default"] ? self.__remote_webpack_require__[bundle ?? "default"]?.type || "webpack" : runtime;
-    logDebug("ChunkLoader", `Remote runtime: "${remoteRuntime}"`);
-    if (remoteRuntime === RUNTIME_WEBPACK) {
-      logDebug("ChunkLoader", "Skipping chunk load - webpack runtime detected");
-      return Promise.resolve(void 0);
-    }
-    const url = new URL(
-      path ? `${prefix ?? ""}${path}`.replace(
-        /(?<char>[^:])(?<double>\/\/)/g,
-        "$1/"
-      ) : "/",
-      self.__remote_bundle_url__?.[bundle ?? "default"] ?? new URL(location.origin)
-    ).href;
-    if (url.endsWith(".css")) {
-      logDebug("ChunkLoader", `Skipping CSS file: "${url}"`);
-      return;
-    }
-    if (!self.__remote_components_turbopack_chunk_loader_promise__) {
-      self.__remote_components_turbopack_chunk_loader_promise__ = {};
-    }
-    if (self.__remote_components_turbopack_chunk_loader_promise__[url]) {
-      logDebug("ChunkLoader", `Returning cached promise for: "${url}"`);
-      return self.__remote_components_turbopack_chunk_loader_promise__[url];
-    }
-    const resolvedUrl = resolveClientUrl?.(url) ?? url;
-    logDebug("ChunkLoader", `Fetching chunk from: "${resolvedUrl}"`);
-    self.__remote_components_turbopack_chunk_loader_promise__[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, bundle ?? "", url);
-        }
-        logDebug(
-          "ChunkLoader",
-          `Chunk does not contain globalThis.TURBOPACK or self.TURBOPACK: "${url}"`
-        );
-        logDebug(
-          "ChunkLoader",
-          `First 500 chars of chunk: ${code.slice(0, 500)}`
-        );
-      }).then(resolve).catch((error) => {
-        const isProxied = isProxiedUrl(resolvedUrl);
-        if (isProxied) {
-          reject(
-            new RemoteComponentsError(
-              `Failed to load chunk "${url}" via proxy "${resolvedUrl}". Ensure withRemoteComponentsHost middleware is configured and "${RC_PROTECTED_REMOTE_FETCH_PATHNAME}" is in the matcher. See: ${CORS_DOCS_URL}`
-            )
-          );
-        } else {
-          warnCrossOriginFetchError("ChunkLoader", url);
-          reject(error);
-        }
-      });
-    });
-    return self.__remote_components_turbopack_chunk_loader_promise__[url];
-  };
-}
-async function handleTurbopackChunk(code, bundle, url) {
-  logDebug(
-    "ChunkLoader",
-    `Handling Turbopack chunk - bundle: "${bundle}", url: "${url}"`
-  );
-  if (/importScripts\(\.\.\.self.TURBOPACK_NEXT_CHUNK_URLS/.test(code)) {
-    logDebug("ChunkLoader", `Skipping worker chunk: "${url}"`);
-    const preloadLinks = document.querySelectorAll(
-      `link[rel="preload"][href="${new URL(url).pathname}"]`
-    );
-    preloadLinks.forEach((preloadLink) => preloadLink.remove());
-    return;
-  }
-  const self = globalThis;
-  const bundleKey = getBundleKey(bundle);
-  logDebug("ChunkLoader", `Bundle key: "${bundleKey}"`);
-  const transformedCode = code.replace(
-    /globalThis\[\s*["']TURBOPACK["']\s*\]/g,
-    `globalThis["TURBOPACK_${bundleKey}"]`
-  ).replace(
-    /self\[\s*["']TURBOPACK["']\s*\]/g,
-    `self["TURBOPACK_${bundleKey}"]`
-  ).replace(/globalThis\.TURBOPACK/g, `globalThis.TURBOPACK_${bundleKey}`).replace(/self\.TURBOPACK(?!_)/g, `self.TURBOPACK_${bundleKey}`).replace(
-    /TURBOPACK_WORKER_LOCATION/g,
-    `TURBOPACK_WORKER_LOCATION_${bundleKey}`
-  ).replace(
-    /TURBOPACK_NEXT_CHUNK_URLS/g,
-    `TURBOPACK_NEXT_CHUNK_URLS_${bundleKey}`
-  ).replace(
-    /TURBOPACK_CHUNK_UPDATE_LISTENERS/g,
-    `TURBOPACK_CHUNK_UPDATE_LISTENERS_${bundleKey}`
-  ).replace(/__next_require__/g, `__${bundleKey}_next_require__`).replace(
-    /\/\/# sourceMappingURL=(?<name>.+)(?<optional>\._)?\.js\.map/g,
-    `//# sourceMappingURL=${new URL(
-      ".",
-      new URL(
-        url,
-        self.__remote_bundle_url__?.[bundle] ?? new URL(location.origin)
-      )
-    ).href}$1$2.js.map`
-  );
-  if (!self[`TURBOPACK_${bundleKey}`]) {
-    const chunkData = [];
-    const turbopackObject = {
-      push: (item) => {
-        logDebug(
-          "ChunkLoader",
-          `TURBOPACK_${bundleKey}.push() called with item type: ${Array.isArray(item) ? "array" : typeof item}`
-        );
-        if (Array.isArray(item)) {
-          chunkData.push(item);
-          logDebug(
-            "ChunkLoader",
-            `TURBOPACK_${bundleKey} now has ${chunkData.length} chunks`
-          );
-        } else {
-          chunkData.push([item]);
-        }
-        return chunkData.length;
-      },
-      // Store chunks for later access
-      __chunks__: chunkData
-    };
-    self[`TURBOPACK_${bundleKey}`] = turbopackObject;
-  }
-  logDebug("ChunkLoader", `Creating blob script for: "${url}"`);
-  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);
-      logDebug(
-        "ChunkLoader",
-        `Script loaded successfully for bundle "${bundle}"`
-      );
-      const turbopackBundle = self[`TURBOPACK_${bundleKey}`];
-      logDebug(
-        "ChunkLoader",
-        `TURBOPACK_${bundleKey} type: ${typeof turbopackBundle}, isArray: ${Array.isArray(turbopackBundle)}, keys: ${turbopackBundle ? Object.keys(turbopackBundle).slice(0, 10).join(", ") : "none"}`
-      );
-      if (turbopackBundle && typeof turbopackBundle === "object") {
-        logDebug(
-          "ChunkLoader",
-          `TURBOPACK_${bundleKey} length/size: ${Array.isArray(turbopackBundle) ? turbopackBundle.length : Object.keys(turbopackBundle).length}`
-        );
-      }
-      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_${bundleKey}_CHUNK_LISTS`];
-  logDebug(
-    "ChunkLoader",
-    `Processing chunk lists for bundle "${bundle}": ${chunkLists?.length ?? 0} lists`
-  );
-  const loadChunkLists = [];
-  while (chunkLists?.length) {
-    const { chunks } = chunkLists.shift() ?? { chunks: [] };
-    if (chunks.length > 0) {
-      logDebug(
-        "ChunkLoader",
-        `Loading ${chunks.length} additional chunks for bundle "${bundle}": [${chunks.join(", ")}]`
-      );
-      chunks.forEach((id) => {
-        const chunkLoadResult = self.__webpack_chunk_load__?.(
-          `[${bundle}] ${url.slice(0, url.indexOf("/_next"))}/_next/${id}`
-        );
-        if (chunkLoadResult) {
-          loadChunkLists.push(chunkLoadResult);
-        }
-      });
-    }
-  }
-  if (loadChunkLists.length > 0) {
-    logDebug(
-      "ChunkLoader",
-      `Waiting for ${loadChunkLists.length} additional chunks to load`
-    );
-    await Promise.all(loadChunkLists);
-  }
-}
-
-// src/shared/client/turbopack-module.ts
-function handleTurbopackModule(bundle, moduleId, id) {
-  const self = globalThis;
-  const bundleKey = getBundleKey(bundle);
-  const raw = self[`TURBOPACK_${bundleKey}`];
-  let modules;
-  if (raw && typeof raw === "object" && "__chunks__" in raw) {
-    modules = raw.__chunks__.flat();
-  } else if (Array.isArray(raw)) {
-    modules = raw.flat();
-  } else {
-    modules = raw;
-  }
-  if (!self.__remote_components_turbopack_modules__) {
-    self.__remote_components_turbopack_modules__ = {};
-  }
-  if (!self.__remote_components_turbopack_modules__[bundle]) {
-    self.__remote_components_turbopack_modules__[bundle] = {};
-  }
-  if (self.__remote_components_turbopack_modules__[bundle][moduleId]) {
-    return self.__remote_components_turbopack_modules__[bundle][moduleId];
-  }
-  if (!modules) {
-    logError("TurbopackModule", `TURBOPACK_${bundleKey} is undefined`);
-  }
-  const moduleInit = findModuleInit(modules, moduleId);
-  const exports = {};
-  const moduleExports = { exports };
-  if (typeof moduleInit !== "function") {
-    throw new Error(
-      `Module ${id} not found in bundle ${bundle} with id ${moduleId}`
-    );
-  }
-  self.__remote_components_turbopack_modules__[bundle][moduleId] = moduleExports.exports;
-  if (!self.__remote_components_turbopack_global__) {
-    self.__remote_components_turbopack_global__ = {};
-  }
-  if (!self.__remote_components_turbopack_global__[bundle]) {
-    self.__remote_components_turbopack_global__[bundle] = {};
-  }
-  moduleInit(
-    createTurbopackContext(
-      bundle,
-      exports,
-      moduleExports,
-      modules,
-      moduleInit,
-      id,
-      self
-    ),
-    moduleExports,
-    exports
-  );
-  if (self.__remote_components_turbopack_modules__[bundle][moduleId] !== moduleExports.exports) {
-    self.__remote_components_turbopack_modules__[bundle][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");
-  }
-  return flat.find(
-    (e) => Boolean(e && typeof e === "object" && moduleId in e)
-  )?.[moduleId];
-}
-function createTurbopackContext(bundle, exports, moduleExports, modules, moduleInit, id, self) {
-  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 (!self.__remote_components_turbopack_modules__) {
-          self.__remote_components_turbopack_modules__ = {};
-        }
-        if (!self.__remote_components_turbopack_modules__[bundle]) {
-          self.__remote_components_turbopack_modules__[bundle] = {};
-        }
-        if (!self.__remote_components_turbopack_modules__[bundle][esmId]) {
-          self.__remote_components_turbopack_modules__[bundle][esmId] = {};
-        }
-        mod = self.__remote_components_turbopack_modules__[bundle][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
-    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 = self.__webpack_require__?.(`[${bundle}] ${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 = self.__webpack_require__?.(`[${bundle}] ${importId}`);
-      }
-      if (typeof mod !== "object" || mod === null) {
-        mod = { default: mod };
-      } else if (!("default" in mod) && mod.toString() !== "[object Module]") {
-        try {
-          mod.default = mod;
-        } catch {
-        }
-      }
-      return mod;
-    },
-    // require
-    r(requireId) {
-      return self.__webpack_require__?.(`[${bundle}] ${requireId}`);
-    },
-    // value exports
-    v(value) {
-      if (typeof value === "function") {
-        exports.default = value((vid) => {
-          return self.__webpack_require__?.(`[${bundle}] ${vid}`);
-        });
-      } else {
-        moduleExports.exports = value;
-      }
-    },
-    // async module initializer
-    async a(mod) {
-      let result;
-      await mod(
-        () => {
-        },
-        (value) => result = value
-      );
-      exports.default = result;
-    },
-    // async module loader
-    async A(Aid) {
-      const mod = self.__webpack_require__?.(`[${bundle}] ${Aid}`);
-      return mod.default(
-        (parentId) => self.__webpack_require__?.(`[${bundle}] ${parentId}`)
-      );
-    },
-    // dynamic import tracking — no-op for remote components
-    j() {
-    },
-    // chunk loader
-    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 bundleUrl = `[${bundle}] ${baseUrl}/_next/${url}`;
-          return self.__webpack_chunk_load__?.(bundleUrl, bundle);
-        }
-      }
-      throw new Error(
-        `Failed to load Turbopack chunk "${url}" for module "${id}". Check the URL is correct.`
-      );
-    },
-    // global object for this bundle
-    g: self.__remote_components_turbopack_global__?.[bundle],
-    m: moduleExports,
-    e: exports
-  };
-}
-
-// src/shared/client/shared-modules.ts
-async function initializeSharedModules(bundle, hostShared = {}, remoteShared = {}) {
-  const self = globalThis;
-  self.__remote_shared_modules__ = self.__remote_shared_modules__ ?? {};
-  if (!self.__remote_shared_modules__[bundle]) {
-    self.__remote_shared_modules__[bundle] = {};
-  }
-  const bundleKey = getBundleKey(bundle);
-  let modules = self[`TURBOPACK_${bundleKey}`];
-  if (modules && typeof modules === "object" && "__chunks__" in modules) {
-    const chunks = modules.__chunks__;
-    modules = chunks.flat();
-  }
-  let sharedModuleInitializer = null;
-  if (modules) {
-    const allModules = Array.isArray(modules) ? modules.flat() : Object.entries(modules).flat();
-    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 } = REMOTE_SHARED_ASSIGNMENT_RE.exec(sharedModuleInitializerCode)?.groups ?? {};
-      if (sharedModuleId) {
-        const { default: sharedModuleInitializerInstance } = handleTurbopackModule(
-          bundle,
-          sharedModuleId,
-          `[${bundle}] ${sharedModuleInitializerId}`
-        );
-        sharedModuleInitializer = sharedModuleInitializerInstance;
-      }
-    }
-    if (sharedModuleInitializer) {
-      const { shared } = await sharedModuleInitializer;
-      const sharedModuleIds = extractSharedModuleIds(
-        shared,
-        bundleKey,
-        self
-      );
-      return Promise.all(
-        Object.entries(sharedModuleIds).map(async ([id, module]) => {
-          if (self.__remote_shared_modules__?.[bundle]) {
-            if (hostShared[module]) {
-              self.__remote_shared_modules__[bundle][id] = await hostShared[module](bundle);
-            } else {
-              logError(
-                "SharedModules",
-                `Host shared module "${module}" not found for ID ${id}`
-              );
-            }
-          }
-        })
-      );
-    }
-  }
-  return Promise.all(
-    Object.entries(remoteShared).map(async ([id, module]) => {
-      if (self.__remote_shared_modules__?.[bundle]) {
-        if (hostShared[module]) {
-          const normalizedId = id.replace("[app-ssr]", "[app-client]");
-          self.__remote_shared_modules__[bundle][normalizedId] = await hostShared[module](bundle);
-        } else {
-          logError(
-            "SharedModules",
-            `Shared module "${module}" not found for "${bundle}"`
-          );
-        }
-      }
-    })
-  );
-}
-function extractSharedModuleIds(shared, bundleKey, self) {
-  return Object.entries(shared).filter(([, value]) => typeof value === "function").reduce((acc, [key, value]) => {
-    const { asyncSharedModuleId } = ASYNC_MODULE_LOADER_RE.exec(value.toString())?.groups ?? {};
-    if (asyncSharedModuleId) {
-      const asyncSharedModuleIdNumber = Number(asyncSharedModuleId);
-      let asyncSharedModule;
-      let turbopackModules = self[`TURBOPACK_${bundleKey}`];
-      if (turbopackModules && typeof turbopackModules === "object" && "__chunks__" in turbopackModules) {
-        const chunks = turbopackModules.__chunks__;
-        turbopackModules = chunks.flat();
-      }
-      const newAllModules = Array.isArray(turbopackModules) ? turbopackModules.flat() : turbopackModules ? Object.entries(turbopackModules).flatMap(([key2, value2]) => [
-        key2,
-        value2
-      ]) : [];
-      const asyncSharedModuleIdIndex = newAllModules.indexOf(
-        asyncSharedModuleIdNumber
-      );
-      if (asyncSharedModuleIdIndex !== -1 && typeof newAllModules[asyncSharedModuleIdIndex + 1] === "function") {
-        asyncSharedModule = newAllModules[asyncSharedModuleIdIndex + 1];
-      }
-      if (asyncSharedModule) {
-        const asyncSharedModuleCode = asyncSharedModule.toString();
-        const { sharedModuleId } = ASYNC_MODULE_RESOLVE_RE.exec(asyncSharedModuleCode)?.groups ?? ASYNC_MODULE_ALL_RE.exec(asyncSharedModuleCode)?.groups ?? {};
-        acc[sharedModuleId ?? asyncSharedModuleId] = key.replace(
-          "__remote_shared_module_",
-          ""
-        );
-      }
-    }
-    return acc;
-  }, {});
-}
-function getSharedModule(bundle, id) {
-  const self = globalThis;
-  for (const [key, value] of Object.entries(
-    self.__remote_shared_modules__?.[bundle] ?? {}
-  )) {
-    if (typeof value !== "undefined" && (typeof id === "string" && id.includes(key) || id === key)) {
-      return value;
-    }
-  }
-  return null;
-}
-
-// src/shared/client/webpack-adapter.ts
-async function setupWebpackRuntime(runtime, scripts = [], url = new URL(location.href), bundle, shared = {}, remoteShared = {}, resolveClientUrl) {
-  const self = globalThis;
-  if (!self.__remote_bundle_url__) {
-    self.__remote_bundle_url__ = {};
-  }
-  self.__remote_bundle_url__[bundle ?? "default"] = url;
-  self.__webpack_get_script_filename__ = () => null;
-  if (typeof self.__webpack_require__ !== "function" || self.__webpack_require_type__ !== "turbopack") {
-    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__ = createChunkLoader(runtime, resolveClientUrl);
-    self.__webpack_require__ = createModuleRequire(runtime);
-    self.__webpack_require_type__ = runtime;
-    if (self.__remote_webpack_require__ && runtime === RUNTIME_TURBOPACK) {
-      const remoteBundle = bundle ?? "default";
-      self.__remote_webpack_require__[remoteBundle] = self.__webpack_require__;
-      self.__remote_webpack_require__[remoteBundle].type = "turbopack";
-    }
-  }
-  if (runtime === RUNTIME_TURBOPACK) {
-    await Promise.all(
-      scripts.map((script) => {
-        if (script.src) {
-          return self.__webpack_chunk_load__?.(script.src, bundle);
-        }
-        return Promise.resolve(void 0);
-      })
-    );
-  }
-  const coreShared = {
-    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,
-    ...shared
-  };
-  await initializeSharedModules(
-    bundle ?? "default",
-    // include all core modules as shared
-    coreShared,
-    remoteShared
-  );
-}
-function createModuleRequire(runtime) {
-  return (id) => {
-    const self = globalThis;
-    const { bundle, id: moduleId } = id.match(REMOTE_COMPONENT_REGEX)?.groups ?? {
-      bundle: "default",
-      id
-    };
-    const remoteRuntime = self.__remote_webpack_require__?.[bundle ?? "default"] ? self.__remote_webpack_require__[bundle ?? "default"]?.type || "webpack" : runtime;
-    logDebug("WebpackAdapter", `remoteRuntime: "${remoteRuntime}"`);
-    try {
-      if (remoteRuntime === RUNTIME_WEBPACK && bundle && moduleId) {
-        return self.__remote_webpack_require__?.[bundle]?.(moduleId);
-      }
-      const sharedModuleId = moduleId ?? id;
-      const sharedModule = getSharedModule(bundle ?? "default", sharedModuleId);
-      if (sharedModule) {
-        return sharedModule;
-      }
-      if (bundle && moduleId) {
-        return handleTurbopackModule(bundle, moduleId, id);
-      }
-      throw new Error(`Module "${id}" not found.`);
-    } catch (requireError) {
-      logWarn(
-        "WebpackAdapter",
-        `Module require failed: ${String(requireError)}`
-      );
-      if (typeof self.__original_webpack_require__ !== "function") {
-        throw new RemoteComponentsError(
-          `Module "${id}" not found in remote component bundle "${bundle}".`,
-          {
-            cause: requireError instanceof Error ? requireError : void 0
-          }
-        );
-      }
-      try {
-        logDebug("WebpackAdapter", "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 "${bundle}".`,
-          { cause: originalError instanceof Error ? originalError : void 0 }
-        );
-      }
-    }
-  };
-}
-
-// src/shared/client/component-loader.ts
-async function loadRemoteComponent({
-  url,
-  name,
-  rscName,
-  bundle,
-  route = "/",
-  runtime = "webpack",
-  data,
-  nextData,
-  scripts = [],
-  shared = 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 shared;
-    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)}`
-    );
-    await setupWebpackRuntime(
-      runtime,
-      scripts,
-      url,
-      bundle,
-      hostShared,
-      remoteShared,
-      resolveClientUrl
-    );
-    if (bundle) {
-      const resolve = {
-        "/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,
-        ...Object.entries(remoteShared).reduce(
-          (acc, [key, value]) => {
-            if (typeof hostShared[value] !== "undefined") {
-              acc[key.replace(/^\(ssr\)\/(?<relative>\.\/)?/, "")] = hostShared[value];
-            } else {
-              logDebug(
-                "ComponentLoader",
-                `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);
-        })
-      );
-      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) {
-  let createFromReadableStream;
-  try {
-    const { createFromReadableStream: _createFromReadableStream } = await import("next/dist/compiled/react-server-dom-webpack/client.browser");
-    createFromReadableStream = _createFromReadableStream;
-  } catch {
-    const {
-      default: { createFromReadableStream: _createFromReadableStream }
-    } = await import("react-server-dom-webpack/client.browser");
-    createFromReadableStream = _createFromReadableStream;
-  }
-  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/shared/client/proxy-through-host.ts
-var proxyClientRequestsThroughHost = (remoteSrc, url) => {
-  if (typeof location === "undefined") {
-    return void 0;
-  }
-  const remoteOrigin = new URL(remoteSrc, location.href).origin;
-  if (remoteOrigin === location.origin) {
-    return void 0;
-  }
-  try {
-    const parsed = new URL(url, location.href);
-    if (parsed.origin === remoteOrigin) {
-      return generateProtectedRcFallbackSrc(url);
-    }
-  } catch {
-  }
-  return void 0;
-};
-
-// src/shared/client/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/shared/client/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 = globalThis.__rc_module_registry__;
-  const mod = registry?.[absoluteSrc] ?? {};
-  if (registry)
-    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 self = globalThis;
-  if (self.__remote_script_entrypoint_mount__?.[url.href]) {
-    self.__remote_script_entrypoint_mount__[url.href] = /* @__PURE__ */ new Set();
-  }
-  if (self.__remote_script_entrypoint_unmount__?.[url.href]) {
-    self.__remote_script_entrypoint_unmount__[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 (!self.__remote_script_entrypoint_mount__) {
-            self.__remote_script_entrypoint_mount__ = {};
-          }
-          if (!self.__remote_script_entrypoint_mount__[url.href]) {
-            self.__remote_script_entrypoint_mount__[url.href] = /* @__PURE__ */ new Set();
-          }
-          self.__remote_script_entrypoint_mount__[url.href]?.add(
-            mod.mount || mod.default?.mount || (() => {
-            })
-          );
-        }
-        if (typeof mod.unmount === "function" || typeof mod.default?.unmount === "function") {
-          if (!self.__remote_script_entrypoint_unmount__) {
-            self.__remote_script_entrypoint_unmount__ = {};
-          }
-          if (!self.__remote_script_entrypoint_unmount__[url.href]) {
-            self.__remote_script_entrypoint_unmount__[url.href] = /* @__PURE__ */ new Set();
-          }
-          self.__remote_script_entrypoint_unmount__[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()
-    }
-  );
-}
-export {
-  DEFAULT_ROUTE,
-  REMOTE_COMPONENT_REGEX,
-  RUNTIME_SCRIPT,
-  RUNTIME_TURBOPACK,
-  RUNTIME_WEBPACK,
-  RemoteComponentsError,
-  createRSCStream,
-  fixPayload,
-  getBundleKey,
-  loadRemoteComponent,
-  loadScripts,
-  loadStaticRemoteComponent,
-  proxyClientRequestsThroughHost,
-  setAttributesFromProps,
-  setupWebpackRuntime
-};
-//# sourceMappingURL=remote-component.js.map