@bleedingdev/modern-js-runtime 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

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

@@ -1,159 +0,0 @@
-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

@@ -1,83 +0,0 @@
-import "node:module";
-import { jsx } from "react/jsx-runtime";
-import { useRuntimeContext } from "../core/context/runtime.mjs";
-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 };

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

@@ -1,116 +0,0 @@
-import "node:module";
-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-node/module-federation/last-known-good.mjs

@@ -1,114 +0,0 @@
-import "node:module";
-import { selectResolvedSurface } from "@modern-js/utils/universal";
-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-node/module-federation/manifest-recovery-runtime-plugin.mjs

@@ -1,90 +0,0 @@
-import "node:module";
-import { wait } from "@modern-js/utils/universal";
-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)=>wait(milliseconds).then(()=>void 0);
-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-node/module-federation/surface-resolution-types.mjs

@@ -1,9 +0,0 @@
-import "node:module";
-import { createDiscoveryError, formatSurfaceRef, parseSurfaceRef, validateSurfaceRef } from "@modern-js/utils/universal";
-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/router/runtime/lifecycle.mjs

@@ -1,106 +0,0 @@
-import "node:module";
-import { createRuntimeContextExtension } from "../../core/context/extensions.mjs";
-const routerRuntimeStateExtension = createRuntimeContextExtension('@modern-js/runtime:router-runtime-state');
-const routerServerSnapshotExtension = createRuntimeContextExtension('@modern-js/runtime:router-server-snapshot');
-function getRouterRuntimeState(runtimeContext) {
-    return routerRuntimeStateExtension.get(runtimeContext);
-}
-function getRouterServerSnapshot(runtimeContext) {
-    return routerServerSnapshotExtension.get(runtimeContext);
-}
-function toHydrationScripts(state) {
-    if (state.hydrationScripts?.length) return state.hydrationScripts;
-    return state.hydrationScript ? [
-        state.hydrationScript
-    ] : void 0;
-}
-function getMatchedRouteIdsFromMatches(matches) {
-    const routeIds = matches?.map((match)=>match.assetRouteId ?? match.routeId).filter((routeId)=>'string' == typeof routeId);
-    return routeIds?.length ? routeIds : void 0;
-}
-function createRouterServerSnapshot(state) {
-    const hydrationScripts = toHydrationScripts(state);
-    const matchedRouteIds = state.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
-    return {
-        ...state,
-        ...hydrationScripts?.length ? {
-            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
-            hydrationScripts
-        } : {},
-        ...matchedRouteIds ? {
-            matchedRouteIds
-        } : {}
-    };
-}
-function createRouterRuntimeState(state) {
-    const hasSnapshotState = Boolean(state.serverSnapshot) || Boolean(state.hydrationScript) || Boolean(state.hydrationScripts?.length) || Boolean(state.matchedRouteIds?.length) || Boolean(state.matches?.length);
-    const serverSnapshot = state.serverSnapshot ? createRouterServerSnapshot({
-        ...state.serverSnapshot,
-        framework: state.serverSnapshot.framework ?? state.framework,
-        basename: state.serverSnapshot.basename ?? state.basename,
-        hydrationScript: state.serverSnapshot.hydrationScript ?? state.hydrationScript,
-        hydrationScripts: state.serverSnapshot.hydrationScripts ?? state.hydrationScripts,
-        matchedRouteIds: state.serverSnapshot.matchedRouteIds ?? state.matchedRouteIds,
-        matches: state.serverSnapshot.matches ?? state.matches
-    }) : hasSnapshotState ? createRouterServerSnapshot({
-        framework: state.framework,
-        basename: state.basename,
-        hydrationScript: state.hydrationScript,
-        hydrationScripts: state.hydrationScripts,
-        matchedRouteIds: state.matchedRouteIds,
-        matches: state.matches
-    }) : void 0;
-    const hydrationScripts = toHydrationScripts({
-        hydrationScript: state.hydrationScript ?? serverSnapshot?.hydrationScript,
-        hydrationScripts: state.hydrationScripts ?? serverSnapshot?.hydrationScripts
-    });
-    const matchedRouteIds = state.matchedRouteIds ?? serverSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
-    return {
-        ...state,
-        ...hydrationScripts?.length ? {
-            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
-            hydrationScripts
-        } : {},
-        ...matchedRouteIds ? {
-            matchedRouteIds
-        } : {},
-        ...serverSnapshot ? {
-            serverSnapshot
-        } : {}
-    };
-}
-function applyRouterRuntimeState(runtimeContext, state) {
-    const normalized = createRouterRuntimeState(state);
-    routerRuntimeStateExtension.set(runtimeContext, normalized);
-    if (normalized.serverSnapshot) routerServerSnapshotExtension.set(runtimeContext, normalized.serverSnapshot);
-    return runtimeContext;
-}
-function applyRouterServerPrepareResult(runtimeContext, result) {
-    const state = createRouterRuntimeState({
-        ...result.state,
-        cleanup: result.cleanup ?? result.state.cleanup,
-        serverSnapshot: result.snapshot ?? result.state.serverSnapshot
-    });
-    applyRouterRuntimeState(runtimeContext, state);
-    return runtimeContext;
-}
-function getRouterHydrationScripts(runtimeContext) {
-    const serverSnapshot = getRouterServerSnapshot(runtimeContext);
-    const runtimeState = getRouterRuntimeState(runtimeContext);
-    return serverSnapshot?.hydrationScripts ?? toHydrationScripts({
-        hydrationScript: serverSnapshot?.hydrationScript
-    }) ?? runtimeState?.hydrationScripts ?? toHydrationScripts({
-        hydrationScript: runtimeState?.hydrationScript
-    }) ?? [];
-}
-function getRouterMatchedRouteIds(runtimeContext) {
-    const serverSnapshot = getRouterServerSnapshot(runtimeContext);
-    const runtimeState = getRouterRuntimeState(runtimeContext);
-    return serverSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(serverSnapshot?.matches) ?? runtimeState?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(runtimeState?.matches);
-}
-async function cleanupRouterRuntimeState(runtimeContext) {
-    try {
-        await getRouterRuntimeState(runtimeContext)?.cleanup?.();
-    } catch  {}
-}
-export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot };