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

package/dist/cjs/module-federation/last-known-good.js

@@ -0,0 +1,157 @@
+"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__, {
+    LAST_KNOWN_GOOD_PROVIDER_NAME: ()=>LAST_KNOWN_GOOD_PROVIDER_NAME,
+    createInMemoryLkgStorage: ()=>createInMemoryLkgStorage,
+    createLastKnownGoodProvider: ()=>createLastKnownGoodProvider
+});
+const surface_resolution_namespaceObject = require("@modern-js/surface-resolution");
+const external_surface_resolution_types_js_namespaceObject = require("./surface-resolution-types.js");
+const LAST_KNOWN_GOOD_PROVIDER_NAME = 'last-known-good';
+function createInMemoryLkgStorage() {
+    const map = new Map();
+    return {
+        read (key) {
+            return map.get(key);
+        },
+        write (key, record) {
+            map.set(key, record);
+        }
+    };
+}
+function markDegraded(resolved, reason) {
+    return {
+        ...resolved,
+        compatibility: {
+            ...resolved.compatibility,
+            status: 'degraded',
+            reason
+        }
+    };
+}
+function staleRecordResult(ref, env, ageMs, maxStaleMs) {
+    return {
+        ok: false,
+        error: (0, external_surface_resolution_types_js_namespaceObject.createDiscoveryError)('stale-record', ref, `Last-known-good record for surface is stale: age ${ageMs}ms exceeds maxStaleMs ${maxStaleMs}ms`, {
+            env,
+            ageMs,
+            maxStaleMs
+        })
+    };
+}
+function resolutionAnswersRef(resolved, ref) {
+    const selected = (0, surface_resolution_namespaceObject.selectResolvedSurface)(resolved, ref);
+    return selected.ok && selected.surface.servedMajor === ref.major;
+}
+function createLastKnownGoodProvider(options) {
+    const storage = options.storage ?? createInMemoryLkgStorage();
+    const now = options.now ?? (()=>Math.floor(performance.timeOrigin + performance.now()));
+    const maxStaleMs = options.freshness?.maxStaleMs;
+    let nextResolutionGeneration = 0;
+    const latestCacheableGenerationByKey = new Map();
+    const writeTailByKey = new Map();
+    async function cacheCompatibleResolution(key, generation, record) {
+        latestCacheableGenerationByKey.set(key, Math.max(latestCacheableGenerationByKey.get(key) ?? 0, generation));
+        const previous = writeTailByKey.get(key) ?? Promise.resolve();
+        const write = previous.catch(()=>void 0).then(async ()=>{
+            if (latestCacheableGenerationByKey.get(key) !== generation) return;
+            await storage.write(key, record);
+        });
+        writeTailByKey.set(key, write);
+        try {
+            await write;
+        } finally{
+            if (writeTailByKey.get(key) === write) writeTailByKey.delete(key);
+        }
+    }
+    async function serveFromCache(ref, env, fallback) {
+        const key = (0, external_surface_resolution_types_js_namespaceObject.deliveryUnitResolutionKey)(ref.unitId, env);
+        const cached = await storage.read(key);
+        if (!cached) return fallback();
+        if (cached.major !== ref.major) return fallback();
+        if (!resolutionAnswersRef(cached.resolved, ref)) return fallback();
+        if ('compatible' !== cached.resolved.compatibility.status) return fallback();
+        const ageMs = now() - cached.storedAt;
+        if (void 0 !== maxStaleMs && ageMs > maxStaleMs) return staleRecordResult(ref, env, ageMs, maxStaleMs);
+        return {
+            ok: true,
+            unit: markDegraded(cached.resolved, `served last-known-good record (age ${ageMs}ms) after provider failure`)
+        };
+    }
+    return {
+        name: LAST_KNOWN_GOOD_PROVIDER_NAME,
+        async resolve (ref, env) {
+            const key = (0, external_surface_resolution_types_js_namespaceObject.deliveryUnitResolutionKey)(ref.unitId, env);
+            const generation = ++nextResolutionGeneration;
+            let resolution;
+            try {
+                resolution = await options.provider.resolve(ref, env);
+            } catch (error) {
+                return serveFromCache(ref, env, ()=>({
+                        ok: false,
+                        error: (0, external_surface_resolution_types_js_namespaceObject.createDiscoveryError)('provider-unavailable', ref, error instanceof Error ? error.message : 'provider threw a non-error value', {
+                            env,
+                            provider: options.provider.name
+                        })
+                    }));
+            }
+            if (!resolution.ok) {
+                const failure = resolution;
+                return serveFromCache(ref, env, ()=>failure);
+            }
+            if (!resolutionAnswersRef(resolution.unit, ref)) return serveFromCache(ref, env, ()=>({
+                    ok: false,
+                    error: (0, external_surface_resolution_types_js_namespaceObject.createDiscoveryError)('identity-mismatch', ref, `Provider ${options.provider.name} returned a delivery unit that does not answer the requested surface.`, {
+                        env,
+                        provider: options.provider.name,
+                        recordUnitId: resolution.unit.unitId,
+                        availableSurfaces: resolution.unit.surfaces.map((surface)=>surface.surfaceId)
+                    })
+                }));
+            if ('compatible' === resolution.unit.compatibility.status) await cacheCompatibleResolution(key, generation, {
+                resolved: resolution.unit,
+                storedAt: now(),
+                major: ref.major
+            });
+            return resolution;
+        }
+    };
+}
+exports.LAST_KNOWN_GOOD_PROVIDER_NAME = __webpack_exports__.LAST_KNOWN_GOOD_PROVIDER_NAME;
+exports.createInMemoryLkgStorage = __webpack_exports__.createInMemoryLkgStorage;
+exports.createLastKnownGoodProvider = __webpack_exports__.createLastKnownGoodProvider;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "LAST_KNOWN_GOOD_PROVIDER_NAME",
+    "createInMemoryLkgStorage",
+    "createLastKnownGoodProvider"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-federation/manifest-recovery-runtime-plugin.js

@@ -0,0 +1,130 @@
+"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 DEFAULT_ATTEMPTS = 3;
+const DEFAULT_RETRY_DELAY_MS = 100;
+const DEFAULT_TIMEOUT_MS = 1000;
+const MAX_ATTEMPTS = 5;
+const MAX_RETRY_DELAY_MS = 1000;
+const MAX_TIMEOUT_MS = 5000;
+const RETRYABLE_HTTP_STATUSES = new Set([
+    408,
+    425,
+    429,
+    500,
+    502,
+    503,
+    504
+]);
+const NON_RETRYABLE_ERROR_PATTERNS = [
+    /RUNTIME-013/i,
+    /invalid manifest/i,
+    /manifest (?:schema|contract|version|identity)/i,
+    /(?:incompatible|mismatch).*(?:manifest|remote)/i
+];
+const clampInteger = (value, fallback, minimum, maximum)=>{
+    if (void 0 === value || !Number.isFinite(value)) return fallback;
+    return Math.min(maximum, Math.max(minimum, Math.floor(value)));
+};
+const getErrorMessage = (error)=>{
+    if (error instanceof Error) return error.message;
+    return 'string' == typeof error ? error : '';
+};
+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;
+    const message = getErrorMessage(error);
+    if (NON_RETRYABLE_ERROR_PATTERNS.some((pattern)=>pattern.test(message))) return false;
+    const status = getErrorStatus(error);
+    if (void 0 !== status) return RETRYABLE_HTTP_STATUSES.has(status);
+    if (error instanceof Error && [
+        'AbortError',
+        'TimeoutError'
+    ].includes(error.name)) return true;
+    return error instanceof TypeError || /(?:fetch failed|network|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN)/i.test(message);
+};
+const isHttpManifestUrl = (id)=>{
+    if (void 0 === id || 0 === id.length) return false;
+    try {
+        const url = new URL(id);
+        return ('http:' === url.protocol || 'https:' === url.protocol) && url.pathname.endsWith('.json');
+    } catch  {
+        return false;
+    }
+};
+const defaultWait = (milliseconds)=>new Promise((resolve)=>{
+        setTimeout(resolve, milliseconds);
+    });
+const fetchWithTimeout = (fetchImpl, url, timeoutMs)=>fetchImpl(url, {
+        signal: AbortSignal.timeout(timeoutMs)
+    });
+const createModuleFederationManifestRecoveryPlugin = (options = {})=>{
+    const attempts = clampInteger(options.attempts, DEFAULT_ATTEMPTS, 1, MAX_ATTEMPTS);
+    const retryDelayMs = clampInteger(options.retryDelayMs, DEFAULT_RETRY_DELAY_MS, 0, MAX_RETRY_DELAY_MS);
+    const timeoutMs = clampInteger(options.timeoutMs, DEFAULT_TIMEOUT_MS, 1, MAX_TIMEOUT_MS);
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    const waitImpl = options.waitImpl ?? defaultWait;
+    const recoverManifest = (url, attempt)=>{
+        const fetchManifest = ()=>Promise.resolve().then(()=>fetchWithTimeout(fetchImpl, url, timeoutMs)).then((response)=>{
+                if (!response.ok) {
+                    if (!RETRYABLE_HTTP_STATUSES.has(response.status) || attempt === attempts - 1) return;
+                    return recoverManifest(url, attempt + 1);
+                }
+                return Promise.resolve().then(()=>response.json()).then((manifest)=>manifest, ()=>void 0);
+            }, (error)=>{
+                if (!isRetryableError(error) || attempt === attempts - 1) return;
+                return recoverManifest(url, attempt + 1);
+            });
+        if (attempt > 0 && retryDelayMs > 0) return waitImpl(retryDelayMs).then(fetchManifest);
+        return fetchManifest();
+    };
+    return {
+        name: 'modern-js-manifest-recovery-plugin',
+        errorLoadRemote (args) {
+            if ('afterResolve' !== args.lifecycle || !isHttpManifestUrl(args.id) || !isRetryableError(args.error) || 'function' != typeof fetchImpl) return Promise.resolve(void 0);
+            return recoverManifest(args.id, 0);
+        }
+    };
+};
+const __rspack_default_export = createModuleFederationManifestRecoveryPlugin;
+__webpack_require__.d(__webpack_exports__, {}, {
+    createModuleFederationManifestRecoveryPlugin: createModuleFederationManifestRecoveryPlugin,
+    default: __rspack_default_export
+});
+exports.createModuleFederationManifestRecoveryPlugin = __webpack_exports__.createModuleFederationManifestRecoveryPlugin;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createModuleFederationManifestRecoveryPlugin",
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-federation/surface-resolution-types.js

@@ -0,0 +1,61 @@
+"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__, {
+    createDiscoveryError: ()=>surface_resolution_namespaceObject.createDiscoveryError,
+    deliveryUnitResolutionKey: ()=>deliveryUnitResolutionKey,
+    formatSurfaceRef: ()=>surface_resolution_namespaceObject.formatSurfaceRef,
+    parseSurfaceRef: ()=>surface_resolution_namespaceObject.parseSurfaceRef,
+    surfaceResolutionKey: ()=>surfaceResolutionKey,
+    validateSurfaceRef: ()=>surface_resolution_namespaceObject.validateSurfaceRef
+});
+const surface_resolution_namespaceObject = require("@modern-js/surface-resolution");
+function surfaceResolutionKey(ref, env) {
+    return `${env}::${(0, surface_resolution_namespaceObject.formatSurfaceRef)(ref)}`;
+}
+function deliveryUnitResolutionKey(unitId, env) {
+    return `${env}::${unitId}`;
+}
+exports.createDiscoveryError = __webpack_exports__.createDiscoveryError;
+exports.deliveryUnitResolutionKey = __webpack_exports__.deliveryUnitResolutionKey;
+exports.formatSurfaceRef = __webpack_exports__.formatSurfaceRef;
+exports.parseSurfaceRef = __webpack_exports__.parseSurfaceRef;
+exports.surfaceResolutionKey = __webpack_exports__.surfaceResolutionKey;
+exports.validateSurfaceRef = __webpack_exports__.validateSurfaceRef;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDiscoveryError",
+    "deliveryUnitResolutionKey",
+    "formatSurfaceRef",
+    "parseSurfaceRef",
+    "surfaceResolutionKey",
+    "validateSurfaceRef"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,158 @@
+import { classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackTelemetry } from "./index.mjs";
+import { createDiscoveryError, formatSurfaceRef, parseSurfaceRef, validateSurfaceRef } from "./surface-resolution-types.mjs";
+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 === validateSurfaceRef(ref) ? formatSurfaceRef(ref) : `${ref.unitId}#${ref.surfaceId}`;
+}
+async function reportFailure(options, ref, base) {
+    const remote = toRemoteString(ref);
+    const telemetry = 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 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 : 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 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 = 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: 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: 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: classifyModuleFederationFallback(error),
+            error,
+            resolved
+        });
+    }
+}
+function createSurfaceConsumer(base) {
+    return function(options) {
+        return consumeSurface({
+            ...base,
+            ...options
+        });
+    };
+}
+export { consumeSurface, createSurfaceConsumer };

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

@@ -0,0 +1,82 @@
+import { jsx } from "react/jsx-runtime";
+import { useRuntimeContext } from "@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 = 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 = useRuntimeContext();
+    const key = distributedSsrFragmentKey(remote, expose);
+    const attributes = {
+        'data-modern-distributed-ssr-boundary': key
+    };
+    if (runtimeContext.isBrowser) return /*#__PURE__*/ jsx("div", {
+        ...attributes,
+        children: children
+    });
+    const fragmentContext = getDistributedSsrFragmentContext(runtimeContext.requestContext?.response);
+    if (void 0 === fragmentContext) return /*#__PURE__*/ 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__*/ 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__*/ 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__*/ jsx(RemoteComponent, {
+            ...props
+        });
+    }
+    return function(props) {
+        return /*#__PURE__*/ jsx(DistributedSsrBoundary, {
+            expose: expose,
+            fallback: fallback,
+            fragmentProps: props,
+            remote: remote,
+            children: /*#__PURE__*/ jsx(DeferredRemoteComponent, {
+                ...props
+            })
+        });
+    };
+}
+export { DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY, DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY, DistributedSsrBoundary, createDistributedSsrComponent, distributedSsrFragmentKey, useDistributedSsrFragmentProps };