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

package/dist/esm-node/index.mjs

@@ -0,0 +1,13 @@
+import "node:module";
+export * from "./plugins/index.mjs";
+export * from "./types/config/index.mjs";
+export * from "./types/plugins/index.mjs";
+export * from "./types/render.mjs";
+export * from "./types/requestHandler.mjs";
+export { Hono } from "hono";
+export { AGGRED_DIR } from "./constants.mjs";
+export { run, useHonoContext } from "./context.mjs";
+export { getLoaderCtx } from "./helper.mjs";
+export { createServerBase } from "./serverBase.mjs";
+export { ErrorDigest, createErrorHtml, onError } from "./utils/index.mjs";
+export { getPublicDirConfig, getPublicDirPatterns, getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath, resolvePublicDirPaths } from "./utils/publicDir.mjs";

package/dist/esm-node/plugins/compat/hooks.mjs

@@ -0,0 +1,41 @@
+import "node:module";
+function getHookRunners(context) {
+    const { hooks } = context;
+    return {
+        config: (params)=>hooks.modifyConfig.call(params),
+        prepare: ()=>hooks.onPrepare.call(),
+        reset: (params)=>hooks.onReset.call(params),
+        fallback: (input)=>hooks.fallback.call(input),
+        prepareWebServer: (input)=>hooks.prepareWebServer.call(input),
+        prepareApiServer: (input)=>hooks.prepareApiServer.call(input),
+        afterMatch: (ctx)=>hooks.afterMatch.call(ctx),
+        afterRender: (ctx)=>hooks.afterRender.call(ctx),
+        afterStreamingRender: (ctx)=>hooks.afterStreamingRender.call(ctx)
+    };
+}
+function transformHookRunner(hookRunnerName) {
+    switch(hookRunnerName){
+        case 'config':
+            return 'modifyConfig';
+        case 'prepare':
+            return 'onPrepare';
+        case 'reset':
+            return 'onReset';
+        default:
+            return hookRunnerName;
+    }
+}
+function handleSetupResult(setupResult, api) {
+    if (!setupResult) return;
+    Object.keys(setupResult).forEach((key)=>{
+        const fn = setupResult[key];
+        if ('function' == typeof fn) {
+            const newAPI = transformHookRunner(key);
+            if (api[newAPI]) api[newAPI]((...params)=>{
+                const res = fn(...params);
+                return res;
+            });
+        }
+    });
+}
+export { getHookRunners, handleSetupResult, transformHookRunner };

package/dist/esm-node/plugins/compat/index.mjs

@@ -0,0 +1,28 @@
+import "node:module";
+import { createAsyncHook, createAsyncPipelineHook } from "@modern-js/plugin";
+import { getHookRunners, handleSetupResult } from "./hooks.mjs";
+const compatPlugin = ()=>({
+        name: '@modern-js/server-compat',
+        registryHooks: {
+            fallback: createAsyncHook(),
+            prepareWebServer: createAsyncPipelineHook(),
+            prepareApiServer: createAsyncPipelineHook(),
+            afterMatch: createAsyncPipelineHook(),
+            afterRender: createAsyncPipelineHook(),
+            afterStreamingRender: createAsyncPipelineHook()
+        },
+        _registryApi: (getServerContext, updateServerContext)=>{
+            const getInternalContext = ()=>getServerContext()._internalContext;
+            return {
+                useConfigContext: ()=>getInternalContext().config,
+                useAppContext: ()=>{
+                    const { _internalContext, ...serverContext } = getServerContext();
+                    return serverContext;
+                },
+                setAppContext: (context)=>updateServerContext(context),
+                useHookRunners: ()=>getHookRunners(getInternalContext())
+            };
+        },
+        setup: ()=>{}
+    });
+export { compatPlugin, handleSetupResult };

package/dist/esm-node/plugins/contractGateAutopilot.mjs

@@ -0,0 +1,125 @@
+import "node:module";
+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-node/plugins/contractGateSnapshotStore.mjs

@@ -0,0 +1,182 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { fs } from "@modern-js/utils";
+import { promises } from "fs";
+import path from "path";
+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 (path.isAbsolute(normalized)) return normalized;
+    return normalized.startsWith('.') ? path.resolve(appDirectory, normalized) : normalized;
+};
+const resolveContractGateSnapshotPath = (appDirectory, configuredPath)=>{
+    const rawPath = configuredPath || process.env.MODERN_CONTRACT_GATES_FILE || 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-node/plugins/default.mjs

@@ -0,0 +1,28 @@
+import "node:module";
+import { compatPlugin } from "./compat/index.mjs";
+import { logPlugin } from "./log.mjs";
+import { initMonitorsPlugin, injectServerTiming, injectloggerPlugin } from "./monitors.mjs";
+import { processedByPlugin } from "./processedBy.mjs";
+import { injectRenderHandlerPlugin } from "./render/index.mjs";
+import { injectRoutePlugin } from "./route.mjs";
+import { injectTelemetryPlugin } from "./telemetry.mjs";
+function createSilenceLogger() {
+    return new Proxy({}, {
+        get: ()=>()=>{}
+    });
+}
+function createDefaultPlugins(options = {}) {
+    const plugins = [
+        compatPlugin(),
+        logPlugin(),
+        initMonitorsPlugin(),
+        injectTelemetryPlugin(),
+        injectRenderHandlerPlugin(options),
+        injectloggerPlugin(options.logger ? options.logger : createSilenceLogger()),
+        injectServerTiming(),
+        processedByPlugin(),
+        injectRoutePlugin()
+    ];
+    return plugins;
+}
+export { createDefaultPlugins };

package/dist/esm-node/plugins/favicon.mjs

@@ -0,0 +1,15 @@
+import "node:module";
+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)
+                });
+            });
+        }
+    });
+export { faviconPlugin };

package/dist/esm-node/plugins/index.mjs

@@ -0,0 +1,12 @@
+import "node:module";
+export { compatPlugin, handleSetupResult } from "./compat/index.mjs";
+export { ContractGateAutopilot } from "./contractGateAutopilot.mjs";
+export { CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION, DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH, createFileContractGateSnapshotStore, createHttpContractGateSnapshotStore, resolveContractGateSnapshotPath, resolveContractGateSnapshotStore } from "./contractGateSnapshotStore.mjs";
+export { createDefaultPlugins } from "./default.mjs";
+export { faviconPlugin } from "./favicon.mjs";
+export { logPlugin } from "./log.mjs";
+export { injectConfigMiddlewarePlugin } from "./middlewares.mjs";
+export { injectServerTiming, injectloggerPlugin } from "./monitors.mjs";
+export { processedByPlugin } from "./processedBy.mjs";
+export { getRenderHandler, injectRenderHandlerPlugin, renderPlugin } from "./render/index.mjs";
+export { DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, DEFAULT_RUNTIME_STATUS_ENDPOINT, TelemetryCanaryOrchestrator, TelemetryRegistry, TelemetryStartupHealthError, createOtlpTelemetryExporter, createRuntimeFallbackSignalRuntimeState, createRuntimeSignalError, createTelemetryAwareMetrics, createVictoriaMetricsTelemetryExporter, enforceRuntimeFallbackSignalAuthToken, enforceRuntimeFallbackSignalTrustPolicy, getRuntimeSignalErrorStatusCode, hasEnabledTelemetryExporters, injectTelemetryPlugin, normalizeRuntimeFallbackSignalAuthConfig, normalizeRuntimeFallbackTrustPolicy, parseRuntimeFallbackSignalPayloadFromRawBody, resolveRuntimeFallbackSignalEndpoint } from "./telemetry.mjs";

package/dist/esm-node/plugins/log.mjs

@@ -0,0 +1,59 @@
+import "node:module";
+import { getPathname } from "../utils/index.mjs";
+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 = 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()
+                });
+            });
+        }
+    });
+export { logPlugin };

package/dist/esm-node/plugins/mfCache.mjs

@@ -0,0 +1,36 @@
+import "node:module";
+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'
+    };
+}
+export { getRequestPathname, isMfManifestAsset, isMfRemoteEntryAsset, resolveMfAssetCacheHeaders };

package/dist/esm-node/plugins/middlewares.mjs

@@ -0,0 +1,16 @@
+import "node:module";
+const injectConfigMiddlewarePlugin = (configMiddlewares = [], configRenderMiddlewares = [])=>({
+        name: '@modern-js/plugin-inject-config-middleware',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, renderMiddlewares } = api.getServerContext();
+                configMiddlewares.forEach((m)=>{
+                    middlewares.push(m);
+                });
+                configRenderMiddlewares.forEach((m)=>{
+                    renderMiddlewares.push(m);
+                });
+            });
+        }
+    });
+export { injectConfigMiddlewarePlugin };