remote-components 0.4.7 → 0.4.9

package/dist/{chunk-YOFJE3RL.cjs → chunk-J42V6HSP.cjs}

@@ -2,7 +2,7 @@
 
 
 
-var _chunkW2TLJBAAcjs = require('./chunk-W2TLJBAA.cjs');
+var _chunk6NAV4SCFcjs = require('./chunk-6NAV4SCF.cjs');
 
 
 
@@ -10,7 +10,7 @@ var _chunkW2TLJBAAcjs = require('./chunk-W2TLJBAA.cjs');
 
 
 
-var _chunkI7VKDF3Ecjs = require('./chunk-I7VKDF3E.cjs');
+var _chunkSELGX4Y2cjs = require('./chunk-SELGX4Y2.cjs');
 
 
 var _chunkZ2SLBFQLcjs = require('./chunk-Z2SLBFQL.cjs');
@@ -25,25 +25,25 @@ async function setupRemoteScope(runtime, scripts = [], url = new URL(location.hr
   const self = globalThis;
   const ns = _chunkZ2SLBFQLcjs.getNamespace.call(void 0, );
   const bundleName = _nullishCoalesce(bundle, () => ( "default"));
-  const existingScope = _chunkI7VKDF3Ecjs.getScope.call(void 0, bundleName);
+  const existingScope = _chunkSELGX4Y2cjs.getScope.call(void 0, bundleName);
   if (existingScope && existingScope.url.origin === url.origin) {
     _chunkBBXVML3Dcjs.logDebug.call(void 0, 
       "WebpackRuntime",
       `Reusing scope "${existingScope.scopedName}" (turbopackModules=${existingScope.turbopackModules.length})`
     );
     existingScope.resolveClientUrl = resolveClientUrl;
-    if (runtime === _chunkI7VKDF3Ecjs.RUNTIME_TURBOPACK) {
+    if (runtime === _chunkSELGX4Y2cjs.RUNTIME_TURBOPACK) {
       await Promise.allSettled(
         scripts.map(
-          (script) => script.src ? _chunkW2TLJBAAcjs.loadChunkWithScope.call(void 0, existingScope, script.src) : Promise.resolve(void 0)
+          (script) => script.src ? _chunk6NAV4SCFcjs.loadChunkWithScope.call(void 0, existingScope, script.src) : Promise.resolve(void 0)
         )
       );
     }
     return existingScope;
   }
-  const scope = _chunkI7VKDF3Ecjs.createScope.call(void 0, bundleName, url, runtime, resolveClientUrl);
-  _chunkI7VKDF3Ecjs.registerScope.call(void 0, scope);
-  if (runtime === _chunkI7VKDF3Ecjs.RUNTIME_WEBPACK && _optionalChain([self, 'access', _ => _.__remote_webpack_require__, 'optionalAccess', _2 => _2[bundleName]])) {
+  const scope = _chunkSELGX4Y2cjs.createScope.call(void 0, bundleName, url, runtime, resolveClientUrl);
+  _chunkSELGX4Y2cjs.registerScope.call(void 0, scope);
+  if (runtime === _chunkSELGX4Y2cjs.RUNTIME_WEBPACK && _optionalChain([self, 'access', _ => _.__remote_webpack_require__, 'optionalAccess', _2 => _2[bundleName]])) {
     scope.webpackRequire = self.__remote_webpack_require__[bundleName];
   }
   ns.bundleUrls[bundleName] = url;
@@ -57,12 +57,12 @@ async function setupRemoteScope(runtime, scripts = [], url = new URL(location.hr
       self.__original_webpack_chunk_load__ = self.__webpack_chunk_load__;
       self.__original_webpack_require__ = self.__webpack_require__;
     }
-    self.__webpack_chunk_load__ = _chunkW2TLJBAAcjs.createChunkDispatcher.call(void 0, );
+    self.__webpack_chunk_load__ = _chunk6NAV4SCFcjs.createChunkDispatcher.call(void 0, );
     self.__webpack_require__ = createModuleDispatcher(runtime);
     ns.dispatcherRuntime = runtime;
     self.__webpack_require_type__ = runtime;
   }
-  if (runtime === _chunkI7VKDF3Ecjs.RUNTIME_TURBOPACK && typeof self.__webpack_require__ === "function") {
+  if (runtime === _chunkSELGX4Y2cjs.RUNTIME_TURBOPACK && typeof self.__webpack_require__ === "function") {
     self.__remote_webpack_require__ ??= {};
     self.__remote_webpack_require__[bundleName] = self.__webpack_require__;
     self.__remote_webpack_require__[bundleName].type = "turbopack";
@@ -70,11 +70,11 @@ async function setupRemoteScope(runtime, scripts = [], url = new URL(location.hr
   if (_optionalChain([self, 'access', _3 => _3.__remote_webpack_require__, 'optionalAccess', _4 => _4[bundleName]]) && scope.scopedName !== bundleName) {
     self.__remote_webpack_require__[scope.scopedName] = self.__remote_webpack_require__[bundleName];
   }
-  if (runtime === _chunkI7VKDF3Ecjs.RUNTIME_TURBOPACK) {
+  if (runtime === _chunkSELGX4Y2cjs.RUNTIME_TURBOPACK) {
     const results = await Promise.allSettled(
       scripts.map((script) => {
         if (script.src) {
-          return _chunkW2TLJBAAcjs.loadChunkWithScope.call(void 0, scope, script.src);
+          return _chunk6NAV4SCFcjs.loadChunkWithScope.call(void 0, scope, script.src);
         }
         return Promise.resolve(void 0);
       })
@@ -93,7 +93,7 @@ async function setupRemoteScope(runtime, scripts = [], url = new URL(location.hr
 function createModuleDispatcher(runtime) {
   return (id) => {
     const self = globalThis;
-    const { bundle, id: moduleId } = _nullishCoalesce(_optionalChain([id, 'access', _5 => _5.match, 'call', _6 => _6(_chunkI7VKDF3Ecjs.REMOTE_COMPONENT_REGEX), 'optionalAccess', _7 => _7.groups]), () => ( {
+    const { bundle, id: moduleId } = _nullishCoalesce(_optionalChain([id, 'access', _5 => _5.match, 'call', _6 => _6(_chunkSELGX4Y2cjs.REMOTE_COMPONENT_REGEX), 'optionalAccess', _7 => _7.groups]), () => ( {
       bundle: "default",
       id
     }));
@@ -104,15 +104,15 @@ function createModuleDispatcher(runtime) {
       `Resolving "${id}" (bundle: "${bundleName}", runtime: "${remoteRuntime}")`
     );
     try {
-      if (remoteRuntime === _chunkI7VKDF3Ecjs.RUNTIME_WEBPACK && bundle && moduleId) {
-        const scope2 = _chunkI7VKDF3Ecjs.getScope.call(void 0, bundle);
+      if (remoteRuntime === _chunkSELGX4Y2cjs.RUNTIME_WEBPACK && bundle && moduleId) {
+        const scope2 = _chunkSELGX4Y2cjs.getScope.call(void 0, bundle);
         if (_optionalChain([scope2, 'optionalAccess', _13 => _13.webpackRequire]))
           return scope2.webpackRequire(moduleId);
         return _optionalChain([self, 'access', _14 => _14.__remote_webpack_require__, 'optionalAccess', _15 => _15[bundle], 'optionalCall', _16 => _16(moduleId)]);
       }
-      const scope = _chunkI7VKDF3Ecjs.getScope.call(void 0, bundleName);
+      const scope = _chunkSELGX4Y2cjs.getScope.call(void 0, bundleName);
       if (scope) {
-        return _chunkW2TLJBAAcjs.requireModule.call(void 0, scope, _nullishCoalesce(moduleId, () => ( id)), id);
+        return _chunk6NAV4SCFcjs.requireModule.call(void 0, scope, _nullishCoalesce(moduleId, () => ( id)), id);
       }
       throw new Error(
         `Module "${id}" not found \u2014 no scope for bundle "${bundleName}".`
@@ -149,4 +149,4 @@ function createModuleDispatcher(runtime) {
 
 
 exports.setupRemoteScope = setupRemoteScope;
-//# sourceMappingURL=chunk-YOFJE3RL.cjs.map
+//# sourceMappingURL=chunk-J42V6HSP.cjs.map

package/dist/{chunk-KTUPOJQQ.js → chunk-JYGC7T6L.js}

@@ -1,14 +1,15 @@
 import {
+  CORE_REACT_SHARED_MODULE_IDS,
   RUNTIME_WEBPACK,
   SHARED_MODULE_MANIFEST_PROTOCOL,
   collapseDoubleSlashes,
   createSharedModulePlan,
   formatRemoteId,
   getScope,
-  installSharedModulePlan,
   isSharedModuleManifest,
-  parseRemoteId
-} from "./chunk-JZRA6DPE.js";
+  parseRemoteId,
+  resolveSharedModulePlan
+} from "./chunk-6NUHDFSH.js";
 import {
   getNamespace
 } from "./chunk-D5GNZB6O.js";
@@ -24,6 +25,247 @@ import {
   isProxiedUrl
 } from "./chunk-X6YKUJKH.js";
 
+// src/host/shared/provider.ts
+var DEFAULT_VERSION = "0";
+var GLOBAL_PROVIDER_SCOPES_KEY = "__remote_components_shared_provider_scopes__";
+function getProviderScopes() {
+  const self = globalThis;
+  self[GLOBAL_PROVIDER_SCOPES_KEY] ??= {};
+  return self[GLOBAL_PROVIDER_SCOPES_KEY];
+}
+function createSharedProvider({
+  value,
+  from
+}) {
+  return {
+    get: () => value,
+    from,
+    eager: true,
+    loaded: 1
+  };
+}
+function createSharedProviderEntry({
+  id,
+  specifier,
+  value,
+  required = true,
+  singleton = true,
+  scope,
+  from = "host"
+}) {
+  return {
+    id,
+    specifier,
+    provider: createSharedProvider({ value, from }),
+    required,
+    singleton,
+    scope
+  };
+}
+async function buildSharedProviderPlan({
+  bundle,
+  hostShared,
+  remoteShared,
+  scope = `remote:${bundle}`,
+  callerTag = "SharedBroker",
+  normalizeId = (id) => id,
+  additionalEntries = [],
+  onMissing
+}) {
+  const sharedModulePlan = createSharedModulePlan({
+    bundle,
+    hostShared,
+    remoteShared,
+    scope,
+    callerTag
+  });
+  const resolved = await resolveSharedModulePlan(sharedModulePlan);
+  const entriesByIdAndSpecifier = /* @__PURE__ */ new Map();
+  const addEntry = (entry) => {
+    entriesByIdAndSpecifier.set(`${entry.id}\0${entry.specifier}`, entry);
+  };
+  for (const entry of additionalEntries) {
+    addEntry(
+      createSharedProviderEntry({
+        ...entry,
+        scope: entry.scope ?? scope
+      })
+    );
+  }
+  for (const entry of sharedModulePlan.entries) {
+    if (entry.status !== "resolved") {
+      if (onMissing && !(sharedModulePlan.protocol === SHARED_MODULE_MANIFEST_PROTOCOL && entry.required)) {
+        onMissing(entry);
+      }
+      continue;
+    }
+    const value = resolved[entry.id];
+    if (typeof value === "undefined")
+      continue;
+    addEntry(
+      createSharedProviderEntry({
+        id: normalizeId(entry.id),
+        specifier: entry.specifier,
+        value,
+        required: entry.required,
+        singleton: entry.singleton,
+        scope: entry.scope
+      })
+    );
+  }
+  return {
+    protocol: sharedModulePlan.protocol,
+    entries: Array.from(entriesByIdAndSpecifier.values())
+  };
+}
+function installSharedProvider({
+  scope,
+  specifier,
+  value,
+  from,
+  provider,
+  version = DEFAULT_VERSION
+}) {
+  const scopes = getProviderScopes();
+  const providerScope = scopes[scope] ??= {};
+  const versions = providerScope[specifier] ??= {};
+  const sharedProvider = provider ?? createSharedProvider({
+    value,
+    from: from ?? "host"
+  });
+  versions[version] = sharedProvider;
+  return sharedProvider;
+}
+function installSharedProviderEntry(entry) {
+  return installSharedProvider({
+    scope: entry.scope,
+    specifier: entry.specifier,
+    provider: entry.provider
+  });
+}
+function getSharedProvider({
+  scope,
+  specifier,
+  version = DEFAULT_VERSION
+}) {
+  const versions = getProviderScopes()[scope]?.[specifier];
+  if (!versions)
+    return void 0;
+  return versions[version] ?? (version === DEFAULT_VERSION ? void 0 : versions[DEFAULT_VERSION]);
+}
+function getSharedProviderModule({
+  scope,
+  specifier,
+  version
+}) {
+  const provider = getSharedProvider({ scope, specifier, version });
+  if (!provider) {
+    throw new Error(
+      `Shared module "${specifier}" not found in provider scope "${scope}".`
+    );
+  }
+  provider.loaded = 1;
+  return provider.get();
+}
+
+// src/config/webpack/shared-module-resolver.ts
+var WEBPACK_SHARED_RESOLVE_METADATA = Symbol.for(
+  "remote-components.webpackSharedResolveMetadata"
+);
+function normalizeWebpackSharedId(id) {
+  return id.replace(/^\(ssr\)\/(?<relative>\.\/)?/, "");
+}
+async function buildWebpackResolve(hostShared, remoteShared, bundle, reactModules, callerTag = "SharedModuleResolver") {
+  const sharedProviderPlan = await buildSharedProviderPlan({
+    bundle,
+    hostShared,
+    remoteShared,
+    callerTag,
+    normalizeId: normalizeWebpackSharedId,
+    additionalEntries: Object.entries(CORE_REACT_SHARED_MODULE_IDS).map(
+      ([specifier, id]) => ({
+        id,
+        specifier,
+        value: reactModules[id],
+        required: true,
+        singleton: true,
+        scope: `remote:${bundle}`
+      })
+    )
+  });
+  const resolve = {
+    ...Object.fromEntries(
+      sharedProviderPlan.entries.map((entry) => [
+        entry.id,
+        entry.provider.get()
+      ])
+    )
+  };
+  Object.defineProperty(resolve, WEBPACK_SHARED_RESOLVE_METADATA, {
+    enumerable: false,
+    value: {
+      protocol: sharedProviderPlan.protocol,
+      entries: sharedProviderPlan.entries
+    }
+  });
+  return resolve;
+}
+
+// src/config/webpack/provider-adapter.ts
+function applyWebpackSharedProviderModules(bundle, entries) {
+  logDebug(
+    "SharedModules",
+    `applyWebpackSharedProviderModules called for bundle: "${bundle}"`
+  );
+  const self = globalThis;
+  const scope = getScope(bundle);
+  const webpackBundle = scope?.webpackRequire ?? self.__remote_webpack_require__?.[bundle];
+  if (!webpackBundle) {
+    throw new RemoteComponentsError(
+      `No Webpack require found for manifest-aware Remote Component bundle "${bundle}".`
+    );
+  }
+  if (!webpackBundle.m) {
+    throw new RemoteComponentsError(
+      `Webpack module factories are not available for manifest-aware Remote Component bundle "${bundle}".`
+    );
+  }
+  const modulePaths = Object.keys(
+    self.__remote_webpack_module_map__?.[bundle] ?? webpackBundle.m
+  );
+  for (const entry of entries) {
+    installSharedProviderEntry(entry);
+    const ids = resolveWebpackModuleIds(bundle, modulePaths, entry.id);
+    if (ids.length === 0) {
+      continue;
+    }
+    for (const id of ids) {
+      const resolvedId = self.__remote_webpack_module_map__?.[bundle]?.[id] ? `${self.__remote_webpack_module_map__[bundle][id]}` : id;
+      webpackBundle.m[resolvedId] = (module) => {
+        module.exports = getSharedProviderModule({
+          scope: entry.scope,
+          specifier: entry.specifier
+        });
+      };
+    }
+  }
+}
+function resolveWebpackModuleIds(bundle, modulePaths, id) {
+  const exactIds = modulePaths.filter((path) => path === id);
+  if (exactIds.length > 0) {
+    return exactIds;
+  }
+  const containedIds = modulePaths.filter((path) => path.includes(id));
+  if (containedIds.length > 0) {
+    return containedIds;
+  }
+  logDebug(
+    "SharedModules",
+    `No matching module path found for manifest shared module "${id}" in bundle "${bundle}"`
+  );
+  return [];
+}
+
 // 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) {
@@ -35,6 +277,11 @@ function applySharedModules(bundle, resolve) {
     "SharedModules",
     `Shared modules to resolve: ${Object.keys(resolve)}`
   );
+  const metadata = resolve[WEBPACK_SHARED_RESOLVE_METADATA];
+  if (metadata?.protocol === SHARED_MODULE_MANIFEST_PROTOCOL) {
+    applyWebpackSharedProviderModules(bundle, metadata.entries);
+    return;
+  }
   const self = globalThis;
   const scope = getScope(bundle);
   const webpackBundle = scope?.webpackRequire ?? self.__remote_webpack_require__?.[bundle];
@@ -510,13 +757,17 @@ function createTurbopackContext(scope, exports, moduleExports, modules, moduleIn
     r(requireId) {
       return scopedRequire(requireId);
     },
-    // value exports
+    // exportValue — mirrors upstream Turbopack's `exportValue`, which sets
+    // `module.exports = value` regardless of value type. Most importantly,
+    // when Turbopack emits an async-loader module the body is
+    //   ctx.v((parentImport) => Promise.all([...]).then(() => parentImport(id)))
+    // The function must be stored as-is so that the consumer's `ctx.A(id)`
+    // can invoke it with the real parent-import resolver. Calling it eagerly
+    // here (the prior remote-components behavior) ran the loader with the
+    // wrong argument and stored a `Promise` as `exports.default`, which then
+    // crashed `ctx.A` with `.default is not a function`.
     v(value) {
-      if (typeof value === "function") {
-        exports.default = value((vid) => scopedRequire(vid));
-      } else {
-        moduleExports.exports = value;
-      }
+      moduleExports.exports = value;
     },
     // exportUrl — used by static asset modules (images, fonts, JSON, etc.).
     // Turbopack emits a tiny module whose entire body is ctx.q(url), which
@@ -529,6 +780,20 @@ function createTurbopackContext(scope, exports, moduleExports, modules, moduleIn
         moduleExports.exports = value;
       }
     },
+    // exportNamespace — Turbopack emits `ctx.n(namespace, esmId?)` when a
+    // module's exports should be replaced wholesale with a precomputed ESM
+    // namespace object (commonly at module evaluation time for re-export
+    // patterns and CJS-to-ESM interop wrappers). Mirrors upstream
+    // `exportNamespace` which sets both `module.exports` and
+    // `module.namespaceObject`; remote-components keeps a single exports
+    // record per module, so we assign to `exports` only.
+    n(namespace, esmId) {
+      if (esmId != null) {
+        scope.moduleCache[String(esmId)] = namespace;
+      } else {
+        moduleExports.exports = namespace;
+      }
+    },
     // async module initializer
     async a(mod) {
       let result;
@@ -539,10 +804,24 @@ function createTurbopackContext(scope, exports, moduleExports, modules, moduleIn
       );
       exports.default = result;
     },
-    // async module loader — resolves directly via scope
+    // async module loader — resolves directly via scope.
+    //
+    // Upstream Turbopack's `asyncLoader` treats `require(id)` itself as the
+    // loader function (see `module.exports = loaderFn` set by the factory).
+    // remote-components additionally supports `{ default: loaderFn }`, which
+    // is what a factory using `ctx.s([['default', () => fn]], ...)` produces.
+    // Both shapes must be accepted: when `ctx.n(loaderFn, esmId)` injects a
+    // function directly into the cache, the require result is the function
+    // itself and there is no `.default` to dereference.
     async A(Aid) {
       const mod = scopedRequire(Aid);
-      return mod.default((parentId) => scopedRequire(parentId));
+      const loader = typeof mod === "function" ? mod : mod?.default;
+      if (typeof loader !== "function") {
+        throw new Error(
+          `Async module loader for "${Aid}" is not a function (got ${typeof loader})`
+        );
+      }
+      return loader((parentId) => scopedRequire(parentId));
     },
     // dynamic import tracking — no-op for remote components
     j() {
@@ -635,12 +914,19 @@ async function initializeSharedModules(scope, hostShared = {}, remoteShared = {}
         "sharedModuleId"
       );
       if (sharedModuleId) {
-        const { default: sharedModuleInitializerInstance } = handleTurbopackModule(
+        const moduleExports = handleTurbopackModule(
           scope,
           sharedModuleId,
           formatRemoteId(scope, String(sharedModuleInitializerId))
         );
-        sharedModuleInitializer = sharedModuleInitializerInstance;
+        const loaderCandidate = typeof moduleExports === "function" ? moduleExports : moduleExports?.default;
+        if (typeof loaderCandidate === "function") {
+          sharedModuleInitializer = loaderCandidate(
+            (parentId) => requireModule(scope, parentId)
+          );
+        } else if (loaderCandidate && typeof loaderCandidate.then === "function") {
+          sharedModuleInitializer = loaderCandidate;
+        }
       }
     }
     if (sharedModuleInitializer) {
@@ -758,33 +1044,26 @@ function stripQuotes2(value) {
   return value;
 }
 function installSharedModules(scope, hostShared, sharedModuleIds, missingMessage) {
-  const plan = createSharedModulePlan({
+  return buildSharedProviderPlan({
     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;
-  });
+  }).then(
+    (results) => results.entries.map((entry) => {
+      installSharedProviderEntry(entry);
+      scope.sharedModules[entry.id] = getSharedProviderModule({
+        scope: entry.scope,
+        specifier: entry.specifier
+      });
+      delete scope.moduleCache[entry.id];
+      return void 0;
+    })
+  );
 }
 function preferSharedManifest(sharedModuleIds, remoteShared) {
   if (!isSharedModuleManifest(remoteShared))
@@ -1060,6 +1339,7 @@ function findPreviousModuleId(entries, factoryIndex) {
 }
 
 export {
+  buildWebpackResolve,
   applySharedModules,
   loadChunkWithScope,
   createChunkDispatcher,
@@ -1067,4 +1347,4 @@ export {
   requireModule,
   nextClientPagesLoader
 };
-//# sourceMappingURL=chunk-KTUPOJQQ.js.map
+//# sourceMappingURL=chunk-JYGC7T6L.js.map