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

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

@@ -0,0 +1,115 @@
+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 };

package/dist/esm/module-federation/last-known-good.mjs

@@ -0,0 +1,113 @@
+import { selectResolvedSurface } from "@modern-js/surface-resolution";
+import { createDiscoveryError, deliveryUnitResolutionKey } from "./surface-resolution-types.mjs";
+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: 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 = 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 = 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 = 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: 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: 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;
+        }
+    };
+}
+export { LAST_KNOWN_GOOD_PROVIDER_NAME, createInMemoryLkgStorage, createLastKnownGoodProvider };

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

@@ -0,0 +1,90 @@
+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 manifest_recovery_runtime_plugin = createModuleFederationManifestRecoveryPlugin;
+export default manifest_recovery_runtime_plugin;
+export { createModuleFederationManifestRecoveryPlugin };

package/dist/esm/module-federation/surface-resolution-types.mjs

@@ -0,0 +1,8 @@
+import { createDiscoveryError, formatSurfaceRef, parseSurfaceRef, validateSurfaceRef } from "@modern-js/surface-resolution";
+function surfaceResolutionKey(ref, env) {
+    return `${env}::${formatSurfaceRef(ref)}`;
+}
+function deliveryUnitResolutionKey(unitId, env) {
+    return `${env}::${unitId}`;
+}
+export { createDiscoveryError, deliveryUnitResolutionKey, formatSurfaceRef, parseSurfaceRef, surfaceResolutionKey, validateSurfaceRef };

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

@@ -0,0 +1,159 @@
+import "node:module";
+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-node/module-federation/distributed-ssr.mjs

@@ -0,0 +1,83 @@
+import "node:module";
+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 };