@bleedingdev/modern-js-federation-runtime 3.9.0-ultramodern.9 → 3.9.3-ultramodern.1

package/dist/cjs/module-federation/renderer-runtime-plugin.js

@@ -0,0 +1,265 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createRendererFederationRuntimePlugin: ()=>createRendererFederationRuntimePlugin,
+    default: ()=>renderer_runtime_plugin,
+    rendererShareVersions: ()=>rendererShareVersions
+});
+const sdk_namespaceObject = require("@module-federation/sdk");
+const external_renderer_contract_js_namespaceObject = require("./renderer-contract.js");
+const ATTESTATION = Symbol.for('ultramodern.renderer-federation.attestation.v1');
+const record = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
+const coordinates = (snapshot)=>JSON.stringify([
+        'globalName',
+        'buildVersion',
+        'remoteEntry',
+        'remoteEntryType',
+        'ssrRemoteEntry',
+        'ssrRemoteEntryType',
+        'publicPath',
+        'ssrPublicPath',
+        'getPublicPath'
+    ].map((key)=>[
+            key,
+            snapshot[key]
+        ]));
+function attestation(snapshot) {
+    const descriptor = Object.getOwnPropertyDescriptor(snapshot, ATTESTATION);
+    const value = descriptor?.value;
+    if (!descriptor || descriptor.writable || descriptor.configurable || !record(value) || 'string' != typeof value.coordinates || value.coordinates !== coordinates(snapshot)) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('cached remote snapshot is missing or has changed its attestation.');
+    return {
+        contract: (0, external_renderer_contract_js_namespaceObject.readRendererFederationContract)(value.contract),
+        coordinates: value.coordinates
+    };
+}
+const assertManifestRemote = (remote)=>{
+    if (!record(remote)) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('remote registration is absent.');
+    if ('entry' in remote && ('string' != typeof remote.entry || !remote.entry.includes('.json'))) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('renderer components require a native JSON manifest remote.');
+};
+function sameFactory(left, right) {
+    if (left === right) return true;
+    if ('function' == typeof left.lib && 'function' == typeof right.lib) return left.lib === right.lib;
+    return 'function' == typeof left.get && left.get === right.get;
+}
+const containerCoordinates = (info)=>JSON.stringify([
+        'name',
+        'entry',
+        'type',
+        'entryGlobalName',
+        'buildVersion'
+    ].map((key)=>[
+            key,
+            info[key]
+        ]));
+const entryCoordinates = (info)=>JSON.stringify([
+        'name',
+        'entry',
+        'type',
+        'entryGlobalName'
+    ].map((key)=>[
+            key,
+            info[key]
+        ]));
+function rendererShareVersions(expected) {
+    const { profile, runtime, bootstrap } = expected;
+    if ('react' === profile.renderer) return new Map([
+        [
+            'react',
+            runtime.version
+        ],
+        [
+            'react-dom',
+            profile.hydration.version
+        ],
+        [
+            'react-dom/client',
+            profile.hydration.version
+        ],
+        [
+            '@modern-js/runtime',
+            bootstrap.version
+        ]
+    ]);
+    const versions = new Map();
+    for (const [name, version] of [
+        [
+            runtime.name,
+            runtime.version
+        ],
+        [
+            profile.hydration.name,
+            profile.hydration.version
+        ],
+        [
+            bootstrap.name,
+            bootstrap.version
+        ],
+        [
+            profile.router.name,
+            profile.router.version
+        ],
+        [
+            profile.router.coreName,
+            profile.router.coreVersion
+        ]
+    ]){
+        const prior = versions.get(name);
+        if (void 0 !== prior && prior !== version) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)(`renderer tuple names ${name} with conflicting versions.`);
+        versions.set(name, version);
+    }
+    return versions;
+}
+function createRendererFederationRuntimePlugin(options) {
+    const expected = (0, external_renderer_contract_js_namespaceObject.readRendererFederationCompatibility)(options);
+    const selected = new Map();
+    const approvedRemoteInfos = new WeakMap();
+    const observedEntries = new WeakMap();
+    const acceptedEntries = new Set();
+    const versions = rendererShareVersions(expected);
+    return {
+        name: 'ultramodern-renderer-federation-contract',
+        beforeRegisterRemote (args) {
+            assertManifestRemote(args.remote);
+            return args;
+        },
+        async afterMatchRemote (args) {
+            if (!args.error) assertManifestRemote(args.remote);
+            return args;
+        },
+        async loadRemoteSnapshot (args) {
+            const snapshot = args.remoteSnapshot;
+            if ('manifest' === args.from) {
+                const manifest = args.manifestJson;
+                const metadata = record(manifest) && record(manifest.metaData) ? manifest.metaData[external_renderer_contract_js_namespaceObject.RENDERER_FEDERATION_METADATA_KEY] : void 0;
+                const contract = (0, external_renderer_contract_js_namespaceObject.readRendererFederationContract)(metadata);
+                if (!record(snapshot) || 'string' != typeof snapshot.remoteEntry) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('native remote entry coordinates are absent.');
+                const existing = Object.getOwnPropertyDescriptor(snapshot, ATTESTATION);
+                if (existing) {
+                    const prior = attestation(snapshot);
+                    if (JSON.stringify(prior.contract) !== JSON.stringify(contract)) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('remote snapshot has conflicting publication ownership.');
+                } else Object.defineProperty(snapshot, ATTESTATION, {
+                    value: Object.freeze({
+                        contract,
+                        coordinates: coordinates(snapshot)
+                    })
+                });
+            } else (0, external_renderer_contract_js_namespaceObject.assertRendererFederationCompatibility)(expected, attestation(snapshot).contract);
+            return args;
+        },
+        async afterLoadSnapshot (args) {
+            (0, external_renderer_contract_js_namespaceObject.assertRendererFederationCompatibility)(expected, attestation(args.remoteSnapshot).contract);
+            const snapshot = args.remoteSnapshot;
+            const browser = sdk_namespaceObject.isBrowserEnvValue || (0, sdk_namespaceObject.isReactNativeEnv)() || !('ssrRemoteEntry' in snapshot);
+            const entry = browser ? snapshot.remoteEntry : snapshot.ssrRemoteEntry;
+            if ('string' != typeof entry || !entry) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('native projected remote entry is absent.');
+            let entryUrl = (0, sdk_namespaceObject.getResourceUrl)(snapshot, entry);
+            if (!sdk_namespaceObject.isBrowserEnvValue && !entryUrl.startsWith('http')) entryUrl = `https:${entryUrl}`;
+            acceptedEntries.add(entryCoordinates({
+                name: args.moduleInfo?.name ?? snapshot.globalName,
+                entry: entryUrl,
+                type: browser ? snapshot.remoteEntryType : snapshot.ssrRemoteEntryType || 'global',
+                entryGlobalName: snapshot.globalName
+            }));
+            return args;
+        },
+        async afterResolve (args) {
+            if (!args.remoteSnapshot) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('native remote resolution has no attested snapshot.');
+            (0, external_renderer_contract_js_namespaceObject.assertRendererFederationCompatibility)(expected, attestation(args.remoteSnapshot).contract);
+            const cached = args.origin.moduleCache.get(args.remote.name);
+            if (cached && (approvedRemoteInfos.get(cached.remoteInfo) !== containerCoordinates(cached.remoteInfo) || containerCoordinates(cached.remoteInfo) !== containerCoordinates(args.remoteInfo))) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('cached remote container has unattested or conflicting ownership.');
+            const priorCoordinates = approvedRemoteInfos.get(args.remoteInfo);
+            if (void 0 !== priorCoordinates && priorCoordinates !== containerCoordinates(args.remoteInfo)) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('native remote container coordinates changed after attestation.');
+            approvedRemoteInfos.set(args.remoteInfo, containerCoordinates(args.remoteInfo));
+            return args;
+        },
+        loadEntry (args) {
+            if (!acceptedEntries.has(entryCoordinates(args.remoteInfo))) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('remote entry coordinates differ from the attested native snapshot.');
+        },
+        async afterLoadEntry (args) {
+            if (args.error && !args.recovered) return args;
+            const binding = containerCoordinates(args.remoteInfo);
+            const entryBinding = entryCoordinates(args.remoteInfo);
+            if (args.cached && approvedRemoteInfos.get(args.remoteInfo) !== binding) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('remote entry has no attested native container resolution.');
+            if (!acceptedEntries.has(entryBinding)) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('remote entry coordinates differ from the attested native snapshot.');
+            const entry = args.remoteEntryExports;
+            if (('object' != typeof entry || null === entry) && 'function' != typeof entry) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('native container exports are absent.');
+            if (args.cached && observedEntries.get(entry) !== entryBinding) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)('cached native container exports have unattested ownership.');
+            approvedRemoteInfos.set(args.remoteInfo, binding);
+            observedEntries.set(entry, entryBinding);
+            return args;
+        },
+        resolveShare (args) {
+            const version = versions.get(args.pkgName);
+            if (void 0 === version) return args;
+            const resolve = args.resolver;
+            return {
+                ...args,
+                resolver () {
+                    const result = resolve();
+                    if (!result) return result;
+                    const shared = result.useTreesShaking && record(result.shared.treeShaking) ? result.shared.treeShaking : result.shared;
+                    if (result.shared.version !== version) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)(`shared ${args.pkgName} version must be ${version}.`);
+                    const prior = selected.get(args.pkgName);
+                    if (prior && !sameFactory(prior, shared)) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)(`shared ${args.pkgName} has conflicting runtime ownership.`);
+                    for (const scope of Object.values(args.shareScopeMap))for (const candidate of Object.values(scope[args.pkgName] ?? {})){
+                        const active = record(candidate.treeShaking) && candidate.treeShaking.loaded ? candidate.treeShaking : candidate;
+                        if ((active.loaded || active.lib) && !sameFactory(active, shared)) throw (0, external_renderer_contract_js_namespaceObject.rendererFederationError)(`shared ${args.pkgName} has duplicate loaded runtime identities.`);
+                    }
+                    selected.set(args.pkgName, Object.freeze({
+                        lib: shared.lib,
+                        get: shared.get
+                    }));
+                    return result;
+                }
+            };
+        },
+        afterLoadShare (args) {
+            if (versions.has(args.pkgName) && args.selectedShared) {
+                const shared = record(args.selectedShared.treeShaking) && args.selectedShared.treeShaking.loaded ? args.selectedShared.treeShaking : args.selectedShared;
+                selected.set(args.pkgName, Object.freeze({
+                    lib: shared.lib,
+                    get: shared.get
+                }));
+            }
+        }
+    };
+}
+const renderer_runtime_plugin = createRendererFederationRuntimePlugin;
+exports.createRendererFederationRuntimePlugin = __webpack_exports__.createRendererFederationRuntimePlugin;
+exports["default"] = __webpack_exports__["default"];
+exports.rendererShareVersions = __webpack_exports__.rendererShareVersions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRendererFederationRuntimePlugin",
+    "default",
+    "rendererShareVersions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-federation/telemetry.js

@@ -0,0 +1,214 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = 'modernjs:mf-runtime-fallback';
+const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = 'modernjs:mf-runtime-recovery';
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = '/_modern/contract-gates/runtime-fallback';
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = 'x-modernjs-runtime-signal-token';
+class ModuleFederationRemoteLoadTimeoutError extends Error {
+    constructor(remote, timeoutMs){
+        super(`Loading remote "${remote}" timed out after ${timeoutMs}ms`);
+        this.name = 'ModuleFederationRemoteLoadTimeoutError';
+    }
+}
+class ModuleFederationRemoteLoadError extends Error {
+    constructor(remote, attempts, causeError){
+        super(`Unable to load remote "${remote}" after ${attempts} attempt${attempts > 1 ? 's' : ''}: ${causeError.message}`);
+        this.name = 'ModuleFederationRemoteLoadError';
+        this.remote = remote;
+        this.attempts = attempts;
+        this.causeError = causeError;
+    }
+}
+class ModuleFederationRemoteComponentContractError extends Error {
+    constructor(remote, exportName){
+        super(`Remote "${remote}" export "${exportName}" is not a valid React component`);
+        this.name = 'ModuleFederationRemoteComponentContractError';
+    }
+}
+function toError(error) {
+    if (error instanceof Error) return error;
+    return new Error('string' == typeof error ? error : 'Unknown remote load error');
+}
+function classifyModuleFederationFallback(error) {
+    const normalizedError = toError(error);
+    if (normalizedError instanceof ModuleFederationRemoteLoadError) return classifyModuleFederationFallback(normalizedError.causeError);
+    if (normalizedError instanceof ModuleFederationRemoteLoadTimeoutError) return 'timeout';
+    if (normalizedError instanceof ModuleFederationRemoteComponentContractError) return 'contract';
+    const message = normalizedError.message;
+    if (/version|requiredVersion|singleton|share scope|shared module/i.test(message)) return 'version-skew';
+    if (/network|fetch|script|timeout|chunk|loading/i.test(message)) return 'network';
+    return 'remote-unavailable';
+}
+function createModuleFederationFallbackTelemetry(input) {
+    const error = void 0 !== input.error ? toError(input.error) : void 0;
+    const status = input.status ?? 'degraded';
+    const eventName = input.eventName ?? ('recovered' === status ? MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT : MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT);
+    const metadata = {
+        ...input.metadata ?? {},
+        classification: input.classification,
+        remote: input.remote,
+        status
+    };
+    if (void 0 !== input.exportName) metadata.exportName = input.exportName;
+    if (void 0 !== input.runtimeDigest) metadata.runtimeDigest = input.runtimeDigest;
+    if (void 0 !== error) {
+        metadata.errorName = error.name;
+        metadata.errorMessage = error.message;
+    }
+    const payload = {
+        appName: input.appName,
+        eventName,
+        metadata,
+        phase: input.phase,
+        reason: input.classification,
+        schemaVersion: 1
+    };
+    if (void 0 !== input.entry) payload.entry = input.entry;
+    if (void 0 !== input.runtimeDigest) payload.runtimeDigest = input.runtimeDigest;
+    return payload;
+}
+function toModuleFederationFallbackAttributes(payload) {
+    return {
+        'data-mf-fallback-app': payload.appName,
+        'data-mf-fallback-classification': payload.reason,
+        'data-mf-fallback-phase': payload.phase,
+        'data-mf-fallback-remote': String(payload.metadata.remote),
+        'data-mf-fallback-status': String(payload.metadata.status),
+        'data-mf-telemetry-event': payload.eventName
+    };
+}
+function emitModuleFederationFallbackTelemetry(input, options = {}) {
+    return emitModuleFederationFallbackPayload(createModuleFederationFallbackTelemetry(input), options);
+}
+function emitModuleFederationFallbackPayload(payload, options = {}) {
+    const delivery = deliver(payload, options);
+    try {
+        options.observe?.(payload, delivery);
+    } catch  {}
+    return delivery;
+}
+async function deliver(payload, options) {
+    let dispatched = false;
+    let timer;
+    const controller = new AbortController();
+    try {
+        if ("u" > typeof window && 'function' == typeof window.dispatchEvent && "u" > typeof CustomEvent) {
+            window.dispatchEvent(new CustomEvent(payload.eventName, {
+                detail: payload
+            }));
+            dispatched = true;
+        }
+        const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+        if (!(true === options.postSignal || options.endpoint) || 'function' != typeof fetchImpl) return {
+            dispatched,
+            posted: false
+        };
+        const headers = new Headers({
+            'content-type': 'application/json'
+        });
+        if (options.authToken) headers.set(options.authHeaderName ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, options.authToken);
+        const timeoutMs = Number.isSafeInteger(options.timeoutMs) && (options.timeoutMs ?? 0) > 0 ? options.timeoutMs : 1000;
+        const expired = new Promise((resolve)=>{
+            timer = setTimeout(()=>{
+                controller.abort();
+                resolve(void 0);
+            }, timeoutMs);
+        });
+        const response = await Promise.race([
+            fetchImpl(options.endpoint ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, {
+                body: JSON.stringify(payload),
+                headers,
+                method: 'POST',
+                keepalive: true,
+                signal: controller.signal
+            }),
+            expired
+        ]);
+        return response ? {
+            dispatched,
+            posted: true,
+            postStatus: response.status
+        } : {
+            dispatched,
+            posted: false
+        };
+    } catch  {
+        return {
+            dispatched,
+            posted: false
+        };
+    } finally{
+        if (void 0 !== timer) clearTimeout(timer);
+    }
+}
+__webpack_require__.d(__webpack_exports__, {
+    ModuleFederationRemoteComponentContractError: ()=>ModuleFederationRemoteComponentContractError,
+    ModuleFederationRemoteLoadError: ()=>ModuleFederationRemoteLoadError,
+    ModuleFederationRemoteLoadTimeoutError: ()=>ModuleFederationRemoteLoadTimeoutError,
+    classifyModuleFederationFallback: ()=>classifyModuleFederationFallback,
+    createModuleFederationFallbackTelemetry: ()=>createModuleFederationFallbackTelemetry,
+    emitModuleFederationFallbackPayload: ()=>emitModuleFederationFallbackPayload,
+    emitModuleFederationFallbackTelemetry: ()=>emitModuleFederationFallbackTelemetry,
+    toModuleFederationFallbackAttributes: ()=>toModuleFederationFallbackAttributes
+}, {
+    DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER: DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER,
+    DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT: DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT,
+    MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT: MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT,
+    MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT: MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT
+});
+exports.DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = __webpack_exports__.DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER;
+exports.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = __webpack_exports__.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT;
+exports.MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = __webpack_exports__.MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT;
+exports.MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = __webpack_exports__.MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT;
+exports.ModuleFederationRemoteComponentContractError = __webpack_exports__.ModuleFederationRemoteComponentContractError;
+exports.ModuleFederationRemoteLoadError = __webpack_exports__.ModuleFederationRemoteLoadError;
+exports.ModuleFederationRemoteLoadTimeoutError = __webpack_exports__.ModuleFederationRemoteLoadTimeoutError;
+exports.classifyModuleFederationFallback = __webpack_exports__.classifyModuleFederationFallback;
+exports.createModuleFederationFallbackTelemetry = __webpack_exports__.createModuleFederationFallbackTelemetry;
+exports.emitModuleFederationFallbackPayload = __webpack_exports__.emitModuleFederationFallbackPayload;
+exports.emitModuleFederationFallbackTelemetry = __webpack_exports__.emitModuleFederationFallbackTelemetry;
+exports.toModuleFederationFallbackAttributes = __webpack_exports__.toModuleFederationFallbackAttributes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER",
+    "DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT",
+    "MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT",
+    "MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT",
+    "ModuleFederationRemoteComponentContractError",
+    "ModuleFederationRemoteLoadError",
+    "ModuleFederationRemoteLoadTimeoutError",
+    "classifyModuleFederationFallback",
+    "createModuleFederationFallbackTelemetry",
+    "emitModuleFederationFallbackPayload",
+    "emitModuleFederationFallbackTelemetry",
+    "toModuleFederationFallbackAttributes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/module-federation/consume-surface.mjs

@@ -1,5 +1,5 @@
-import { classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackTelemetry } from "./index.mjs";
 import { createDiscoveryError, formatSurfaceRef, parseSurfaceRef, validateSurfaceRef } from "./surface-resolution-types.mjs";
+import { classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackPayload, emitModuleFederationFallbackTelemetry } from "./telemetry.mjs";
 function classifyDiscoveryError(code) {
     switch(code){
         case 'major-not-published':
@@ -38,17 +38,7 @@ async function reportFailure(options, ref, base) {
         remote,
         status: 'degraded'
     });
-    try {
-        await emitModuleFederationFallbackTelemetry({
-            appName: options.appName,
-            classification: base.classification,
-            error: base.error ?? base.discoveryError,
-            metadata: telemetry.metadata,
-            phase: base.phase,
-            remote,
-            status: 'degraded'
-        }, options.telemetry ?? {});
-    } catch  {}
+    emitModuleFederationFallbackPayload(telemetry, options.telemetry);
     const failure = {
         ref,
         env: options.env,
@@ -68,7 +58,7 @@ async function reportFailure(options, ref, base) {
         degradedValue = await options.degraded(failure);
     } catch (handlerError) {
         try {
-            await emitModuleFederationFallbackTelemetry({
+            emitModuleFederationFallbackTelemetry({
                 appName: options.appName,
                 classification: base.classification,
                 error: handlerError,

package/dist/esm/module-federation/distributed-ssr.mjs

@@ -62,7 +62,12 @@ function DistributedSsrBoundary({ children, expose, fallback, fragmentProps, rem
 function createDistributedSsrComponent({ createComponent, expose, fallback, remote }) {
     let RemoteComponent;
     function DeferredRemoteComponent(props) {
-        RemoteComponent ??= createComponent();
+        RemoteComponent ??= createComponent({
+            export: 'default',
+            fallback,
+            injectLink: false,
+            loading: null
+        });
         return /*#__PURE__*/ jsx(RemoteComponent, {
             ...props
         });

package/dist/esm/module-federation/index.mjs

@@ -1,115 +1,5 @@
 export * from "./consume-surface.mjs";
-export * from "./distributed-ssr.mjs";
 export * from "./last-known-good.mjs";
 export * from "./manifest-recovery-runtime-plugin.mjs";
 export * from "./surface-resolution-types.mjs";
-const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = 'modernjs:mf-runtime-fallback';
-const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = 'modernjs:mf-runtime-recovery';
-const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = '/_modern/contract-gates/runtime-fallback';
-const DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = 'x-modernjs-runtime-signal-token';
-class ModuleFederationRemoteLoadTimeoutError extends Error {
-    constructor(remote, timeoutMs){
-        super(`Loading remote "${remote}" timed out after ${timeoutMs}ms`);
-        this.name = 'ModuleFederationRemoteLoadTimeoutError';
-    }
-}
-class ModuleFederationRemoteLoadError extends Error {
-    constructor(remote, attempts, causeError){
-        super(`Unable to load remote "${remote}" after ${attempts} attempt${attempts > 1 ? 's' : ''}: ${causeError.message}`);
-        this.name = 'ModuleFederationRemoteLoadError';
-        this.remote = remote;
-        this.attempts = attempts;
-        this.causeError = causeError;
-    }
-}
-class ModuleFederationRemoteComponentContractError extends Error {
-    constructor(remote, exportName){
-        super(`Remote "${remote}" export "${exportName}" is not a valid React component`);
-        this.name = 'ModuleFederationRemoteComponentContractError';
-    }
-}
-function toError(error) {
-    if (error instanceof Error) return error;
-    return new Error('string' == typeof error ? error : 'Unknown remote load error');
-}
-function classifyModuleFederationFallback(error) {
-    const normalizedError = toError(error);
-    if (normalizedError instanceof ModuleFederationRemoteLoadError) return classifyModuleFederationFallback(normalizedError.causeError);
-    if (normalizedError instanceof ModuleFederationRemoteLoadTimeoutError) return 'timeout';
-    if (normalizedError instanceof ModuleFederationRemoteComponentContractError) return 'contract';
-    const message = normalizedError.message;
-    if (/version|requiredVersion|singleton|share scope|shared module/i.test(message)) return 'version-skew';
-    if (/network|fetch|script|timeout|chunk|loading/i.test(message)) return 'network';
-    return 'remote-unavailable';
-}
-function createModuleFederationFallbackTelemetry(input) {
-    const error = void 0 !== input.error ? toError(input.error) : void 0;
-    const status = input.status ?? 'degraded';
-    const eventName = input.eventName ?? ('recovered' === status ? MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT : MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT);
-    const metadata = {
-        ...input.metadata ?? {},
-        classification: input.classification,
-        remote: input.remote,
-        status
-    };
-    if (void 0 !== input.exportName) metadata.exportName = input.exportName;
-    if (void 0 !== input.runtimeDigest) metadata.runtimeDigest = input.runtimeDigest;
-    if (void 0 !== error) {
-        metadata.errorName = error.name;
-        metadata.errorMessage = error.message;
-    }
-    const payload = {
-        appName: input.appName,
-        eventName,
-        metadata,
-        phase: input.phase,
-        reason: input.classification,
-        schemaVersion: 1
-    };
-    if (void 0 !== input.entry) payload.entry = input.entry;
-    if (void 0 !== input.runtimeDigest) payload.runtimeDigest = input.runtimeDigest;
-    return payload;
-}
-function toModuleFederationFallbackAttributes(payload) {
-    return {
-        'data-mf-fallback-app': payload.appName,
-        'data-mf-fallback-classification': payload.reason,
-        'data-mf-fallback-phase': payload.phase,
-        'data-mf-fallback-remote': String(payload.metadata.remote),
-        'data-mf-fallback-status': String(payload.metadata.status),
-        'data-mf-telemetry-event': payload.eventName
-    };
-}
-async function emitModuleFederationFallbackTelemetry(input, options = {}) {
-    const payload = createModuleFederationFallbackTelemetry(input);
-    if ("u" > typeof window && 'function' == typeof window.dispatchEvent && "u" > typeof CustomEvent) window.dispatchEvent(new CustomEvent(payload.eventName, {
-        detail: payload
-    }));
-    const shouldPost = true === options.postSignal || Boolean(options.endpoint);
-    if (!shouldPost) return {
-        dispatched: true,
-        posted: false
-    };
-    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
-    if ('function' != typeof fetchImpl) return {
-        dispatched: true,
-        posted: false
-    };
-    const headers = new Headers({
-        'content-type': 'application/json'
-    });
-    if (void 0 !== options.authToken && options.authToken.length > 0) headers.set(options.authHeaderName ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, options.authToken);
-    const response = await fetchImpl(options.endpoint ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, {
-        body: JSON.stringify(payload),
-        headers,
-        method: 'POST',
-        keepalive: true
-    });
-    return {
-        dispatched: true,
-        posted: true,
-        postStatus: response.status
-    };
-}
-export { DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY, useDistributedSsrFragmentProps } from "./distributed-ssr.mjs";
-export { DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT, MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT, ModuleFederationRemoteComponentContractError, ModuleFederationRemoteLoadError, ModuleFederationRemoteLoadTimeoutError, classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackTelemetry, toModuleFederationFallbackAttributes };
+export * from "./telemetry.mjs";

package/dist/esm/module-federation/manifest-recovery-runtime-plugin.mjs

@@ -31,7 +31,7 @@ const getErrorStatus = (error)=>{
     if ('object' == typeof error && null !== error && 'status' in error && 'number' == typeof error.status) return error.status;
 };
 const isRetryableError = (error)=>{
-    if (error instanceof SyntaxError) return false;
+    if (error instanceof SyntaxError) return true;
     const message = getErrorMessage(error);
     if (NON_RETRYABLE_ERROR_PATTERNS.some((pattern)=>pattern.test(message))) return false;
     const status = getErrorStatus(error);