remote-components 0.3.4 → 0.3.6

package/dist/chunk-F44NODUS.cjs

@@ -0,0 +1,709 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+var _chunkR4QFK5TNcjs = require('./chunk-R4QFK5TN.cjs');
+
+
+var _chunk7MVFHOIPcjs = require('./chunk-7MVFHOIP.cjs');
+
+
+
+
+
+
+
+var _chunkRUWR74XQcjs = require('./chunk-RUWR74XQ.cjs');
+
+
+var _chunkKE7QPAQ4cjs = require('./chunk-KE7QPAQ4.cjs');
+
+// src/runtime/turbopack/patterns.ts
+var MODULE_ID_PATTERN = '"[^"]+"|[0-9]+';
+function stripQuotes(value) {
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function extractGroup(re, input, group) {
+  const raw = _optionalChain([re, 'access', _ => _.exec, 'call', _2 => _2(input), 'optionalAccess', _3 => _3.groups, 'optionalAccess', _4 => _4[group]]);
+  return raw ? stripQuotes(raw) : void 0;
+}
+var REMOTE_SHARED_MARKER_RE = /(?:self|[a-z])\.TURBOPACK_REMOTE_SHARED/;
+var REMOTE_SHARED_ASSIGNMENT_RE = new RegExp(
+  `\\.TURBOPACK_REMOTE_SHARED\\s*=\\s*await (?:__turbopack_context__|[a-z])\\.A\\((?<sharedModuleId>${MODULE_ID_PATTERN})\\)`
+);
+var ASYNC_MODULE_LOADER_RE = new RegExp(
+  `(?:__turbopack_context__|[a-z])\\.A\\((?<asyncSharedModuleId>${MODULE_ID_PATTERN})\\)`
+);
+var ASYNC_MODULE_CALLBACK_RE = new RegExp(
+  `(?:parentImport|[a-z])\\((?<sharedModuleId>${MODULE_ID_PATTERN})\\)`
+);
+var TURBOPACK_GLOBAL_RE = /(?:globalThis|self)\s*(?:\.TURBOPACK|\[\s*["']TURBOPACK["']\s*\])/;
+
+// src/runtime/turbopack/chunk-loader.ts
+function loadChunkWithScope(scope, chunkId) {
+  _chunkRUWR74XQcjs.logDebug.call(void 0, 
+    "ChunkLoader",
+    `loadChunkWithScope: "${chunkId}" (scope: "${scope.scopedName}")`
+  );
+  const self = globalThis;
+  const ns = _chunk7MVFHOIPcjs.getNamespace.call(void 0, );
+  const { bundle, path, prefix } = _chunkR4QFK5TNcjs.parseRemoteId.call(void 0, chunkId);
+  const remoteRuntime = _optionalChain([self, 'access', _5 => _5.__remote_webpack_require__, 'optionalAccess', _6 => _6[_nullishCoalesce(bundle, () => ( "default"))]]) ? _optionalChain([self, 'access', _7 => _7.__remote_webpack_require__, 'access', _8 => _8[_nullishCoalesce(bundle, () => ( "default"))], 'optionalAccess', _9 => _9.type]) || "webpack" : scope.runtime;
+  if (remoteRuntime === _chunkR4QFK5TNcjs.RUNTIME_WEBPACK) {
+    return Promise.resolve(void 0);
+  }
+  const rawPath = path ? _chunkR4QFK5TNcjs.collapseDoubleSlashes.call(void 0, `${prefix}${path}`) : "/";
+  const url = new URL(rawPath, scope.url).href;
+  if (url.endsWith(".css")) {
+    return;
+  }
+  if (ns.chunkCache[url]) {
+    _chunkRUWR74XQcjs.logDebug.call(void 0, "ChunkLoader", `Cache hit for "${chunkId}" (url="${url}")`);
+    return ns.chunkCache[url];
+  }
+  const resolvedUrl = _nullishCoalesce(_optionalChain([scope, 'access', _10 => _10.resolveClientUrl, 'optionalCall', _11 => _11(url)]), () => ( url));
+  if (resolvedUrl !== url) {
+    _chunkRUWR74XQcjs.logDebug.call(void 0, "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 = _chunkKE7QPAQ4cjs.isProxiedUrl.call(void 0, resolvedUrl);
+      if (isProxied) {
+        reject(_chunkRUWR74XQcjs.failedProxiedAssetError.call(void 0, "chunk", url, resolvedUrl));
+      } else {
+        _chunkRUWR74XQcjs.warnCrossOriginFetchError.call(void 0, "ChunkLoader", url);
+        reject(error);
+      }
+    });
+  });
+  return ns.chunkCache[url];
+}
+function createChunkDispatcher() {
+  return function __chunk_dispatcher__(chunkId, scriptBundle) {
+    _chunkRUWR74XQcjs.logDebug.call(void 0, "ChunkDispatcher", `Dispatching chunk: "${chunkId}"`);
+    const { bundle } = _chunkR4QFK5TNcjs.parseRemoteId.call(void 0, chunkId);
+    const bundleName = bundle || scriptBundle || "default";
+    const scope = _chunkR4QFK5TNcjs.getScope.call(void 0, bundleName);
+    _chunkRUWR74XQcjs.logDebug.call(void 0, 
+      "ChunkDispatcher",
+      `Scope resolution: bundle="${bundleName}", scope=${_nullishCoalesce(_optionalChain([scope, 'optionalAccess', _12 => _12.scopedName]), () => ( "null"))}`
+    );
+    if (!scope) {
+      _chunkRUWR74XQcjs.logWarn.call(void 0, "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 (0, _chunkRUWR74XQcjs.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 (_optionalChain([chunkLists, 'optionalAccess', _13 => _13.length])) {
+    const { chunks } = _nullishCoalesce(chunkLists.shift(), () => ( { chunks: [] }));
+    if (chunks.length > 0) {
+      for (const id of chunks) {
+        const baseUrl = url.slice(0, url.indexOf("/_next"));
+        const chunkLoadResult = loadChunkWithScope(
+          scope,
+          _chunkR4QFK5TNcjs.formatRemoteId.call(void 0, scope, `${baseUrl}/_next/${id}`)
+        );
+        if (chunkLoadResult) {
+          loadChunkPromises.push(chunkLoadResult);
+        }
+      }
+    }
+  }
+  if (loadChunkPromises.length > 0) {
+    await Promise.all(loadChunkPromises);
+  }
+}
+
+// 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,
+    _nullishCoalesce(fullId, () => ( _chunkR4QFK5TNcjs.formatRemoteId.call(void 0, scope, idStr)))
+  );
+}
+function handleTurbopackModule(scope, moduleId, id) {
+  if (scope.moduleCache[moduleId]) {
+    return scope.moduleCache[moduleId];
+  }
+  const modules = getTurbopackModules(scope);
+  if (!modules) {
+    _chunkRUWR74XQcjs.logError.call(void 0, 
+      "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, _chunkR4QFK5TNcjs.formatRemoteId.call(void 0, 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 } = _nullishCoalesce(_optionalChain([/\s+<export (?<exportSource>.*?) as (?<exportName>.*?)>$/, 'access', _14 => _14.exec, 'call', _15 => _15(
+          importId
+        ), 'optionalAccess', _16 => _16.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 (e2) {
+        }
+      }
+      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, _chunkR4QFK5TNcjs.formatRemoteId.call(void 0, scope, chunkUrl));
+        }
+      }
+      throw new Error(
+        `Failed to load Turbopack chunk "${url}" for module "${id}". Check the URL is correct.`
+      );
+    },
+    // globalThis substitute shared across all modules in this scope
+    g: scope.moduleGlobal,
+    m: moduleExports,
+    e: exports
+  };
+}
+
+// src/runtime/turbopack/shared-modules.ts
+var DEDUPLICATION_WARNING = "This module will not be deduplicated \u2014 the remote may load its own copy, which can cause duplicate instance errors (e.g. invalid hook calls if React is loaded twice).";
+function getTurbopackModules(scope) {
+  if (scope.turbopackModules.length > 0) {
+    return scope.turbopackModules;
+  }
+  const self = globalThis;
+  const raw = self[`TURBOPACK_${scope.globalKey}`];
+  if (!raw)
+    return void 0;
+  if (Array.isArray(raw)) {
+    return raw.flat();
+  }
+  return Object.entries(raw).flat();
+}
+async function initializeSharedModules(scope, hostShared = {}, remoteShared = {}) {
+  const allModules = getTurbopackModules(scope);
+  _chunkRUWR74XQcjs.logDebug.call(void 0, 
+    "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,
+          _chunkR4QFK5TNcjs.formatRemoteId.call(void 0, scope, String(sharedModuleInitializerId))
+        );
+        sharedModuleInitializer = sharedModuleInitializerInstance;
+      }
+    }
+    if (sharedModuleInitializer) {
+      const { shared } = await sharedModuleInitializer;
+      const sharedModuleIds = extractSharedModuleIds(shared, scope);
+      _chunkRUWR74XQcjs.logDebug.call(void 0, 
+        "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 {
+            _chunkRUWR74XQcjs.logError.call(void 0, 
+              "SharedModules",
+              `Host shared module "${module}" not found for ID ${id}. ${DEDUPLICATION_WARNING}`
+            );
+          }
+        })
+      );
+    }
+    _chunkRUWR74XQcjs.logWarn.call(void 0, 
+      "SharedModules",
+      `No shared module initializer found in bundle for scope="${scope.scopedName}" \u2014 falling back to remoteShared mapping`
+    );
+  } else {
+    _chunkRUWR74XQcjs.logWarn.call(void 0, 
+      "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 {
+        _chunkRUWR74XQcjs.logError.call(void 0, 
+          "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[_nullishCoalesce(sharedModuleId, () => ( asyncSharedModuleId))] = key.replace(
+          "__remote_shared_module_",
+          ""
+        );
+      }
+    }
+    return acc;
+  }, {});
+}
+function getSharedModule(scope, id) {
+  const idStr = String(id);
+  if (scope.sharedModules[idStr] !== void 0) {
+    return scope.sharedModules[idStr];
+  }
+  for (const [key, value] of Object.entries(scope.sharedModules)) {
+    if (typeof value !== "undefined" && idStr !== key && idStr.endsWith(key)) {
+      return value;
+    }
+  }
+  return null;
+}
+
+// src/runtime/turbopack/remote-scope-setup.ts
+async function setupRemoteScope(runtime, scripts = [], url = new URL(location.href), bundle, resolveClientUrl) {
+  const self = globalThis;
+  const ns = _chunk7MVFHOIPcjs.getNamespace.call(void 0, );
+  const bundleName = _nullishCoalesce(bundle, () => ( "default"));
+  const existingScope = _chunkR4QFK5TNcjs.getScope.call(void 0, bundleName);
+  if (existingScope && existingScope.url.origin === url.origin) {
+    _chunkRUWR74XQcjs.logDebug.call(void 0, 
+      "WebpackRuntime",
+      `Reusing scope "${existingScope.scopedName}" (turbopackModules=${existingScope.turbopackModules.length})`
+    );
+    existingScope.resolveClientUrl = resolveClientUrl;
+    if (runtime === _chunkR4QFK5TNcjs.RUNTIME_TURBOPACK) {
+      await Promise.allSettled(
+        scripts.map(
+          (script) => script.src ? loadChunkWithScope(existingScope, script.src) : Promise.resolve(void 0)
+        )
+      );
+    }
+    return existingScope;
+  }
+  const scope = _chunkR4QFK5TNcjs.createScope.call(void 0, bundleName, url, runtime, resolveClientUrl);
+  _chunkR4QFK5TNcjs.registerScope.call(void 0, scope);
+  if (runtime === _chunkR4QFK5TNcjs.RUNTIME_WEBPACK && _optionalChain([self, 'access', _17 => _17.__remote_webpack_require__, 'optionalAccess', _18 => _18[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 === _chunkR4QFK5TNcjs.RUNTIME_TURBOPACK) {
+      self.__remote_webpack_require__[bundleName] = self.__webpack_require__;
+      self.__remote_webpack_require__[bundleName].type = "turbopack";
+    }
+  }
+  if (_optionalChain([self, 'access', _19 => _19.__remote_webpack_require__, 'optionalAccess', _20 => _20[bundleName]]) && scope.scopedName !== bundleName) {
+    self.__remote_webpack_require__[scope.scopedName] = self.__remote_webpack_require__[bundleName];
+  }
+  if (runtime === _chunkR4QFK5TNcjs.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") {
+        _chunkRUWR74XQcjs.logWarn.call(void 0, 
+          "WebpackRuntime",
+          `Initial chunk load failed: ${String(result.reason)}`
+        );
+      }
+    }
+  }
+  return scope;
+}
+function createModuleDispatcher(runtime) {
+  return (id) => {
+    const self = globalThis;
+    const { bundle, id: moduleId } = _nullishCoalesce(_optionalChain([id, 'access', _21 => _21.match, 'call', _22 => _22(_chunkR4QFK5TNcjs.REMOTE_COMPONENT_REGEX), 'optionalAccess', _23 => _23.groups]), () => ( {
+      bundle: "default",
+      id
+    }));
+    const bundleName = _nullishCoalesce(bundle, () => ( "default"));
+    const remoteRuntime = _optionalChain([self, 'access', _24 => _24.__remote_webpack_require__, 'optionalAccess', _25 => _25[bundleName]]) ? _optionalChain([self, 'access', _26 => _26.__remote_webpack_require__, 'access', _27 => _27[bundleName], 'optionalAccess', _28 => _28.type]) || "webpack" : runtime;
+    _chunkRUWR74XQcjs.logDebug.call(void 0, 
+      "ModuleDispatcher",
+      `Resolving "${id}" (bundle: "${bundleName}", runtime: "${remoteRuntime}")`
+    );
+    try {
+      if (remoteRuntime === _chunkR4QFK5TNcjs.RUNTIME_WEBPACK && bundle && moduleId) {
+        const scope2 = _chunkR4QFK5TNcjs.getScope.call(void 0, bundle);
+        if (_optionalChain([scope2, 'optionalAccess', _29 => _29.webpackRequire]))
+          return scope2.webpackRequire(moduleId);
+        return _optionalChain([self, 'access', _30 => _30.__remote_webpack_require__, 'optionalAccess', _31 => _31[bundle], 'optionalCall', _32 => _32(moduleId)]);
+      }
+      const scope = _chunkR4QFK5TNcjs.getScope.call(void 0, bundleName);
+      if (scope) {
+        return requireModule(scope, _nullishCoalesce(moduleId, () => ( id)), id);
+      }
+      throw new Error(
+        `Module "${id}" not found \u2014 no scope for bundle "${bundleName}".`
+      );
+    } catch (requireError) {
+      _chunkRUWR74XQcjs.logWarn.call(void 0, 
+        "ModuleDispatcher",
+        `Module require failed: ${String(requireError)}`
+      );
+      if (typeof self.__original_webpack_require__ !== "function") {
+        throw new (0, _chunkRUWR74XQcjs.RemoteComponentsError)(
+          `Module "${id}" not found in remote component bundle "${bundleName}".`,
+          {
+            cause: requireError instanceof Error ? requireError : void 0
+          }
+        );
+      }
+      try {
+        _chunkRUWR74XQcjs.logDebug.call(void 0, 
+          "ModuleDispatcher",
+          "Falling back to original webpack require"
+        );
+        return self.__original_webpack_require__(id);
+      } catch (originalError) {
+        throw new (0, _chunkRUWR74XQcjs.RemoteComponentsError)(
+          `Module "${id}" not found in remote component bundle "${bundleName}".`,
+          { cause: originalError instanceof Error ? originalError : void 0 }
+        );
+      }
+    }
+  };
+}
+
+
+
+
+exports.initializeSharedModules = initializeSharedModules; exports.setupRemoteScope = setupRemoteScope;
+//# sourceMappingURL=chunk-F44NODUS.cjs.map