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

package/dist/cjs/index.js

@@ -0,0 +1,162 @@
+"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__, {
+    CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION: ()=>external_contractGateSnapshotStore_js_namespaceObject.CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION,
+    ContractGateAutopilot: ()=>external_contractGateAutopilot_js_namespaceObject.ContractGateAutopilot,
+    DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH: ()=>external_contractGateSnapshotStore_js_namespaceObject.DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH,
+    DEFAULT_ENVIRONMENT_NAME: ()=>external_env_js_namespaceObject.DEFAULT_ENVIRONMENT_NAME,
+    DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT: ()=>external_telemetry_js_namespaceObject.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT,
+    DEFAULT_RUNTIME_STATUS_ENDPOINT: ()=>external_telemetry_js_namespaceObject.DEFAULT_RUNTIME_STATUS_ENDPOINT,
+    TelemetryCanaryOrchestrator: ()=>external_telemetry_js_namespaceObject.TelemetryCanaryOrchestrator,
+    TelemetryRegistry: ()=>external_telemetry_js_namespaceObject.TelemetryRegistry,
+    TelemetryStartupHealthError: ()=>external_telemetry_js_namespaceObject.TelemetryStartupHealthError,
+    collectDirectRemoteModuleFederationCss: ()=>external_moduleFederationCss_js_namespaceObject.collectDirectRemoteModuleFederationCss,
+    collectDirectRemoteModuleFederationCssWithMeta: ()=>external_moduleFederationCss_js_namespaceObject.collectDirectRemoteModuleFederationCssWithMeta,
+    collectModuleFederationManifestCss: ()=>external_moduleFederationCss_js_namespaceObject.collectModuleFederationManifestCss,
+    createFileContractGateSnapshotStore: ()=>external_contractGateSnapshotStore_js_namespaceObject.createFileContractGateSnapshotStore,
+    createHttpContractGateSnapshotStore: ()=>external_contractGateSnapshotStore_js_namespaceObject.createHttpContractGateSnapshotStore,
+    createModuleFederationCssCollector: ()=>external_moduleFederationCss_js_namespaceObject.createModuleFederationCssCollector,
+    createOtlpTelemetryExporter: ()=>external_telemetry_js_namespaceObject.createOtlpTelemetryExporter,
+    createRuntimeFallbackSignalRuntimeState: ()=>external_telemetry_js_namespaceObject.createRuntimeFallbackSignalRuntimeState,
+    createRuntimeSignalError: ()=>external_telemetry_js_namespaceObject.createRuntimeSignalError,
+    createTelemetryAwareMetrics: ()=>external_telemetry_js_namespaceObject.createTelemetryAwareMetrics,
+    createVictoriaMetricsTelemetryExporter: ()=>external_telemetry_js_namespaceObject.createVictoriaMetricsTelemetryExporter,
+    enforceRuntimeFallbackSignalAuthToken: ()=>external_telemetry_js_namespaceObject.enforceRuntimeFallbackSignalAuthToken,
+    enforceRuntimeFallbackSignalTrustPolicy: ()=>external_telemetry_js_namespaceObject.enforceRuntimeFallbackSignalTrustPolicy,
+    getRequestPathname: ()=>external_mfCache_js_namespaceObject.getRequestPathname,
+    getRuntimeSignalErrorStatusCode: ()=>external_telemetry_js_namespaceObject.getRuntimeSignalErrorStatusCode,
+    hasEnabledTelemetryExporters: ()=>external_telemetry_js_namespaceObject.hasEnabledTelemetryExporters,
+    injectMfAssetCacheHeadersPlugin: ()=>external_mfCache_js_namespaceObject.injectMfAssetCacheHeadersPlugin,
+    injectModuleFederationCssPlugin: ()=>external_moduleFederationCss_js_namespaceObject.injectModuleFederationCssPlugin,
+    injectTelemetryPlugin: ()=>external_telemetry_js_namespaceObject.injectTelemetryPlugin,
+    isMfManifestAsset: ()=>external_mfCache_js_namespaceObject.isMfManifestAsset,
+    isMfRemoteEntryAsset: ()=>external_mfCache_js_namespaceObject.isMfRemoteEntryAsset,
+    normalizeRequiredRuntimeFallbackSignalAuthConfig: ()=>external_telemetry_js_namespaceObject.normalizeRequiredRuntimeFallbackSignalAuthConfig,
+    normalizeRuntimeFallbackSignalAuthConfig: ()=>external_telemetry_js_namespaceObject.normalizeRuntimeFallbackSignalAuthConfig,
+    normalizeRuntimeFallbackTrustPolicy: ()=>external_telemetry_js_namespaceObject.normalizeRuntimeFallbackTrustPolicy,
+    parseRuntimeFallbackSignalPayloadFromRawBody: ()=>external_telemetry_js_namespaceObject.parseRuntimeFallbackSignalPayloadFromRawBody,
+    parseServerRuntimeExtensionsEnv: ()=>external_env_js_namespaceObject.parseServerRuntimeExtensionsEnv,
+    resolveContractGateSnapshotPath: ()=>external_contractGateSnapshotStore_js_namespaceObject.resolveContractGateSnapshotPath,
+    resolveContractGateSnapshotStore: ()=>external_contractGateSnapshotStore_js_namespaceObject.resolveContractGateSnapshotStore,
+    resolveMfAssetCacheHeaders: ()=>external_mfCache_js_namespaceObject.resolveMfAssetCacheHeaders,
+    resolveRuntimeFallbackSignalEndpoint: ()=>external_telemetry_js_namespaceObject.resolveRuntimeFallbackSignalEndpoint,
+    resolveTelemetrySloOptions: ()=>external_telemetry_js_namespaceObject.resolveTelemetrySloOptions
+});
+const external_contractGateAutopilot_js_namespaceObject = require("./contractGateAutopilot.js");
+const external_contractGateSnapshotStore_js_namespaceObject = require("./contractGateSnapshotStore.js");
+const external_env_js_namespaceObject = require("./env.js");
+const external_mfCache_js_namespaceObject = require("./mfCache.js");
+const external_moduleFederationCss_js_namespaceObject = require("./moduleFederationCss.js");
+const external_telemetry_js_namespaceObject = require("./telemetry.js");
+exports.CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION = __webpack_exports__.CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION;
+exports.ContractGateAutopilot = __webpack_exports__.ContractGateAutopilot;
+exports.DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH = __webpack_exports__.DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH;
+exports.DEFAULT_ENVIRONMENT_NAME = __webpack_exports__.DEFAULT_ENVIRONMENT_NAME;
+exports.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = __webpack_exports__.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT;
+exports.DEFAULT_RUNTIME_STATUS_ENDPOINT = __webpack_exports__.DEFAULT_RUNTIME_STATUS_ENDPOINT;
+exports.TelemetryCanaryOrchestrator = __webpack_exports__.TelemetryCanaryOrchestrator;
+exports.TelemetryRegistry = __webpack_exports__.TelemetryRegistry;
+exports.TelemetryStartupHealthError = __webpack_exports__.TelemetryStartupHealthError;
+exports.collectDirectRemoteModuleFederationCss = __webpack_exports__.collectDirectRemoteModuleFederationCss;
+exports.collectDirectRemoteModuleFederationCssWithMeta = __webpack_exports__.collectDirectRemoteModuleFederationCssWithMeta;
+exports.collectModuleFederationManifestCss = __webpack_exports__.collectModuleFederationManifestCss;
+exports.createFileContractGateSnapshotStore = __webpack_exports__.createFileContractGateSnapshotStore;
+exports.createHttpContractGateSnapshotStore = __webpack_exports__.createHttpContractGateSnapshotStore;
+exports.createModuleFederationCssCollector = __webpack_exports__.createModuleFederationCssCollector;
+exports.createOtlpTelemetryExporter = __webpack_exports__.createOtlpTelemetryExporter;
+exports.createRuntimeFallbackSignalRuntimeState = __webpack_exports__.createRuntimeFallbackSignalRuntimeState;
+exports.createRuntimeSignalError = __webpack_exports__.createRuntimeSignalError;
+exports.createTelemetryAwareMetrics = __webpack_exports__.createTelemetryAwareMetrics;
+exports.createVictoriaMetricsTelemetryExporter = __webpack_exports__.createVictoriaMetricsTelemetryExporter;
+exports.enforceRuntimeFallbackSignalAuthToken = __webpack_exports__.enforceRuntimeFallbackSignalAuthToken;
+exports.enforceRuntimeFallbackSignalTrustPolicy = __webpack_exports__.enforceRuntimeFallbackSignalTrustPolicy;
+exports.getRequestPathname = __webpack_exports__.getRequestPathname;
+exports.getRuntimeSignalErrorStatusCode = __webpack_exports__.getRuntimeSignalErrorStatusCode;
+exports.hasEnabledTelemetryExporters = __webpack_exports__.hasEnabledTelemetryExporters;
+exports.injectMfAssetCacheHeadersPlugin = __webpack_exports__.injectMfAssetCacheHeadersPlugin;
+exports.injectModuleFederationCssPlugin = __webpack_exports__.injectModuleFederationCssPlugin;
+exports.injectTelemetryPlugin = __webpack_exports__.injectTelemetryPlugin;
+exports.isMfManifestAsset = __webpack_exports__.isMfManifestAsset;
+exports.isMfRemoteEntryAsset = __webpack_exports__.isMfRemoteEntryAsset;
+exports.normalizeRequiredRuntimeFallbackSignalAuthConfig = __webpack_exports__.normalizeRequiredRuntimeFallbackSignalAuthConfig;
+exports.normalizeRuntimeFallbackSignalAuthConfig = __webpack_exports__.normalizeRuntimeFallbackSignalAuthConfig;
+exports.normalizeRuntimeFallbackTrustPolicy = __webpack_exports__.normalizeRuntimeFallbackTrustPolicy;
+exports.parseRuntimeFallbackSignalPayloadFromRawBody = __webpack_exports__.parseRuntimeFallbackSignalPayloadFromRawBody;
+exports.parseServerRuntimeExtensionsEnv = __webpack_exports__.parseServerRuntimeExtensionsEnv;
+exports.resolveContractGateSnapshotPath = __webpack_exports__.resolveContractGateSnapshotPath;
+exports.resolveContractGateSnapshotStore = __webpack_exports__.resolveContractGateSnapshotStore;
+exports.resolveMfAssetCacheHeaders = __webpack_exports__.resolveMfAssetCacheHeaders;
+exports.resolveRuntimeFallbackSignalEndpoint = __webpack_exports__.resolveRuntimeFallbackSignalEndpoint;
+exports.resolveTelemetrySloOptions = __webpack_exports__.resolveTelemetrySloOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION",
+    "ContractGateAutopilot",
+    "DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH",
+    "DEFAULT_ENVIRONMENT_NAME",
+    "DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT",
+    "DEFAULT_RUNTIME_STATUS_ENDPOINT",
+    "TelemetryCanaryOrchestrator",
+    "TelemetryRegistry",
+    "TelemetryStartupHealthError",
+    "collectDirectRemoteModuleFederationCss",
+    "collectDirectRemoteModuleFederationCssWithMeta",
+    "collectModuleFederationManifestCss",
+    "createFileContractGateSnapshotStore",
+    "createHttpContractGateSnapshotStore",
+    "createModuleFederationCssCollector",
+    "createOtlpTelemetryExporter",
+    "createRuntimeFallbackSignalRuntimeState",
+    "createRuntimeSignalError",
+    "createTelemetryAwareMetrics",
+    "createVictoriaMetricsTelemetryExporter",
+    "enforceRuntimeFallbackSignalAuthToken",
+    "enforceRuntimeFallbackSignalTrustPolicy",
+    "getRequestPathname",
+    "getRuntimeSignalErrorStatusCode",
+    "hasEnabledTelemetryExporters",
+    "injectMfAssetCacheHeadersPlugin",
+    "injectModuleFederationCssPlugin",
+    "injectTelemetryPlugin",
+    "isMfManifestAsset",
+    "isMfRemoteEntryAsset",
+    "normalizeRequiredRuntimeFallbackSignalAuthConfig",
+    "normalizeRuntimeFallbackSignalAuthConfig",
+    "normalizeRuntimeFallbackTrustPolicy",
+    "parseRuntimeFallbackSignalPayloadFromRawBody",
+    "parseServerRuntimeExtensionsEnv",
+    "resolveContractGateSnapshotPath",
+    "resolveContractGateSnapshotStore",
+    "resolveMfAssetCacheHeaders",
+    "resolveRuntimeFallbackSignalEndpoint",
+    "resolveTelemetrySloOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/mfCache.js

@@ -0,0 +1,106 @@
+"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 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'
+                });
+            });
+        }
+    });
+__webpack_require__.d(__webpack_exports__, {
+    getRequestPathname: ()=>getRequestPathname,
+    isMfManifestAsset: ()=>isMfManifestAsset,
+    isMfRemoteEntryAsset: ()=>isMfRemoteEntryAsset,
+    resolveMfAssetCacheHeaders: ()=>resolveMfAssetCacheHeaders
+}, {
+    injectMfAssetCacheHeadersPlugin: injectMfAssetCacheHeadersPlugin
+});
+exports.getRequestPathname = __webpack_exports__.getRequestPathname;
+exports.injectMfAssetCacheHeadersPlugin = __webpack_exports__.injectMfAssetCacheHeadersPlugin;
+exports.isMfManifestAsset = __webpack_exports__.isMfManifestAsset;
+exports.isMfRemoteEntryAsset = __webpack_exports__.isMfRemoteEntryAsset;
+exports.resolveMfAssetCacheHeaders = __webpack_exports__.resolveMfAssetCacheHeaders;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getRequestPathname",
+    "injectMfAssetCacheHeadersPlugin",
+    "isMfManifestAsset",
+    "isMfRemoteEntryAsset",
+    "resolveMfAssetCacheHeaders"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/moduleFederationCss.js

@@ -0,0 +1,285 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    collectDirectRemoteModuleFederationCss: ()=>collectDirectRemoteModuleFederationCss,
+    collectDirectRemoteModuleFederationCssWithMeta: ()=>collectDirectRemoteModuleFederationCssWithMeta,
+    collectModuleFederationManifestCss: ()=>collectModuleFederationManifestCss,
+    createModuleFederationCssCollector: ()=>createModuleFederationCssCollector,
+    injectModuleFederationCssPlugin: ()=>injectModuleFederationCssPlugin
+});
+const fileReader_namespaceObject = require("@modern-js/runtime-utils/fileReader");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+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 = external_path_default().join(pwd, MODULE_FEDERATION_MANIFEST_FILE);
+    if (!await utils_namespaceObject.fs.pathExists(manifestPath)) return;
+    const manifestBuffer = await fileReader_namespaceObject.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 ?? ((0, utils_namespaceObject.isProd)() ? DEFAULT_REMOTE_CSS_CACHE_TTL_MS : 0));
+                const collector = createModuleFederationCssCollector(pwd, {
+                    ttlMs
+                });
+                if ((0, utils_namespaceObject.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
+                });
+            });
+        }
+    });
+exports.collectDirectRemoteModuleFederationCss = __webpack_exports__.collectDirectRemoteModuleFederationCss;
+exports.collectDirectRemoteModuleFederationCssWithMeta = __webpack_exports__.collectDirectRemoteModuleFederationCssWithMeta;
+exports.collectModuleFederationManifestCss = __webpack_exports__.collectModuleFederationManifestCss;
+exports.createModuleFederationCssCollector = __webpack_exports__.createModuleFederationCssCollector;
+exports.injectModuleFederationCssPlugin = __webpack_exports__.injectModuleFederationCssPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "collectDirectRemoteModuleFederationCss",
+    "collectDirectRemoteModuleFederationCssWithMeta",
+    "collectModuleFederationManifestCss",
+    "createModuleFederationCssCollector",
+    "injectModuleFederationCssPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});