@bleedingdev/modern-js-server-core 3.2.0-ultramodern.0

package/dist/cjs/plugins/contractGateSnapshotStore.js

@@ -0,0 +1,239 @@
+"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, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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: ()=>CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION,
+    DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH: ()=>DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH,
+    createFileContractGateSnapshotStore: ()=>createFileContractGateSnapshotStore,
+    createHttpContractGateSnapshotStore: ()=>createHttpContractGateSnapshotStore,
+    resolveContractGateSnapshotPath: ()=>resolveContractGateSnapshotPath,
+    resolveContractGateSnapshotStore: ()=>resolveContractGateSnapshotStore
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_fs_namespaceObject = require("fs");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+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'
+]);
+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 (external_path_default().isAbsolute(normalized)) return normalized;
+    return normalized.startsWith('.') ? external_path_default().resolve(appDirectory, normalized) : normalized;
+};
+const resolveContractGateSnapshotPath = (appDirectory, configuredPath)=>{
+    const rawPath = configuredPath || process.env.MODERN_CONTRACT_GATES_FILE || DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH;
+    if (external_path_default().isAbsolute(rawPath)) return rawPath;
+    return external_path_default().resolve(appDirectory, rawPath);
+};
+const createFileContractGateSnapshotStore = (gateSnapshotPath)=>{
+    const resolvedPath = external_path_default().resolve(gateSnapshotPath);
+    return {
+        name: `file:${resolvedPath}`,
+        async readSnapshot () {
+            if (!await utils_namespaceObject.fs.pathExists(resolvedPath)) return;
+            try {
+                const raw = await external_fs_namespaceObject.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 external_fs_namespaceObject.promises.mkdir(external_path_default().dirname(resolvedPath), {
+                recursive: true
+            });
+            await external_fs_namespaceObject.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;
+};
+exports.CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION = __webpack_exports__.CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION;
+exports.DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH = __webpack_exports__.DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH;
+exports.createFileContractGateSnapshotStore = __webpack_exports__.createFileContractGateSnapshotStore;
+exports.createHttpContractGateSnapshotStore = __webpack_exports__.createHttpContractGateSnapshotStore;
+exports.resolveContractGateSnapshotPath = __webpack_exports__.resolveContractGateSnapshotPath;
+exports.resolveContractGateSnapshotStore = __webpack_exports__.resolveContractGateSnapshotStore;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION",
+    "DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH",
+    "createFileContractGateSnapshotStore",
+    "createHttpContractGateSnapshotStore",
+    "resolveContractGateSnapshotPath",
+    "resolveContractGateSnapshotStore"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/default.js

@@ -0,0 +1,61 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    createDefaultPlugins: ()=>createDefaultPlugins
+});
+const index_js_namespaceObject = require("./compat/index.js");
+const external_log_js_namespaceObject = require("./log.js");
+const external_monitors_js_namespaceObject = require("./monitors.js");
+const external_processedBy_js_namespaceObject = require("./processedBy.js");
+const external_render_index_js_namespaceObject = require("./render/index.js");
+const external_route_js_namespaceObject = require("./route.js");
+const external_telemetry_js_namespaceObject = require("./telemetry.js");
+function createSilenceLogger() {
+    return new Proxy({}, {
+        get: ()=>()=>{}
+    });
+}
+function createDefaultPlugins(options = {}) {
+    const plugins = [
+        (0, index_js_namespaceObject.compatPlugin)(),
+        (0, external_log_js_namespaceObject.logPlugin)(),
+        (0, external_monitors_js_namespaceObject.initMonitorsPlugin)(),
+        (0, external_telemetry_js_namespaceObject.injectTelemetryPlugin)(),
+        (0, external_render_index_js_namespaceObject.injectRenderHandlerPlugin)(options),
+        (0, external_monitors_js_namespaceObject.injectloggerPlugin)(options.logger ? options.logger : createSilenceLogger()),
+        (0, external_monitors_js_namespaceObject.injectServerTiming)(),
+        (0, external_processedBy_js_namespaceObject.processedByPlugin)(),
+        (0, external_route_js_namespaceObject.injectRoutePlugin)()
+    ];
+    return plugins;
+}
+exports.createDefaultPlugins = __webpack_exports__.createDefaultPlugins;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDefaultPlugins"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/favicon.js

@@ -0,0 +1,48 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    faviconPlugin: ()=>faviconPlugin
+});
+const faviconPlugin = ()=>({
+        name: '@modern-js/plugin-favicon',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'favicon-fallback',
+                    path: '/favicon.ico',
+                    handler: async (c, _next)=>c.body(null, 204)
+                });
+            });
+        }
+    });
+exports.faviconPlugin = __webpack_exports__.faviconPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "faviconPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/index.js

@@ -0,0 +1,157 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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_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,
+    compatPlugin: ()=>index_js_namespaceObject.compatPlugin,
+    createDefaultPlugins: ()=>external_default_js_namespaceObject.createDefaultPlugins,
+    createFileContractGateSnapshotStore: ()=>external_contractGateSnapshotStore_js_namespaceObject.createFileContractGateSnapshotStore,
+    createHttpContractGateSnapshotStore: ()=>external_contractGateSnapshotStore_js_namespaceObject.createHttpContractGateSnapshotStore,
+    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,
+    faviconPlugin: ()=>external_favicon_js_namespaceObject.faviconPlugin,
+    getRenderHandler: ()=>external_render_index_js_namespaceObject.getRenderHandler,
+    getRuntimeSignalErrorStatusCode: ()=>external_telemetry_js_namespaceObject.getRuntimeSignalErrorStatusCode,
+    handleSetupResult: ()=>index_js_namespaceObject.handleSetupResult,
+    hasEnabledTelemetryExporters: ()=>external_telemetry_js_namespaceObject.hasEnabledTelemetryExporters,
+    injectConfigMiddlewarePlugin: ()=>external_middlewares_js_namespaceObject.injectConfigMiddlewarePlugin,
+    injectRenderHandlerPlugin: ()=>external_render_index_js_namespaceObject.injectRenderHandlerPlugin,
+    injectServerTiming: ()=>external_monitors_js_namespaceObject.injectServerTiming,
+    injectTelemetryPlugin: ()=>external_telemetry_js_namespaceObject.injectTelemetryPlugin,
+    injectloggerPlugin: ()=>external_monitors_js_namespaceObject.injectloggerPlugin,
+    logPlugin: ()=>external_log_js_namespaceObject.logPlugin,
+    normalizeRuntimeFallbackSignalAuthConfig: ()=>external_telemetry_js_namespaceObject.normalizeRuntimeFallbackSignalAuthConfig,
+    normalizeRuntimeFallbackTrustPolicy: ()=>external_telemetry_js_namespaceObject.normalizeRuntimeFallbackTrustPolicy,
+    parseRuntimeFallbackSignalPayloadFromRawBody: ()=>external_telemetry_js_namespaceObject.parseRuntimeFallbackSignalPayloadFromRawBody,
+    processedByPlugin: ()=>external_processedBy_js_namespaceObject.processedByPlugin,
+    renderPlugin: ()=>external_render_index_js_namespaceObject.renderPlugin,
+    resolveContractGateSnapshotPath: ()=>external_contractGateSnapshotStore_js_namespaceObject.resolveContractGateSnapshotPath,
+    resolveContractGateSnapshotStore: ()=>external_contractGateSnapshotStore_js_namespaceObject.resolveContractGateSnapshotStore,
+    resolveRuntimeFallbackSignalEndpoint: ()=>external_telemetry_js_namespaceObject.resolveRuntimeFallbackSignalEndpoint
+});
+const index_js_namespaceObject = require("./compat/index.js");
+const external_contractGateAutopilot_js_namespaceObject = require("./contractGateAutopilot.js");
+const external_contractGateSnapshotStore_js_namespaceObject = require("./contractGateSnapshotStore.js");
+const external_default_js_namespaceObject = require("./default.js");
+const external_favicon_js_namespaceObject = require("./favicon.js");
+const external_log_js_namespaceObject = require("./log.js");
+const external_middlewares_js_namespaceObject = require("./middlewares.js");
+const external_monitors_js_namespaceObject = require("./monitors.js");
+const external_processedBy_js_namespaceObject = require("./processedBy.js");
+const external_render_index_js_namespaceObject = require("./render/index.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_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.compatPlugin = __webpack_exports__.compatPlugin;
+exports.createDefaultPlugins = __webpack_exports__.createDefaultPlugins;
+exports.createFileContractGateSnapshotStore = __webpack_exports__.createFileContractGateSnapshotStore;
+exports.createHttpContractGateSnapshotStore = __webpack_exports__.createHttpContractGateSnapshotStore;
+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.faviconPlugin = __webpack_exports__.faviconPlugin;
+exports.getRenderHandler = __webpack_exports__.getRenderHandler;
+exports.getRuntimeSignalErrorStatusCode = __webpack_exports__.getRuntimeSignalErrorStatusCode;
+exports.handleSetupResult = __webpack_exports__.handleSetupResult;
+exports.hasEnabledTelemetryExporters = __webpack_exports__.hasEnabledTelemetryExporters;
+exports.injectConfigMiddlewarePlugin = __webpack_exports__.injectConfigMiddlewarePlugin;
+exports.injectRenderHandlerPlugin = __webpack_exports__.injectRenderHandlerPlugin;
+exports.injectServerTiming = __webpack_exports__.injectServerTiming;
+exports.injectTelemetryPlugin = __webpack_exports__.injectTelemetryPlugin;
+exports.injectloggerPlugin = __webpack_exports__.injectloggerPlugin;
+exports.logPlugin = __webpack_exports__.logPlugin;
+exports.normalizeRuntimeFallbackSignalAuthConfig = __webpack_exports__.normalizeRuntimeFallbackSignalAuthConfig;
+exports.normalizeRuntimeFallbackTrustPolicy = __webpack_exports__.normalizeRuntimeFallbackTrustPolicy;
+exports.parseRuntimeFallbackSignalPayloadFromRawBody = __webpack_exports__.parseRuntimeFallbackSignalPayloadFromRawBody;
+exports.processedByPlugin = __webpack_exports__.processedByPlugin;
+exports.renderPlugin = __webpack_exports__.renderPlugin;
+exports.resolveContractGateSnapshotPath = __webpack_exports__.resolveContractGateSnapshotPath;
+exports.resolveContractGateSnapshotStore = __webpack_exports__.resolveContractGateSnapshotStore;
+exports.resolveRuntimeFallbackSignalEndpoint = __webpack_exports__.resolveRuntimeFallbackSignalEndpoint;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION",
+    "ContractGateAutopilot",
+    "DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH",
+    "DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT",
+    "DEFAULT_RUNTIME_STATUS_ENDPOINT",
+    "TelemetryCanaryOrchestrator",
+    "TelemetryRegistry",
+    "TelemetryStartupHealthError",
+    "compatPlugin",
+    "createDefaultPlugins",
+    "createFileContractGateSnapshotStore",
+    "createHttpContractGateSnapshotStore",
+    "createOtlpTelemetryExporter",
+    "createRuntimeFallbackSignalRuntimeState",
+    "createRuntimeSignalError",
+    "createTelemetryAwareMetrics",
+    "createVictoriaMetricsTelemetryExporter",
+    "enforceRuntimeFallbackSignalAuthToken",
+    "enforceRuntimeFallbackSignalTrustPolicy",
+    "faviconPlugin",
+    "getRenderHandler",
+    "getRuntimeSignalErrorStatusCode",
+    "handleSetupResult",
+    "hasEnabledTelemetryExporters",
+    "injectConfigMiddlewarePlugin",
+    "injectRenderHandlerPlugin",
+    "injectServerTiming",
+    "injectTelemetryPlugin",
+    "injectloggerPlugin",
+    "logPlugin",
+    "normalizeRuntimeFallbackSignalAuthConfig",
+    "normalizeRuntimeFallbackTrustPolicy",
+    "parseRuntimeFallbackSignalPayloadFromRawBody",
+    "processedByPlugin",
+    "renderPlugin",
+    "resolveContractGateSnapshotPath",
+    "resolveContractGateSnapshotStore",
+    "resolveRuntimeFallbackSignalEndpoint"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/log.js

@@ -0,0 +1,92 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    logPlugin: ()=>logPlugin
+});
+const index_js_namespaceObject = require("../utils/index.js");
+const humanize = (times)=>{
+    const [delimiter, separator] = [
+        ',',
+        '.'
+    ];
+    const orderTimes = times.map((v)=>v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, `$1${delimiter}`));
+    return orderTimes.join(separator);
+};
+const time = (start)=>{
+    const delta = Date.now() - start;
+    return humanize([
+        delta < 1000 ? `${delta}ms` : `${Math.round(delta / 1000)}s`
+    ]);
+};
+const colorStatus = (status)=>{
+    const out = {
+        7: `\x1b[35m${status}\x1b[0m`,
+        5: `\x1b[31m${status}\x1b[0m`,
+        4: `\x1b[33m${status}\x1b[0m`,
+        3: `\x1b[36m${status}\x1b[0m`,
+        2: `\x1b[32m${status}\x1b[0m`,
+        1: `\x1b[32m${status}\x1b[0m`,
+        0: `\x1b[33m${status}\x1b[0m`
+    };
+    const calculateStatus = Math.floor(status / 100);
+    return out[calculateStatus];
+};
+function log(fn, prefix, method, path, status = 0, elapsed) {
+    const out = "<--" === prefix ? `  ${prefix} ${method} ${path}` : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;
+    fn(out);
+}
+function logHandler() {
+    return async function(c, next) {
+        const { method } = c.req;
+        const monitors = c.get('monitors');
+        if (!monitors) return void await next();
+        const path = (0, index_js_namespaceObject.getPathname)(c.req.raw);
+        const logFn = monitors.debug;
+        log(logFn, "<--", method, path);
+        const start = Date.now();
+        await next();
+        log(logFn, "-->", method, path, c?.env?.node?.res?.statusCode ?? c.res.status, time(start));
+    };
+}
+const logPlugin = ()=>({
+        name: '@modern-js/plugin-log',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'print_log',
+                    handler: logHandler()
+                });
+            });
+        }
+    });
+exports.logPlugin = __webpack_exports__.logPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "logPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/mfCache.js

@@ -0,0 +1,78 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    getRequestPathname: ()=>getRequestPathname,
+    isMfManifestAsset: ()=>isMfManifestAsset,
+    isMfRemoteEntryAsset: ()=>isMfRemoteEntryAsset,
+    resolveMfAssetCacheHeaders: ()=>resolveMfAssetCacheHeaders
+});
+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'
+    };
+}
+exports.getRequestPathname = __webpack_exports__.getRequestPathname;
+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",
+    "isMfManifestAsset",
+    "isMfRemoteEntryAsset",
+    "resolveMfAssetCacheHeaders"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});