@bleedingdev/modern-js-federation-runtime 0.0.0 → 3.9.0-ultramodern.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cjs/module-federation/consume-surface.js

@@ -0,0 +1,199 @@
+"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__, {
+    consumeSurface: ()=>consumeSurface,
+    createSurfaceConsumer: ()=>createSurfaceConsumer
+});
+const external_index_js_namespaceObject = require("./index.js");
+const external_surface_resolution_types_js_namespaceObject = require("./surface-resolution-types.js");
+function classifyDiscoveryError(code) {
+    switch(code){
+        case 'major-not-published':
+        case 'stale-record':
+            return 'version-skew';
+        case 'identity-mismatch':
+            return 'contract';
+        case 'unknown-unit':
+        case 'unknown-surface':
+        case 'provider-unavailable':
+            return 'remote-unavailable';
+        default:
+            return 'remote-unavailable';
+    }
+}
+function toRemoteString(ref) {
+    return void 0 === (0, external_surface_resolution_types_js_namespaceObject.validateSurfaceRef)(ref) ? (0, external_surface_resolution_types_js_namespaceObject.formatSurfaceRef)(ref) : `${ref.unitId}#${ref.surfaceId}`;
+}
+async function reportFailure(options, ref, base) {
+    const remote = toRemoteString(ref);
+    const telemetry = (0, external_index_js_namespaceObject.createModuleFederationFallbackTelemetry)({
+        appName: options.appName,
+        classification: base.classification,
+        error: base.error ?? base.discoveryError,
+        metadata: {
+            env: options.env,
+            surfaceRef: remote,
+            ...base.discoveryError ? {
+                discoveryErrorCode: base.discoveryError.code
+            } : {},
+            ...base.resolved ? {
+                buildMarker: base.resolved.buildMarker
+            } : {}
+        },
+        phase: base.phase,
+        remote,
+        status: 'degraded'
+    });
+    try {
+        await (0, external_index_js_namespaceObject.emitModuleFederationFallbackTelemetry)({
+            appName: options.appName,
+            classification: base.classification,
+            error: base.error ?? base.discoveryError,
+            metadata: telemetry.metadata,
+            phase: base.phase,
+            remote,
+            status: 'degraded'
+        }, options.telemetry ?? {});
+    } catch  {}
+    const failure = {
+        ref,
+        env: options.env,
+        phase: base.phase,
+        classification: base.classification,
+        telemetry
+    };
+    if (base.discoveryError) failure.discoveryError = base.discoveryError;
+    if (void 0 !== base.error) failure.error = base.error;
+    if (base.resolved) failure.resolved = base.resolved;
+    const critical = (options.classification ?? 'critical') === 'critical';
+    const reason = base.discoveryError ?? (void 0 !== base.error ? base.error : (0, external_surface_resolution_types_js_namespaceObject.createDiscoveryError)('identity-mismatch', remote, `resolved record for "${remote}" is incompatible`, {
+        env: options.env
+    }));
+    let degradedValue;
+    try {
+        degradedValue = await options.degraded(failure);
+    } catch (handlerError) {
+        try {
+            await (0, external_index_js_namespaceObject.emitModuleFederationFallbackTelemetry)({
+                appName: options.appName,
+                classification: base.classification,
+                error: handlerError,
+                metadata: {
+                    ...telemetry.metadata,
+                    degradedHandlerFailed: true
+                },
+                phase: base.phase,
+                remote,
+                status: 'failed'
+            }, options.telemetry ?? {});
+        } catch  {}
+        if (critical) throw reason;
+        return;
+    }
+    if (critical) throw reason;
+    return degradedValue;
+}
+async function consumeSurface(options) {
+    let ref;
+    if ('string' == typeof options.ref) {
+        const parsed = (0, external_surface_resolution_types_js_namespaceObject.parseSurfaceRef)(options.ref);
+        if (!parsed.ok) {
+            const hashIndex = options.ref.indexOf('#');
+            const echoed = -1 === hashIndex ? {
+                unitId: options.ref,
+                surfaceId: ''
+            } : {
+                unitId: options.ref.slice(0, hashIndex),
+                surfaceId: options.ref.slice(hashIndex + 1)
+            };
+            return reportFailure(options, echoed, {
+                phase: 'discovery',
+                classification: 'remote-unavailable',
+                discoveryError: (0, external_surface_resolution_types_js_namespaceObject.createDiscoveryError)('unknown-surface', options.ref, `SurfaceRef "${options.ref}" is not a valid canonical reference (${parsed.error.code}).`, {
+                    parseError: parsed.error,
+                    env: options.env
+                })
+            });
+        }
+        ref = parsed.ref;
+    } else ref = options.ref;
+    let resolution;
+    try {
+        resolution = await options.provider.resolve(ref, options.env);
+    } catch (error) {
+        return reportFailure(options, ref, {
+            phase: 'discovery',
+            classification: (0, external_index_js_namespaceObject.classifyModuleFederationFallback)(error),
+            error
+        });
+    }
+    if (!resolution.ok) return reportFailure(options, ref, {
+        phase: 'discovery',
+        classification: classifyDiscoveryError(resolution.error.code),
+        discoveryError: resolution.error
+    });
+    const resolved = resolution.unit;
+    if ('incompatible' === resolved.compatibility.status) return reportFailure(options, ref, {
+        phase: 'discovery',
+        classification: 'contract',
+        resolved
+    });
+    try {
+        return await options.load({
+            resolved,
+            ref,
+            env: options.env
+        });
+    } catch (error) {
+        return reportFailure(options, ref, {
+            phase: 'load',
+            classification: (0, external_index_js_namespaceObject.classifyModuleFederationFallback)(error),
+            error,
+            resolved
+        });
+    }
+}
+function createSurfaceConsumer(base) {
+    return function(options) {
+        return consumeSurface({
+            ...base,
+            ...options
+        });
+    };
+}
+exports.consumeSurface = __webpack_exports__.consumeSurface;
+exports.createSurfaceConsumer = __webpack_exports__.createSurfaceConsumer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "consumeSurface",
+    "createSurfaceConsumer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-federation/distributed-ssr.js

@@ -0,0 +1,135 @@
+"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__, {
+    DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY: ()=>DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY,
+    DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY: ()=>DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY,
+    DistributedSsrBoundary: ()=>DistributedSsrBoundary,
+    createDistributedSsrComponent: ()=>createDistributedSsrComponent,
+    distributedSsrFragmentKey: ()=>distributedSsrFragmentKey,
+    useDistributedSsrFragmentProps: ()=>useDistributedSsrFragmentProps
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const runtime_namespaceObject = require("@modern-js/runtime");
+const DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY = '__modernDistributedSsrFragments';
+const DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY = '__modernDistributedSsrFragmentRequest';
+function distributedSsrFragmentKey(remote, expose) {
+    return `${remote}::${expose}`;
+}
+function getDistributedSsrFragmentContext(response) {
+    const locals = response?.locals;
+    if ('object' != typeof locals || null === locals) return;
+    const context = DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY in locals ? locals[DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY] : void 0;
+    if ('object' != typeof context || null === context) return;
+    return context;
+}
+function useDistributedSsrFragmentProps({ boundaryId, expose }) {
+    const runtimeContext = (0, runtime_namespaceObject.useRuntimeContext)();
+    const locals = runtimeContext.requestContext?.response?.locals;
+    const request = 'object' == typeof locals && null !== locals && DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY in locals ? locals[DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY] : void 0;
+    if ('object' != typeof request || null === request || !('boundaryId' in request) || request.boundaryId !== boundaryId || !('expose' in request) || request.expose !== expose) throw new Error(`Distributed SSR fragment request contract mismatch for ${boundaryId} ${expose}.`);
+    const props = 'props' in request ? request.props : void 0;
+    if ('object' != typeof props || null === props || Array.isArray(props)) throw new Error(`Distributed SSR fragment request props must be an object for ${boundaryId} ${expose}.`);
+    return props;
+}
+function isThenable(value) {
+    return void 0 !== value && 'then' in value && 'function' == typeof value.then;
+}
+function DistributedSsrBoundary({ children, expose, fallback, fragmentProps, remote }) {
+    const runtimeContext = (0, runtime_namespaceObject.useRuntimeContext)();
+    const key = distributedSsrFragmentKey(remote, expose);
+    const attributes = {
+        'data-modern-distributed-ssr-boundary': key
+    };
+    if (runtimeContext.isBrowser) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        ...attributes,
+        children: children
+    });
+    const fragmentContext = getDistributedSsrFragmentContext(runtimeContext.requestContext?.response);
+    if (void 0 === fragmentContext) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        ...attributes,
+        children: children
+    });
+    const resolverFragmentProps = void 0 === fragmentProps ? {} : Object.fromEntries(Object.entries(fragmentProps));
+    const fragmentOrPromise = fragmentContext.resolve?.(remote, expose, resolverFragmentProps) ?? fragmentContext.fragments?.[key];
+    if (isThenable(fragmentOrPromise)) throw fragmentOrPromise;
+    const fragment = fragmentOrPromise;
+    if (fragment?.status === 'ready') return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        ...attributes,
+        "data-modern-distributed-ssr-build": fragment.buildMarker,
+        "data-modern-distributed-ssr-digest": fragment.digest,
+        "data-modern-distributed-ssr-status": "ready",
+        dangerouslySetInnerHTML: {
+            __html: fragment.html
+        }
+    });
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        ...attributes,
+        "data-modern-distributed-ssr-reason": fragment?.reason ?? 'missing',
+        "data-modern-distributed-ssr-status": "degraded",
+        children: fallback
+    });
+}
+function createDistributedSsrComponent({ createComponent, expose, fallback, remote }) {
+    let RemoteComponent;
+    function DeferredRemoteComponent(props) {
+        RemoteComponent ??= createComponent();
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(RemoteComponent, {
+            ...props
+        });
+    }
+    return function(props) {
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(DistributedSsrBoundary, {
+            expose: expose,
+            fallback: fallback,
+            fragmentProps: props,
+            remote: remote,
+            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(DeferredRemoteComponent, {
+                ...props
+            })
+        });
+    };
+}
+exports.DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY = __webpack_exports__.DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY;
+exports.DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY = __webpack_exports__.DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY;
+exports.DistributedSsrBoundary = __webpack_exports__.DistributedSsrBoundary;
+exports.createDistributedSsrComponent = __webpack_exports__.createDistributedSsrComponent;
+exports.distributedSsrFragmentKey = __webpack_exports__.distributedSsrFragmentKey;
+exports.useDistributedSsrFragmentProps = __webpack_exports__.useDistributedSsrFragmentProps;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY",
+    "DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY",
+    "DistributedSsrBoundary",
+    "createDistributedSsrComponent",
+    "distributedSsrFragmentKey",
+    "useDistributedSsrFragmentProps"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,316 @@
+"use strict";
+var __webpack_modules__ = {
+    "./consume-surface" (module) {
+        module.exports = require("./consume-surface.js");
+    },
+    "./distributed-ssr" (module) {
+        module.exports = require("./distributed-ssr.js");
+    },
+    "./last-known-good" (module) {
+        module.exports = require("./last-known-good.js");
+    },
+    "./manifest-recovery-runtime-plugin" (module) {
+        module.exports = require("./manifest-recovery-runtime-plugin.js");
+    },
+    "./surface-resolution-types" (module) {
+        module.exports = require("./surface-resolution-types.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__);
+    var _consume_surface__rspack_import_0 = __webpack_require__("./consume-surface");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _consume_surface__rspack_import_0)if ([
+        "MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT",
+        "MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT",
+        "DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT",
+        "createModuleFederationFallbackTelemetry",
+        "toModuleFederationFallbackAttributes",
+        "ModuleFederationRemoteComponentContractError",
+        "emitModuleFederationFallbackTelemetry",
+        "default",
+        "DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER",
+        "classifyModuleFederationFallback",
+        "ModuleFederationRemoteLoadTimeoutError",
+        "useDistributedSsrFragmentProps",
+        "ModuleFederationRemoteLoadError",
+        "DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_consume_surface__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _distributed_ssr__rspack_import_1 = __webpack_require__("./distributed-ssr");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _distributed_ssr__rspack_import_1)if ([
+        "MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT",
+        "MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT",
+        "DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT",
+        "createModuleFederationFallbackTelemetry",
+        "toModuleFederationFallbackAttributes",
+        "ModuleFederationRemoteComponentContractError",
+        "emitModuleFederationFallbackTelemetry",
+        "default",
+        "DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER",
+        "classifyModuleFederationFallback",
+        "ModuleFederationRemoteLoadTimeoutError",
+        "useDistributedSsrFragmentProps",
+        "ModuleFederationRemoteLoadError",
+        "DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_distributed_ssr__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _last_known_good__rspack_import_2 = __webpack_require__("./last-known-good");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _last_known_good__rspack_import_2)if ([
+        "MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT",
+        "MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT",
+        "DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT",
+        "createModuleFederationFallbackTelemetry",
+        "toModuleFederationFallbackAttributes",
+        "ModuleFederationRemoteComponentContractError",
+        "emitModuleFederationFallbackTelemetry",
+        "default",
+        "DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER",
+        "classifyModuleFederationFallback",
+        "ModuleFederationRemoteLoadTimeoutError",
+        "useDistributedSsrFragmentProps",
+        "ModuleFederationRemoteLoadError",
+        "DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_last_known_good__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _manifest_recovery_runtime_plugin__rspack_import_3 = __webpack_require__("./manifest-recovery-runtime-plugin");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _manifest_recovery_runtime_plugin__rspack_import_3)if ([
+        "MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT",
+        "MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT",
+        "DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT",
+        "createModuleFederationFallbackTelemetry",
+        "toModuleFederationFallbackAttributes",
+        "ModuleFederationRemoteComponentContractError",
+        "emitModuleFederationFallbackTelemetry",
+        "default",
+        "DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER",
+        "classifyModuleFederationFallback",
+        "ModuleFederationRemoteLoadTimeoutError",
+        "useDistributedSsrFragmentProps",
+        "ModuleFederationRemoteLoadError",
+        "DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_manifest_recovery_runtime_plugin__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _surface_resolution_types__rspack_import_4 = __webpack_require__("./surface-resolution-types");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _surface_resolution_types__rspack_import_4)if ([
+        "MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT",
+        "MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT",
+        "DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT",
+        "createModuleFederationFallbackTelemetry",
+        "toModuleFederationFallbackAttributes",
+        "ModuleFederationRemoteComponentContractError",
+        "emitModuleFederationFallbackTelemetry",
+        "default",
+        "DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER",
+        "classifyModuleFederationFallback",
+        "ModuleFederationRemoteLoadTimeoutError",
+        "useDistributedSsrFragmentProps",
+        "ModuleFederationRemoteLoadError",
+        "DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_surface_resolution_types__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    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
+        };
+    }
+    __webpack_require__.d(__webpack_exports__, {
+        DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY: ()=>_distributed_ssr__rspack_import_1.DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY,
+        ModuleFederationRemoteComponentContractError: ()=>ModuleFederationRemoteComponentContractError,
+        ModuleFederationRemoteLoadError: ()=>ModuleFederationRemoteLoadError,
+        ModuleFederationRemoteLoadTimeoutError: ()=>ModuleFederationRemoteLoadTimeoutError,
+        classifyModuleFederationFallback: ()=>classifyModuleFederationFallback,
+        createModuleFederationFallbackTelemetry: ()=>createModuleFederationFallbackTelemetry,
+        emitModuleFederationFallbackTelemetry: ()=>emitModuleFederationFallbackTelemetry,
+        toModuleFederationFallbackAttributes: ()=>toModuleFederationFallbackAttributes,
+        useDistributedSsrFragmentProps: ()=>_distributed_ssr__rspack_import_1.useDistributedSsrFragmentProps
+    }, {
+        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.DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY = __webpack_exports__.DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY;
+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.emitModuleFederationFallbackTelemetry = __webpack_exports__.emitModuleFederationFallbackTelemetry;
+exports.toModuleFederationFallbackAttributes = __webpack_exports__.toModuleFederationFallbackAttributes;
+exports.useDistributedSsrFragmentProps = __webpack_exports__.useDistributedSsrFragmentProps;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER",
+    "DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT",
+    "DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY",
+    "MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT",
+    "MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT",
+    "ModuleFederationRemoteComponentContractError",
+    "ModuleFederationRemoteLoadError",
+    "ModuleFederationRemoteLoadTimeoutError",
+    "classifyModuleFederationFallback",
+    "createModuleFederationFallbackTelemetry",
+    "emitModuleFederationFallbackTelemetry",
+    "toModuleFederationFallbackAttributes",
+    "useDistributedSsrFragmentProps"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});