remote-components 0.4.2 → 0.4.3

package/dist/{chunk-MTMDXJLM.js → chunk-4NW46ZVD.js}

@@ -1,14 +1,12 @@
 import {
-  REMOTE_COMPONENT_REGEX,
-  RUNTIME_TURBOPACK,
   RUNTIME_WEBPACK,
   collapseDoubleSlashes,
-  createScope,
+  createSharedModulePlan,
   formatRemoteId,
   getScope,
-  parseRemoteId,
-  registerScope
-} from "./chunk-SAGYPGIQ.js";
+  installSharedModulePlan,
+  parseRemoteId
+} from "./chunk-55TEMSB5.js";
 import {
   getNamespace
 } from "./chunk-D5GNZB6O.js";
@@ -19,11 +17,74 @@ import {
   logError,
   logWarn,
   warnCrossOriginFetchError
-} from "./chunk-S2A4TFLS.js";
+} from "./chunk-ULXU6XWH.js";
 import {
   isProxiedUrl
 } from "./chunk-X6YKUJKH.js";
 
+// src/config/webpack/apply-shared-modules.ts
+var DEDUPLICATION_SKIPPED = "shared module deduplication skipped. The remote may load its own copy of shared dependencies.";
+function applySharedModules(bundle, resolve) {
+  logDebug(
+    "SharedModules",
+    `applySharedModules called for bundle: "${bundle}"`
+  );
+  logDebug(
+    "SharedModules",
+    `Shared modules to resolve: ${Object.keys(resolve)}`
+  );
+  const self = globalThis;
+  const scope = getScope(bundle);
+  const webpackBundle = scope?.webpackRequire ?? self.__remote_webpack_require__?.[bundle];
+  if (webpackBundle) {
+    const modulePaths = Object.keys(
+      self.__remote_webpack_module_map__?.[bundle] ?? webpackBundle.m ?? {}
+    );
+    logDebug(
+      "SharedModules",
+      `Available module paths for bundle "${bundle}": ${modulePaths}`
+    );
+    for (const [key, value] of Object.entries(resolve)) {
+      const exactIds = modulePaths.filter((p) => p === key);
+      const ids = exactIds.length > 0 ? exactIds : modulePaths.filter((p) => p.includes(key));
+      if (ids.length === 0) {
+        logDebug(
+          "SharedModules",
+          `No matching module path found for shared module "${key}"`
+        );
+      }
+      for (const id of ids) {
+        if (webpackBundle.m) {
+          const resolvedId = self.__remote_webpack_module_map__?.[bundle]?.[id] ? `${self.__remote_webpack_module_map__[bundle][id]}` : id;
+          if (resolvedId !== id) {
+            logDebug(
+              "SharedModules",
+              `Mapped module id: "${id}" -> "${resolvedId}"`
+            );
+          }
+          webpackBundle.m[resolvedId] = (module) => {
+            module.exports = value;
+          };
+        } else {
+          logWarn(
+            "SharedModules",
+            `webpackBundle.m is not available for bundle "${bundle}" \u2014 ${DEDUPLICATION_SKIPPED}`
+          );
+        }
+      }
+    }
+  } else {
+    logWarn(
+      "SharedModules",
+      `No webpack require found for bundle "${bundle}" \u2014 ${DEDUPLICATION_SKIPPED}`
+    );
+    logDebug(
+      "SharedModules",
+      `Available bundles: ${Object.keys(self.__remote_webpack_require__ ?? {})}`
+    );
+  }
+}
+
 // src/runtime/turbopack/patterns.ts
 var MODULE_ID_PATTERN = '"[^"]+"|[0-9]+';
 function stripQuotes(value) {
@@ -223,11 +284,18 @@ async function handleTurbopackChunk(code, scope, url) {
 // 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)
+  if (sharedModule !== null) {
+    if (scope.moduleCache[idStr]) {
+      logDebug(
+        "TurbopackModule",
+        `Shared module "${idStr}" resolved from host and overrides a cached remote copy in "${scope.scopedName}"`
+      );
+    }
     return sharedModule;
+  }
+  if (scope.moduleCache[idStr])
+    return scope.moduleCache[idStr];
   return handleTurbopackModule(
     scope,
     idStr,
@@ -247,7 +315,10 @@ function handleTurbopackModule(scope, moduleId, id) {
   }
   const moduleInit = findModuleInit(modules, moduleId);
   const exports = {};
-  const moduleExports = { exports };
+  const moduleExports = {
+    exports,
+    hot: createNoopHotModule()
+  };
   if (typeof moduleInit !== "function") {
     throw new Error(
       `Module ${id} not found in bundle ${scope.name} with id ${moduleId}`
@@ -443,9 +514,22 @@ function createTurbopackContext(scope, exports, moduleExports, modules, moduleIn
     e: exports
   };
 }
+function createNoopHotModule() {
+  return {
+    active: true,
+    data: {},
+    accept() {
+    },
+    dispose() {
+    },
+    invalidate() {
+    }
+  };
+}
 
 // src/runtime/turbopack/shared-modules.ts
 var DEDUPLICATION_WARNING = "This module will not be deduplicated \u2014 the remote may load its own copy, which can cause duplicate instance errors (e.g. invalid hook calls if React is loaded twice).";
+var INLINE_REMOTE_SHARED_RE = /["']?__remote_shared_module_(?<specifier>[^"':]+)["']?\s*:\s*\(\)\s*=>\s*(?:__turbopack_context__|[a-z])\.A\((?<asyncSharedModuleId>"[^"]+"|[0-9]+)\)/g;
 function getTurbopackModules(scope) {
   if (scope.turbopackModules.length > 0) {
     return scope.turbopackModules;
@@ -498,17 +582,27 @@ async function initializeSharedModules(scope, hostShared = {}, remoteShared = {}
         "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}`
-            );
-          }
-        })
+      return installSharedModules(
+        scope,
+        hostShared,
+        sharedModuleIds,
+        (id, module) => `Host shared module "${module}" not found for ID ${id}. ${DEDUPLICATION_WARNING}`
+      );
+    }
+    const inlineSharedModuleIds = extractInlineSharedModuleIds(
+      allModules,
+      scope
+    );
+    if (Object.keys(inlineSharedModuleIds).length > 0) {
+      logDebug(
+        "SharedModules",
+        `Resolved inline shared modules for scope="${scope.scopedName}": ${JSON.stringify(inlineSharedModuleIds)}`
+      );
+      return installSharedModules(
+        scope,
+        hostShared,
+        inlineSharedModuleIds,
+        (id, module) => `Host shared module "${module}" not found for inline ID ${id}. ${DEDUPLICATION_WARNING}`
       );
     }
     logWarn(
@@ -521,20 +615,17 @@ async function initializeSharedModules(scope, hostShared = {}, remoteShared = {}
       `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}`
-        );
-      }
-    })
+  const normalizedRemoteShared = Object.fromEntries(
+    Object.entries(remoteShared).map(([id, module]) => [
+      id.replace("[app-ssr]", "[app-client]"),
+      module
+    ])
+  );
+  return installSharedModules(
+    scope,
+    hostShared,
+    normalizedRemoteShared,
+    (_id, module) => `Shared module "${module}" not found for "${scope.name}". ${DEDUPLICATION_WARNING}`
   );
 }
 function extractSharedModuleIds(shared, scope) {
@@ -564,146 +655,319 @@ function extractSharedModuleIds(shared, scope) {
     return acc;
   }, {});
 }
+function extractInlineSharedModuleIds(allModules, scope) {
+  const sharedModuleIds = {};
+  for (const idOrFunc of allModules) {
+    if (typeof idOrFunc !== "function")
+      continue;
+    const funcCode = idOrFunc.toString();
+    if (!funcCode.includes("__remote_shared_module_"))
+      continue;
+    INLINE_REMOTE_SHARED_RE.lastIndex = 0;
+    for (const match of funcCode.matchAll(INLINE_REMOTE_SHARED_RE)) {
+      const specifier = match.groups?.specifier;
+      const asyncSharedModuleId = stripQuotes2(
+        match.groups?.asyncSharedModuleId
+      );
+      if (!specifier || !asyncSharedModuleId)
+        continue;
+      const asyncSharedModule = findModuleInit(
+        getTurbopackModules(scope),
+        asyncSharedModuleId
+      );
+      if (!asyncSharedModule)
+        continue;
+      const sharedModuleId = extractGroup(
+        ASYNC_MODULE_CALLBACK_RE,
+        asyncSharedModule.toString(),
+        "sharedModuleId"
+      );
+      sharedModuleIds[sharedModuleId ?? asyncSharedModuleId] = specifier;
+    }
+  }
+  return sharedModuleIds;
+}
+function stripQuotes2(value) {
+  if (value?.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function installSharedModules(scope, hostShared, sharedModuleIds, missingMessage) {
+  const plan = createSharedModulePlan({
+    bundle: scope.name,
+    hostShared,
+    remoteShared: sharedModuleIds,
+    scope: `remote:${scope.scopedName}`,
+    callerTag: "SharedModules"
+  });
+  for (const entry of plan.entries) {
+    if (entry.status === "resolved") {
+      delete scope.moduleCache[entry.id];
+    }
+  }
+  return installSharedModulePlan({
+    plan,
+    target: scope.sharedModules,
+    callerTag: "SharedModules",
+    onMissing: (entry) => {
+      logError("SharedModules", missingMessage(entry.id, entry.specifier));
+    }
+  }).then((results) => {
+    for (const entry of plan.entries) {
+      if (entry.status === "resolved") {
+        delete scope.moduleCache[entry.id];
+      }
+    }
+    return results;
+  });
+}
 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)) {
+    if (typeof value !== "undefined" && idStr !== key && matchesSharedModuleKey(idStr, key)) {
       return value;
     }
   }
   return null;
 }
+function matchesSharedModuleKey(id, key) {
+  if (id.endsWith(key))
+    return true;
+  if (!key.includes("/") && !key.endsWith(".js"))
+    return false;
+  const index = id.lastIndexOf(key);
+  if (index < 0)
+    return false;
+  const afterKey = id.slice(index + key.length);
+  return /^\s+(?:\[[^\]]+\]\s*)?(?:\([^)]*\))?$/.test(afterKey);
+}
 
-// src/runtime/turbopack/remote-scope-setup.ts
-async function setupRemoteScope(runtime, scripts = [], url = new URL(location.href), bundle, resolveClientUrl) {
+// src/config/webpack/next-client-pages-loader.ts
+function nextClientPagesLoader(bundle, route, styleContainer = document.head) {
   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})`
+  ns.pageComponentCache ??= {};
+  const cacheKey = `${bundle}:${route}`;
+  const remoteRequire = self.__remote_webpack_require__?.[bundle];
+  const turbopackScope = remoteRequire?.type === "turbopack" ? getScope(bundle) : void 0;
+  const applyBundleCss = () => {
+    const elements = ns.cssCache[bundle] ?? [];
+    if (styleContainer) {
+      for (const el of elements) {
+        styleContainer.appendChild(el.cloneNode(true));
+      }
+    } else {
+      for (const el of elements) {
+        document.head.appendChild(el);
+      }
+    }
+  };
+  const cachedEntry = ns.pageComponentCache[cacheKey];
+  if (cachedEntry) {
+    applyBundleCss();
+    return cachedEntry;
+  }
+  const nextCssOriginal = document.querySelector(
+    `[id="__next_css__DO_NOT_USE__"]:not([data-bundle="${bundle}"][data-route="${route}"])`
+  );
+  const nextCssOriginalParent = nextCssOriginal?.parentNode ?? null;
+  const nextCssOriginalNextSibling = nextCssOriginal?.nextSibling ?? null;
+  if (nextCssOriginal) {
+    nextCssOriginalParent?.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 = (turbopackScope ? findTurbopackPagesLoaderId(turbopackScope, route) : void 0) ?? Object.keys(remoteRequire?.m ?? {}).find(
+    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=${encodeURIComponent(route)}!`)
+  ) ?? Object.keys(remoteRequire?.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 = (turbopackScope ? findTurbopackPagesLoaderId(turbopackScope, "/_app") : void 0) ?? Object.keys(remoteRequire?.m ?? {}).find(
+    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=%2F_app`)
+  ) ?? Object.keys(remoteRequire?.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 (!isLoaderId(componentLoaderChunk) || !isLoaderId(appLoaderChunk)) {
+    throw new RemoteComponentsError(
+      `Next.js client pages loader not found in bundle "${bundle}".`
     );
-    existingScope.resolveClientUrl = resolveClientUrl;
-    if (runtime === RUNTIME_TURBOPACK) {
-      await Promise.allSettled(
-        scripts.map(
-          (script) => script.src ? loadChunkWithScope(existingScope, script.src) : Promise.resolve(void 0)
-        )
+  }
+  const __NEXT_P_ORIGINAL = self.__NEXT_P;
+  const selfOriginal = self;
+  delete selfOriginal.__NEXT_P;
+  try {
+    loadPagesLoaderModule(bundle, componentLoaderChunk, turbopackScope);
+    if (isLoaderId(appLoaderChunk)) {
+      loadPagesLoaderModule(bundle, appLoaderChunk, turbopackScope);
+    }
+    if (self.__NEXT_P) {
+      logDebug(
+        "ComponentLoader",
+        `Next.js Pages loader registry for "${route}" in "${bundle}": ${self.__NEXT_P.map((entry) => entry?.[0] ?? "<empty>").join(", ")}`
       );
+      const componentEntry = self.__NEXT_P.find(
+        (entry) => entry?.[0] === route
+      ) ?? self.__NEXT_P[0];
+      const appEntry = self.__NEXT_P.find((entry) => entry?.[0] === "/_app") ?? self.__NEXT_P[2];
+      const [, componentLoader] = componentEntry ?? [
+        void 0,
+        () => ({ default: null })
+      ];
+      const [, appLoader] = appEntry ?? [
+        void 0,
+        () => ({
+          default: null
+        })
+      ];
+      const { default: Component = null } = componentLoader();
+      const { default: App = null } = appLoader();
+      const cssCache = ns.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;
+      }
+      applyBundleCss();
+      const result = { Component, App };
+      ns.pageComponentCache[cacheKey] = result;
+      return result;
     }
-    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__;
+    logDebug(
+      "ComponentLoader",
+      `Next.js Pages loaders for route "${route}" in "${bundle}" did not populate __NEXT_P`
+    );
+    return { Component: null, App: null };
+  } finally {
+    if (typeof __NEXT_P_ORIGINAL === "undefined") {
+      delete self.__NEXT_P;
+    } else {
+      self.__NEXT_P = __NEXT_P_ORIGINAL;
     }
-    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 (nextCssOriginal && nextCssOriginalParent) {
+      const restoreBefore = nextCssOriginalNextSibling?.parentNode === nextCssOriginalParent ? nextCssOriginalNextSibling : null;
+      nextCssOriginalParent.insertBefore(nextCssOriginal, restoreBefore);
     }
+    nextCss.remove();
+    nextCssEnd.remove();
+  }
+}
+function isLoaderId(id) {
+  return typeof id === "string" && id.length > 0 || typeof id === "number" && id !== -1;
+}
+function loadPagesLoaderModule(bundle, id, turbopackScope) {
+  const self = globalThis;
+  if (turbopackScope) {
+    delete turbopackScope.moduleCache[String(id)];
+    requireModule(turbopackScope, id);
+    return;
   }
-  if (self.__remote_webpack_require__?.[bundleName] && scope.scopedName !== bundleName) {
-    self.__remote_webpack_require__[scope.scopedName] = self.__remote_webpack_require__[bundleName];
+  const remoteRequire = self.__remote_webpack_require__?.[bundle];
+  if (remoteRequire?.c) {
+    delete remoteRequire.c[id];
   }
-  if (runtime === RUNTIME_TURBOPACK) {
-    const results = await Promise.allSettled(
-      scripts.map((script) => {
-        if (script.src) {
-          return loadChunkWithScope(scope, script.src);
+  remoteRequire?.(id);
+}
+function findTurbopackPagesLoaderId(scope, route) {
+  const modules = getTurbopackModules(scope);
+  if (!modules)
+    return void 0;
+  const routeLiteral = JSON.stringify(route);
+  const singleQuotedRouteLiteral = `'${route.replaceAll("'", "\\'")}'`;
+  const flat = modules.flat();
+  for (let index = 0; index < flat.length; index++) {
+    const entry = flat[index];
+    if (typeof entry === "function") {
+      const code = entry.toString();
+      if (code.includes("__NEXT_P") && (code.includes(routeLiteral) || code.includes(singleQuotedRouteLiteral))) {
+        const id = findPreviousModuleId(flat, index);
+        if (isLoaderId(id) && isTurbopackPagesLoaderId(id)) {
+          logDebug(
+            "SharedModules",
+            `Resolved Turbopack Pages loader for route "${route}" in "${scope.scopedName}" as "${id}"`
+          );
+          return id;
         }
-        return Promise.resolve(void 0);
-      })
-    );
-    for (const result of results) {
-      if (result.status === "rejected") {
-        logWarn(
-          "WebpackRuntime",
-          `Initial chunk load failed: ${String(result.reason)}`
-        );
       }
+      continue;
     }
-  }
-  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 {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      continue;
+    if (typeof Element !== "undefined" && entry instanceof Element)
+      continue;
+    for (const [id, moduleInit] of Object.entries(
+      entry
+    )) {
+      if (typeof moduleInit !== "function")
+        continue;
+      const code = moduleInit.toString();
+      if (code.includes("__NEXT_P") && (code.includes(routeLiteral) || code.includes(singleQuotedRouteLiteral)) && isTurbopackPagesLoaderId(id)) {
         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 }
+          "SharedModules",
+          `Resolved Turbopack Pages loader for route "${route}" in "${scope.scopedName}" as "${id}"`
         );
+        return id;
       }
     }
-  };
+  }
+  return void 0;
+}
+function isTurbopackPagesLoaderId(id) {
+  if (typeof id === "number")
+    return true;
+  return id.includes("[next]/entry/page-loader.ts") || id.includes("/next/dist/client/page-loader.js");
+}
+function findPreviousModuleId(entries, factoryIndex) {
+  for (let index = factoryIndex - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (isLoaderId(entry))
+      return entry;
+    if (typeof entry === "function")
+      return void 0;
+  }
+  return void 0;
 }
 
 export {
+  applySharedModules,
+  loadChunkWithScope,
+  createChunkDispatcher,
   initializeSharedModules,
-  setupRemoteScope
+  requireModule,
+  nextClientPagesLoader
 };
-//# sourceMappingURL=chunk-MTMDXJLM.js.map
+//# sourceMappingURL=chunk-4NW46ZVD.js.map