@bleedingdev/modern-js-server-runtime-extensions 0.0.0-trusted-publisher-bootstrap

package/dist/esm/contractGateAutopilot.mjs

@@ -0,0 +1,124 @@
+import { createFileContractGateSnapshotStore } from "./contractGateSnapshotStore.mjs";
+const DEFAULT_POLL_INTERVAL_MS = 15000;
+const DEFAULT_GATE_STALE_AFTER_MS = 600000;
+class ContractGateAutopilot {
+    async start() {
+        await this.syncOnce();
+        if (this.poller) return;
+        this.poller = setInterval(()=>{
+            this.syncOnce();
+        }, this.pollIntervalMs);
+        if ('function' == typeof this.poller.unref) this.poller.unref();
+    }
+    stop() {
+        if (this.poller) {
+            clearInterval(this.poller);
+            this.poller = void 0;
+        }
+    }
+    async syncOnce() {
+        const snapshot = await this.loadSnapshot();
+        if (!snapshot) return 0;
+        const gates = this.normalizeSnapshot(snapshot);
+        let updatedCount = 0;
+        for (const gate of gates){
+            this.orchestrator.addRequiredContractGate(gate.name);
+            const fingerprint = `${gate.passed ? '1' : '0'}:${gate.reason || ''}`;
+            if (this.appliedGateFingerprints.get(gate.name) !== fingerprint) {
+                this.orchestrator.setContractGate(gate.name, gate.passed, gate.reason);
+                this.appliedGateFingerprints.set(gate.name, fingerprint);
+                updatedCount += 1;
+                this.logger?.info?.(`[telemetry.canary.autopilot] gate=${gate.name} passed=${String(gate.passed)} reason=${gate.reason || 'none'}`);
+            }
+        }
+        return updatedCount;
+    }
+    async loadSnapshot() {
+        try {
+            const snapshot = await this.gateSnapshotStore.readSnapshot();
+            if (!snapshot) return;
+            const fingerprint = JSON.stringify(snapshot);
+            if (fingerprint === this.lastSnapshotFingerprint) return;
+            this.lastSnapshotFingerprint = fingerprint;
+            return snapshot;
+        } catch (error) {
+            const source = this.gateSnapshotPath || this.gateSnapshotStore.name || 'stateStore';
+            this.logger?.warn?.(`[telemetry.canary.autopilot] failed to load gate snapshot ${source}: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+    }
+    normalizeSnapshot(snapshot) {
+        const now = Date.now();
+        const output = [];
+        const gates = snapshot.gates;
+        if (!gates || 'object' != typeof gates) return output;
+        for (const [name, value] of Object.entries(gates)){
+            const normalizedName = name.trim();
+            if (!normalizedName) continue;
+            const gate = this.normalizeGateValue(value, snapshot.updatedAt, now);
+            if (!gate) continue;
+            if ('number' == typeof gate.expiresAt && Number.isFinite(gate.expiresAt) && gate.expiresAt > 0 && now >= gate.expiresAt) {
+                output.push({
+                    name: normalizedName,
+                    passed: true,
+                    reason: void 0,
+                    updatedAt: gate.updatedAt,
+                    expiresAt: gate.expiresAt
+                });
+                continue;
+            }
+            const isStale = this.gateStaleAfterMs > 0 && now - gate.updatedAt > this.gateStaleAfterMs;
+            if (isStale) {
+                output.push({
+                    name: normalizedName,
+                    passed: false,
+                    reason: gate.reason || 'Gate snapshot is stale',
+                    updatedAt: gate.updatedAt
+                });
+                continue;
+            }
+            output.push({
+                name: normalizedName,
+                passed: gate.passed,
+                reason: gate.reason,
+                updatedAt: gate.updatedAt
+            });
+        }
+        return output;
+    }
+    normalizeGateValue(value, snapshotUpdatedAt, now) {
+        if ('boolean' == typeof value) return {
+            passed: value,
+            updatedAt: this.normalizeUpdatedAt(snapshotUpdatedAt, now)
+        };
+        if (!value || 'object' != typeof value) return;
+        const hasPassed = 'boolean' == typeof value.passed;
+        const passed = true === value.passed;
+        let reason = 'string' == typeof value.reason && value.reason.trim().length > 0 ? value.reason : void 0;
+        if (!hasPassed) reason = reason || 'Gate snapshot record is missing "passed" boolean';
+        return {
+            passed,
+            reason,
+            updatedAt: this.normalizeUpdatedAt(value.updatedAt ?? snapshotUpdatedAt, now),
+            expiresAt: this.normalizeExpiresAt(value.expiresAt)
+        };
+    }
+    normalizeUpdatedAt(value, fallback) {
+        if ('number' == typeof value && Number.isFinite(value) && value > 0) return value;
+        return fallback;
+    }
+    normalizeExpiresAt(value) {
+        if ('number' == typeof value && Number.isFinite(value) && value > 0) return value;
+    }
+    constructor(options){
+        this.appliedGateFingerprints = new Map();
+        this.orchestrator = options.orchestrator;
+        if (!options.gateSnapshotStore && !options.gateSnapshotPath) throw new Error('ContractGateAutopilot requires gateSnapshotPath or gateSnapshotStore');
+        this.gateSnapshotPath = options.gateSnapshotPath;
+        this.gateSnapshotStore = options.gateSnapshotStore || createFileContractGateSnapshotStore(options.gateSnapshotPath);
+        this.pollIntervalMs = Math.max(250, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+        this.gateStaleAfterMs = Math.max(0, options.gateStaleAfterMs ?? DEFAULT_GATE_STALE_AFTER_MS);
+        this.logger = options.logger;
+    }
+}
+export { ContractGateAutopilot };

package/dist/esm/contractGateSnapshotStore.mjs

@@ -0,0 +1,190 @@
+import { createRequire } from "node:module";
+import { fs } from "@modern-js/utils";
+import { promises } from "fs";
+import path from "path";
+import { parseServerRuntimeExtensionsEnv } from "./env.mjs";
+const CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION = 1;
+const DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH = '.modern/contract-gates.json';
+const DEFAULT_HTTP_STORE_TIMEOUT_MS = 5000;
+const BUILTIN_HTTP_STATE_STORE_MODULES = new Set([
+    'http',
+    '@modern-js/server-core/http',
+    '@modern-js/server-core/contract-gate-http-store',
+    '@modern-js/server-runtime-extensions/http',
+    '@modern-js/server-runtime-extensions/contract-gate-http-store'
+]);
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const normalizeSnapshot = (snapshot)=>{
+    if (!isRecord(snapshot)) return;
+    const schemaVersion = 'number' == typeof snapshot.schemaVersion ? snapshot.schemaVersion : CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION;
+    const updatedAt = 'number' == typeof snapshot.updatedAt ? snapshot.updatedAt : Date.now();
+    const gates = isRecord(snapshot.gates) ? snapshot.gates : {};
+    return {
+        schemaVersion,
+        updatedAt,
+        gates
+    };
+};
+const normalizeHttpStoreOptions = (options)=>{
+    const endpoint = 'string' == typeof options?.endpoint ? options.endpoint.trim() : '';
+    if (!endpoint) throw new Error('[telemetry.canary.autopilot] HTTP stateStore requires options.endpoint');
+    const readMethod = 'string' == typeof options?.readMethod && options.readMethod.trim() ? options.readMethod.trim().toUpperCase() : 'GET';
+    const writeMethod = 'string' == typeof options?.writeMethod && options.writeMethod.trim() ? options.writeMethod.trim().toUpperCase() : 'PUT';
+    const timeoutMsRaw = Number(options?.timeoutMs);
+    const timeoutMs = Number.isFinite(timeoutMsRaw) && timeoutMsRaw > 0 ? Math.floor(timeoutMsRaw) : DEFAULT_HTTP_STORE_TIMEOUT_MS;
+    const headersRaw = options?.headers;
+    const headers = {};
+    if (headersRaw && 'object' == typeof headersRaw && !Array.isArray(headersRaw)) Object.entries(headersRaw).forEach(([key, value])=>{
+        if ('string' == typeof key && key.trim().length > 0 && null != value) headers[key] = String(value);
+    });
+    return {
+        endpoint,
+        readMethod,
+        writeMethod,
+        headers,
+        timeoutMs
+    };
+};
+const withTimeoutAbort = (timeoutMs)=>{
+    const controller = new AbortController();
+    const timer = setTimeout(()=>controller.abort(), timeoutMs);
+    return {
+        signal: controller.signal,
+        clear: ()=>clearTimeout(timer)
+    };
+};
+const createHttpContractGateSnapshotStore = (options)=>{
+    const normalized = normalizeHttpStoreOptions(options);
+    const endpoint = normalized.endpoint;
+    return {
+        name: `http:${endpoint}`,
+        async readSnapshot () {
+            const { signal, clear } = withTimeoutAbort(normalized.timeoutMs || 5000);
+            try {
+                const response = await fetch(endpoint, {
+                    method: normalized.readMethod || 'GET',
+                    headers: {
+                        accept: 'application/json',
+                        ...normalized.headers || {}
+                    },
+                    signal
+                });
+                if (404 === response.status) return;
+                if (!response.ok) throw new Error(`HTTP stateStore read failed with status ${String(response.status)}`);
+                const payload = await response.json();
+                return normalizeSnapshot(payload);
+            } finally{
+                clear();
+            }
+        },
+        async writeSnapshot (snapshot) {
+            const body = JSON.stringify(normalizeSnapshot(snapshot) || {
+                schemaVersion: CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION,
+                updatedAt: Date.now(),
+                gates: {}
+            });
+            const { signal, clear } = withTimeoutAbort(normalized.timeoutMs || 5000);
+            try {
+                const response = await fetch(endpoint, {
+                    method: normalized.writeMethod || 'PUT',
+                    headers: {
+                        'content-type': 'application/json',
+                        ...normalized.headers || {}
+                    },
+                    body,
+                    signal
+                });
+                if (!response.ok) throw new Error(`HTTP stateStore write failed with status ${String(response.status)}`);
+            } finally{
+                clear();
+            }
+        }
+    };
+};
+const tryResolveBuiltinSnapshotStore = (input)=>{
+    const moduleName = input.stateStore.module.trim();
+    if (!BUILTIN_HTTP_STATE_STORE_MODULES.has(moduleName)) return;
+    return createHttpContractGateSnapshotStore(input.stateStore.options || {});
+};
+const pickStoreFactory = (mod)=>{
+    if ('function' == typeof mod) return mod;
+    if ('function' == typeof mod.createContractGateSnapshotStore) return mod.createContractGateSnapshotStore;
+    if ('function' == typeof mod.default) return mod.default;
+    if (mod.default && 'object' == typeof mod.default && 'function' == typeof mod.default.createContractGateSnapshotStore) return mod.default.createContractGateSnapshotStore;
+};
+const ensureStoreShape = (store, modulePath)=>{
+    if (!store || 'object' != typeof store || 'function' != typeof store.readSnapshot || 'function' != typeof store.writeSnapshot) throw new Error(`Invalid contract gate snapshot store from "${modulePath}". Expected { readSnapshot(), writeSnapshot() }.`);
+};
+const resolveStoreModulePath = (appDirectory, modulePath)=>{
+    const normalized = modulePath.trim();
+    if (!normalized) throw new Error('Contract gate snapshot stateStore.module must be non-empty');
+    if (path.isAbsolute(normalized)) return normalized;
+    if (normalized.startsWith('.')) return path.resolve(appDirectory, normalized);
+    const appRequire = createRequire(path.join(appDirectory, 'package.json'));
+    try {
+        return appRequire.resolve(normalized);
+    } catch (_error) {
+        return normalized;
+    }
+};
+const resolveContractGateSnapshotPath = (appDirectory, configuredPath)=>{
+    const rawPath = configuredPath || parseServerRuntimeExtensionsEnv().contractGatesFile || DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH;
+    if (path.isAbsolute(rawPath)) return rawPath;
+    return path.resolve(appDirectory, rawPath);
+};
+const createFileContractGateSnapshotStore = (gateSnapshotPath)=>{
+    const resolvedPath = path.resolve(gateSnapshotPath);
+    return {
+        name: `file:${resolvedPath}`,
+        async readSnapshot () {
+            if (!await fs.pathExists(resolvedPath)) return;
+            try {
+                const raw = await promises.readFile(resolvedPath, 'utf8');
+                return normalizeSnapshot(JSON.parse(raw));
+            } catch (_error) {
+                return;
+            }
+        },
+        async writeSnapshot (snapshot) {
+            const normalized = normalizeSnapshot(snapshot) || {
+                schemaVersion: CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION,
+                updatedAt: Date.now(),
+                gates: {}
+            };
+            await promises.mkdir(path.dirname(resolvedPath), {
+                recursive: true
+            });
+            await promises.writeFile(resolvedPath, `${JSON.stringify(normalized, null, 2)}\n`);
+        }
+    };
+};
+const resolveContractGateSnapshotStore = async (input)=>{
+    const { appDirectory, gateSnapshotPath, stateStore, logger } = input;
+    if (!stateStore?.module) return createFileContractGateSnapshotStore(gateSnapshotPath);
+    const builtinStore = tryResolveBuiltinSnapshotStore({
+        stateStore
+    });
+    if (builtinStore) {
+        logger?.info?.(`[telemetry.canary.autopilot] using built-in contract gate snapshot store "${builtinStore.name}"`);
+        return builtinStore;
+    }
+    const modulePath = resolveStoreModulePath(appDirectory, stateStore.module);
+    let mod;
+    try {
+        mod = require(modulePath);
+    } catch (error) {
+        throw new Error(`[telemetry.canary.autopilot] Failed to load stateStore.module "${stateStore.module}" (${modulePath}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const factory = pickStoreFactory(mod);
+    if (!factory) throw new Error(`[telemetry.canary.autopilot] stateStore.module "${stateStore.module}" does not export createContractGateSnapshotStore()`);
+    const store = await factory({
+        appDirectory,
+        gateSnapshotPath,
+        options: stateStore.options,
+        logger
+    });
+    ensureStoreShape(store, modulePath);
+    logger?.info?.(`[telemetry.canary.autopilot] using contract gate snapshot store "${store.name || modulePath}"`);
+    return store;
+};
+export { CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION, DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH, createFileContractGateSnapshotStore, createHttpContractGateSnapshotStore, resolveContractGateSnapshotPath, resolveContractGateSnapshotStore };

package/dist/esm/env.mjs

@@ -0,0 +1,17 @@
+const DEFAULT_ENVIRONMENT_NAME = 'development';
+const readString = (value)=>{
+    if ('string' != typeof value) return;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+};
+const parseServerRuntimeExtensionsEnv = (env = process.env)=>{
+    const modernEnv = readString(env.MODERN_ENV);
+    const nodeEnv = readString(env.NODE_ENV);
+    return {
+        modernEnv,
+        nodeEnv,
+        environmentName: modernEnv || nodeEnv || DEFAULT_ENVIRONMENT_NAME,
+        contractGatesFile: readString(env.MODERN_CONTRACT_GATES_FILE)
+    };
+};
+export { DEFAULT_ENVIRONMENT_NAME, parseServerRuntimeExtensionsEnv };

package/dist/esm/index.mjs

@@ -0,0 +1,6 @@
+export { ContractGateAutopilot } from "./contractGateAutopilot.mjs";
+export { CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION, DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH, createFileContractGateSnapshotStore, createHttpContractGateSnapshotStore, resolveContractGateSnapshotPath, resolveContractGateSnapshotStore } from "./contractGateSnapshotStore.mjs";
+export { DEFAULT_ENVIRONMENT_NAME, parseServerRuntimeExtensionsEnv } from "./env.mjs";
+export { getRequestPathname, injectMfAssetCacheHeadersPlugin, isMfManifestAsset, isMfRemoteEntryAsset, resolveMfAssetCacheHeaders } from "./mfCache.mjs";
+export { collectDirectRemoteModuleFederationCss, collectDirectRemoteModuleFederationCssWithMeta, collectModuleFederationManifestCss, createModuleFederationCssCollector, injectModuleFederationCssPlugin } from "./moduleFederationCss.mjs";
+export { DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, DEFAULT_RUNTIME_STATUS_ENDPOINT, TelemetryCanaryOrchestrator, TelemetryRegistry, TelemetryStartupHealthError, createOtlpTelemetryExporter, createRuntimeFallbackSignalRuntimeState, createRuntimeSignalError, createTelemetryAwareMetrics, createVictoriaMetricsTelemetryExporter, enforceRuntimeFallbackSignalAuthToken, enforceRuntimeFallbackSignalTrustPolicy, getRuntimeSignalErrorStatusCode, hasEnabledTelemetryExporters, injectTelemetryPlugin, normalizeRequiredRuntimeFallbackSignalAuthConfig, normalizeRuntimeFallbackSignalAuthConfig, normalizeRuntimeFallbackTrustPolicy, parseRuntimeFallbackSignalPayloadFromRawBody, resolveRuntimeFallbackSignalEndpoint, resolveTelemetrySloOptions } from "./telemetry.mjs";

package/dist/esm/mfCache.mjs

@@ -0,0 +1,55 @@
+const REMOTE_ENTRY_REGEXP = /(^|\/)remoteEntry(?:\.[a-zA-Z0-9_-]+)?\.js$/;
+function firstQueryValue(value) {
+    if (Array.isArray(value)) return value.find((item)=>'string' == typeof item && item.length > 0);
+    if ('string' == typeof value && value.length > 0) return value;
+}
+function getRequestPathname(url) {
+    try {
+        return new URL(url, 'http://modernjs.local').pathname;
+    } catch (_error) {
+        return url.split('?')[0] || '/';
+    }
+}
+function isMfManifestAsset(pathname) {
+    return pathname.endsWith('/mf-manifest.json') || pathname.endsWith('/mf-stats.json');
+}
+function isMfRemoteEntryAsset(pathname) {
+    return REMOTE_ENTRY_REGEXP.test(pathname);
+}
+function hasRemoteVersionPin(query = {}) {
+    return Boolean(firstQueryValue(query.mfv) || firstQueryValue(query.v) || firstQueryValue(query.version));
+}
+function resolveMfAssetCacheHeaders(url, query = {}) {
+    const pathname = getRequestPathname(url);
+    if (isMfManifestAsset(pathname)) return {
+        'cache-control': 'no-cache, no-store, must-revalidate',
+        pragma: 'no-cache',
+        expires: '0'
+    };
+    if (isMfRemoteEntryAsset(pathname)) return hasRemoteVersionPin(query) ? {
+        'cache-control': 'public, max-age=31536000, immutable'
+    } : {
+        'cache-control': 'public, max-age=0, must-revalidate'
+    };
+}
+const injectMfAssetCacheHeadersPlugin = ()=>({
+        name: '@modern-js/inject-mf-asset-cache-headers',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                const handler = async (c, next)=>{
+                    await next();
+                    if (!c.res || c.res.status >= 400) return;
+                    const headers = resolveMfAssetCacheHeaders(c.req.path, c.req.query());
+                    if (!headers) return;
+                    for (const [name, value] of Object.entries(headers))c.res.headers.set(name, value);
+                };
+                middlewares.push({
+                    name: 'mf-asset-cache-headers',
+                    handler,
+                    order: 'pre'
+                });
+            });
+        }
+    });
+export { getRequestPathname, injectMfAssetCacheHeadersPlugin, isMfManifestAsset, isMfRemoteEntryAsset, resolveMfAssetCacheHeaders };

package/dist/esm/moduleFederationCss.mjs

@@ -0,0 +1,225 @@
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+import { fs, isProd } from "@modern-js/utils";
+import path from "path";
+const MODULE_FEDERATION_MANIFEST_FILE = 'mf-manifest.json';
+const DEFAULT_REMOTE_MANIFEST_TIMEOUT = 1500;
+const warn = (monitors, message, ...args)=>{
+    if (monitors) return void monitors.warn(message, ...args);
+    console.warn(message, ...args);
+};
+const ensureTrailingSlash = (value)=>value.endsWith('/') ? value : `${value}/`;
+const tryResolveUrl = (value, base)=>{
+    try {
+        return new URL(value, base).toString();
+    } catch  {
+        return;
+    }
+};
+const normalizeRemoteEntry = (entry)=>{
+    const value = entry.trim();
+    if (!value) return;
+    const atIndex = value.lastIndexOf('@');
+    return atIndex >= 0 ? value.slice(atIndex + 1) : value;
+};
+const getCssAssets = (assets)=>[
+        ...assets?.css?.sync || [],
+        ...assets?.css?.async || []
+    ];
+const getManifestFallbackBase = (manifestUrl)=>{
+    try {
+        return new URL('.', manifestUrl).toString();
+    } catch  {
+        return ensureTrailingSlash(manifestUrl);
+    }
+};
+const getManifestPublicPathBase = (publicPath, manifestUrl)=>{
+    if (!publicPath || 'auto' === publicPath) return getManifestFallbackBase(manifestUrl);
+    const base = tryResolveUrl(ensureTrailingSlash(publicPath), manifestUrl);
+    return base || getManifestFallbackBase(manifestUrl);
+};
+const appendResolvedCssAssets = (result, seen, assets, base)=>{
+    for (const asset of assets){
+        if (!asset) continue;
+        const resolved = tryResolveUrl(asset, base);
+        if (resolved && !seen.has(resolved)) {
+            seen.add(resolved);
+            result.push(resolved);
+        }
+    }
+};
+const collectModuleFederationManifestCss = (manifest, manifestUrl)=>{
+    const base = getManifestPublicPathBase(manifest.metaData?.publicPath, manifestUrl);
+    const result = [];
+    const seen = new Set();
+    for (const item of manifest.shared || [])appendResolvedCssAssets(result, seen, getCssAssets(item.assets), base);
+    for (const item of manifest.exposes || [])appendResolvedCssAssets(result, seen, getCssAssets(item.assets), base);
+    return result;
+};
+const fetchJsonWithTimeout = async (url, fetcher, timeout)=>{
+    const controller = new AbortController();
+    let timeoutId;
+    try {
+        const response = await Promise.race([
+            fetcher(url, {
+                signal: controller.signal
+            }),
+            new Promise((_, reject)=>{
+                timeoutId = setTimeout(()=>{
+                    controller.abort();
+                    reject(new Error(`Request timed out after ${timeout}ms`));
+                }, timeout);
+            })
+        ]);
+        if (!response.ok) throw new Error(`Unexpected status ${response.status}`);
+        return await response.json();
+    } finally{
+        if (timeoutId) clearTimeout(timeoutId);
+    }
+};
+const getHostManifest = async (pwd, monitors)=>{
+    const manifestPath = path.join(pwd, MODULE_FEDERATION_MANIFEST_FILE);
+    if (!await fs.pathExists(manifestPath)) return;
+    const manifestBuffer = await fileReader.readFileFromSystem(manifestPath, 'buffer');
+    if (null === manifestBuffer) return;
+    try {
+        return JSON.parse(manifestBuffer.toString('utf-8'));
+    } catch (error) {
+        warn(monitors, 'Parse module federation manifest failed, error = %s', error instanceof Error ? error.message : error);
+        return;
+    }
+};
+const collectDirectRemoteModuleFederationCssWithMeta = async (pwd, options = {})=>{
+    const hostManifest = await getHostManifest(pwd, options.monitors);
+    if (!hostManifest) return {
+        assets: [],
+        errored: false
+    };
+    const fetcher = options.fetcher || globalThis.fetch?.bind(globalThis);
+    if (!fetcher) {
+        warn(options.monitors, 'Skip module federation remote CSS collection because fetch is unavailable.');
+        return {
+            assets: [],
+            errored: false
+        };
+    }
+    const timeout = options.timeout ?? DEFAULT_REMOTE_MANIFEST_TIMEOUT;
+    const remoteResults = await Promise.all((hostManifest.remotes || []).map(async (remote)=>{
+        if (!remote.entry) return {
+            assets: [],
+            errored: false
+        };
+        const remoteEntry = normalizeRemoteEntry(remote.entry);
+        if (!remoteEntry) return {
+            assets: [],
+            errored: false
+        };
+        let remoteManifestUrl;
+        try {
+            remoteManifestUrl = new URL(remoteEntry).toString();
+        } catch  {
+            warn(options.monitors, 'Skip module federation remote CSS collection for non-absolute manifest URL %s', remoteEntry);
+            return {
+                assets: [],
+                errored: false
+            };
+        }
+        try {
+            const remoteManifest = await fetchJsonWithTimeout(remoteManifestUrl, fetcher, timeout);
+            return {
+                assets: collectModuleFederationManifestCss(remoteManifest, remoteManifestUrl),
+                errored: false
+            };
+        } catch (error) {
+            warn(options.monitors, 'Load module federation remote manifest %s failed, error = %s', remoteManifestUrl, error instanceof Error ? error.message : error);
+            return {
+                assets: [],
+                errored: true
+            };
+        }
+    }));
+    const cssAssets = [];
+    const seen = new Set();
+    let errored = false;
+    for (const result of remoteResults){
+        errored = errored || result.errored;
+        for (const asset of result.assets)if (!seen.has(asset)) {
+            seen.add(asset);
+            cssAssets.push(asset);
+        }
+    }
+    return {
+        assets: cssAssets,
+        errored
+    };
+};
+const collectDirectRemoteModuleFederationCss = async (pwd, options = {})=>{
+    const { assets } = await collectDirectRemoteModuleFederationCssWithMeta(pwd, options);
+    return assets;
+};
+const createModuleFederationCssCollector = (pwd, options = {})=>{
+    const { ttlMs = 0, now = Date.now, ...collectOptions } = options;
+    const normalizedTtlMs = Math.max(0, ttlMs);
+    let cached;
+    let lastGoodAssets;
+    let inflight;
+    const refresh = (monitors)=>{
+        const promise = collectDirectRemoteModuleFederationCssWithMeta(pwd, {
+            ...collectOptions,
+            monitors: monitors ?? collectOptions.monitors
+        }).then((result)=>{
+            if (!result.errored) {
+                lastGoodAssets = result.assets;
+                cached = {
+                    assets: result.assets,
+                    expiresAt: now() + normalizedTtlMs
+                };
+                return result.assets;
+            }
+            cached = void 0;
+            return lastGoodAssets ?? result.assets;
+        }).finally(()=>{
+            if (inflight === promise) inflight = void 0;
+        });
+        inflight = promise;
+        return promise;
+    };
+    return {
+        collect (monitors) {
+            if (cached && now() < cached.expiresAt) return Promise.resolve(cached.assets);
+            if (inflight) return inflight;
+            return refresh(monitors);
+        }
+    };
+};
+const DEFAULT_REMOTE_CSS_CACHE_TTL_MS = 30000;
+const injectModuleFederationCssPlugin = (options = {})=>({
+        name: '@modern-js/inject-module-federation-css',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, distDirectory: pwd } = api.getServerContext();
+                if (!pwd) return;
+                const ttlMs = Math.max(0, options.remoteCssCacheTtlMs ?? (isProd() ? DEFAULT_REMOTE_CSS_CACHE_TTL_MS : 0));
+                const collector = createModuleFederationCssCollector(pwd, {
+                    ttlMs
+                });
+                if (isProd()) collector.collect().catch(()=>{});
+                const handler = async (c, next)=>{
+                    const serverManifest = c.get('serverManifest');
+                    if (serverManifest && !serverManifest.moduleFederationCssAssets) {
+                        const monitors = c.get('monitors');
+                        const moduleFederationCssAssets = await collector.collect(monitors);
+                        c.set('serverManifest', {
+                            ...serverManifest,
+                            moduleFederationCssAssets
+                        });
+                    }
+                    await next();
+                };
+                middlewares.push({
+                    name: 'inject-module-federation-css',
+                    handler
+                });
+            });
+        }
+    });
+export { collectDirectRemoteModuleFederationCss, collectDirectRemoteModuleFederationCssWithMeta, collectModuleFederationManifestCss, createModuleFederationCssCollector, injectModuleFederationCssPlugin };