@bleedingdev/modern-js-server-core 3.8.2-ultramodern.9 → 3.8.3-ultramodern.2

package/dist/cjs/adapters/node/node.js

@@ -69,7 +69,9 @@ const createWebRequest = (req, res, body)=>{
         signal: controller.signal
     };
     res.on('close', ()=>controller.abort('res closed'));
-    const url = `http://${req.headers.host}${req.url}`;
+    const protocol = 'encrypted' in req.socket && req.socket.encrypted ? 'https' : 'http';
+    const authority = req.headers[':authority'] ?? req.headers.host;
+    const url = `${protocol}://${authority}${req.url}`;
     const needsRequestBody = body || !('GET' === method || 'HEAD' === method);
     const cloneableReq = needsRequestBody ? external_cloneable_readable_default()(req) : null;
     if (needsRequestBody) {

package/dist/cjs/adapters/node/plugins/staticModuleFederation.js

@@ -60,7 +60,11 @@ const MODULE_FEDERATION_OPTIONAL_FILES = [
     'mf-stats.json'
 ];
 const trimLeadingSlash = (value)=>value.replace(/^\/+/, '');
-const getModuleFederationRequestPath = (pathname, pathPrefix)=>trimLeadingSlash(pathname.replace(pathPrefix, ()=>''));
+const getModuleFederationRequestPath = (pathname, pathPrefix)=>{
+    const normalizedPrefix = `/${trimLeadingSlash(pathPrefix)}`.replace(/\/+$/u, '');
+    const requestPath = normalizedPrefix && (pathname === normalizedPrefix || pathname.startsWith(`${normalizedPrefix}/`)) ? pathname.slice(normalizedPrefix.length) : pathname;
+    return trimLeadingSlash(requestPath);
+};
 const isModuleFederationManifestRequest = (requestPath)=>MODULE_FEDERATION_MANIFEST_FILES.includes(requestPath);
 const isBackendModuleFederationManifestRequest = (requestPath)=>requestPath === BACKEND_MODULE_FEDERATION_MANIFEST_FILE;
 const applyModuleFederationAssetHeaders = (c)=>{

package/dist/cjs/adapters/node/plugins/staticPrecompressed.js

@@ -40,23 +40,32 @@ const PRE_COMPRESSED_SUPPORTED_ENCODINGS = [
     'br',
     'gzip'
 ];
+const QUALITY_VALUE_PATTERN = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/u;
 const parseAcceptEncoding = (value)=>value.split(',').map((item)=>item.trim()).filter(Boolean).map((item)=>{
         const [rawName, ...params] = item.split(';');
         const name = rawName.trim().toLowerCase();
         let q = 1;
+        let qualitySeen = false;
         for (const param of params){
             const [key, rawValue] = param.split('=').map((v)=>v.trim());
-            if ('q' !== key.toLowerCase() || null == rawValue) continue;
-            const parsedQ = Number(rawValue);
-            if (!Number.isNaN(parsedQ)) q = Math.max(0, Math.min(parsedQ, 1));
+            if ('q' === key.toLowerCase()) {
+                if (qualitySeen || null == rawValue || !QUALITY_VALUE_PATTERN.test(rawValue)) {
+                    q = 0;
+                    break;
+                }
+                qualitySeen = true;
+                q = Number(rawValue);
+            }
         }
         return {
             name,
             q
         };
     });
-const getAcceptedEncodings = (value)=>{
-    if (!value) return [];
+const getAcceptedRepresentations = (value)=>{
+    if (!value) return [
+        'identity'
+    ];
     const parsed = parseAcceptEncoding(value);
     const qualityByEncoding = new Map();
     let wildcardQuality;
@@ -72,10 +81,17 @@ const getAcceptedEncodings = (value)=>{
         if (void 0 !== explicit) return explicit;
         return wildcardQuality ?? 0;
     };
-    return PRE_COMPRESSED_SUPPORTED_ENCODINGS.map((encoding)=>({
-            encoding,
-            quality: getQuality(encoding)
-        })).filter((item)=>item.quality > 0).sort((a, b)=>b.quality - a.quality).map((item)=>item.encoding);
+    const identityQuality = qualityByEncoding.get('identity') ?? (0 === wildcardQuality ? 0 : 1);
+    return [
+        ...PRE_COMPRESSED_SUPPORTED_ENCODINGS.map((encoding)=>({
+                encoding,
+                quality: getQuality(encoding)
+            })),
+        {
+            encoding: 'identity',
+            quality: identityQuality
+        }
+    ].filter((item)=>item.quality > 0).sort((a, b)=>b.quality - a.quality).map((item)=>item.encoding);
 };
 const appendVaryHeader = (c, value)=>{
     const current = c.res.headers.get('Vary');
@@ -91,34 +107,38 @@ const resolvePreCompressedAsset = async (c, filepath)=>{
         utils_namespaceObject.fs.pathExists(gzipPath)
     ]);
     const hasVariant = hasBr || hasGzip;
-    if (!hasVariant) return {
-        selected: null,
-        hasVariant: false
-    };
-    const acceptedEncodings = getAcceptedEncodings(c.req.header('accept-encoding'));
-    for (const encoding of acceptedEncodings){
+    const acceptedRepresentations = getAcceptedRepresentations(c.req.header('accept-encoding'));
+    for (const encoding of acceptedRepresentations){
+        if ('identity' === encoding) return {
+            selected: null,
+            hasVariant,
+            acceptable: true
+        };
         if ('br' === encoding && hasBr) return {
             selected: {
                 filepath: brPath,
                 encoding
             },
-            hasVariant: true
+            hasVariant: true,
+            acceptable: true
         };
         if ('gzip' === encoding && hasGzip) return {
             selected: {
                 filepath: gzipPath,
                 encoding
             },
-            hasVariant: true
+            hasVariant: true,
+            acceptable: true
         };
     }
     return {
         selected: null,
-        hasVariant: true
+        hasVariant,
+        acceptable: false
     };
 };
 const applyPreCompressedAssetHeaders = (c, preCompressedAsset)=>{
-    if (preCompressedAsset.hasVariant) appendVaryHeader(c, 'Accept-Encoding');
+    if (preCompressedAsset.hasVariant || !preCompressedAsset.acceptable) appendVaryHeader(c, 'Accept-Encoding');
     if (preCompressedAsset.selected) c.header('Content-Encoding', preCompressedAsset.selected.encoding);
 };
 exports.applyPreCompressedAssetHeaders = __webpack_exports__.applyPreCompressedAssetHeaders;

package/dist/cjs/adapters/node/plugins/staticServing.js

@@ -48,11 +48,16 @@ const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const external_staticModuleFederation_js_namespaceObject = require("./staticModuleFederation.js");
 const external_staticPrecompressed_js_namespaceObject = require("./staticPrecompressed.js");
+const MODULE_FEDERATION_ASSET_REFRESH_INTERVAL_MS = 1000;
 const getStaticMimeType = (filename)=>(0, mime_namespaceObject.getMimeType)(filename) ?? ('.cjs' === external_path_default().extname(filename).toLowerCase() ? "text/javascript; charset=UTF-8" : void 0);
 const servePreCompressedPublicRouteAsset = async (c, pwd, route)=>{
     const { entryPath } = route;
     const originFilename = external_path_default().join(pwd, entryPath);
     const preCompressedAsset = await (0, external_staticPrecompressed_js_namespaceObject.resolvePreCompressedAsset)(c, originFilename);
+    if (!preCompressedAsset.acceptable) {
+        (0, external_staticPrecompressed_js_namespaceObject.applyPreCompressedAssetHeaders)(c, preCompressedAsset);
+        return c.body(null, 406);
+    }
     const filename = preCompressedAsset.selected?.filepath ?? originFilename;
     const data = await fileReader_namespaceObject.fileReader.readFile(filename, 'buffer');
     const mimeType = getStaticMimeType(originFilename);
@@ -99,6 +104,10 @@ const servePublicDirectoryAsset = async (c, pwd)=>{
     const originFilename = await resolvePublicDirectoryAsset(pwd, c.req.path);
     if (null === originFilename) return null;
     const preCompressedAsset = await (0, external_staticPrecompressed_js_namespaceObject.resolvePreCompressedAsset)(c, originFilename);
+    if (!preCompressedAsset.acceptable) {
+        (0, external_staticPrecompressed_js_namespaceObject.applyPreCompressedAssetHeaders)(c, preCompressedAsset);
+        return c.body(null, 406);
+    }
     const selectedFilename = preCompressedAsset.selected?.filepath ?? originFilename;
     const publicDirectory = await utils_namespaceObject.fs.realpath(external_path_default().join(pwd, 'public'));
     let realSelectedFilename;
@@ -119,10 +128,19 @@ const servePublicDirectoryAsset = async (c, pwd)=>{
     return c.body(body, 200);
 };
 const createModuleFederationStaticServing = ({ pwd, pathPrefix })=>{
-    let moduleFederationAssetsPromise = null;
+    let moduleFederationAssets = null;
+    let moduleFederationAssetsExpiresAt = 0;
+    let moduleFederationAssetsRefresh = null;
     const getModuleFederationAssets = async ()=>{
-        if (!moduleFederationAssetsPromise) moduleFederationAssetsPromise = (0, external_staticModuleFederation_js_namespaceObject.getModuleFederationAssetList)(pwd);
-        return moduleFederationAssetsPromise;
+        if (moduleFederationAssets && Date.now() < moduleFederationAssetsExpiresAt) return moduleFederationAssets;
+        if (!moduleFederationAssetsRefresh) moduleFederationAssetsRefresh = (0, external_staticModuleFederation_js_namespaceObject.getModuleFederationAssetList)(pwd).then((assets)=>{
+            moduleFederationAssets = assets;
+            moduleFederationAssetsExpiresAt = Date.now() + MODULE_FEDERATION_ASSET_REFRESH_INTERVAL_MS;
+            return assets;
+        }).finally(()=>{
+            moduleFederationAssetsRefresh = null;
+        });
+        return moduleFederationAssetsRefresh;
     };
     const resolveRequest = async (pathname)=>{
         const requestPath = (0, external_staticModuleFederation_js_namespaceObject.getModuleFederationRequestPath)(pathname, pathPrefix);
@@ -143,8 +161,13 @@ const createModuleFederationStaticServing = ({ pwd, pathPrefix })=>{
         const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
         const preCompressedAsset = canUsePreCompressed ? await (0, external_staticPrecompressed_js_namespaceObject.resolvePreCompressedAsset)(c, filepath) : {
             selected: null,
-            hasVariant: false
+            hasVariant: false,
+            acceptable: true
         };
+        if (!preCompressedAsset.acceptable) {
+            (0, external_staticPrecompressed_js_namespaceObject.applyPreCompressedAssetHeaders)(c, preCompressedAsset);
+            return c.body(null, 406);
+        }
         const targetFilepath = preCompressedAsset.selected?.filepath ?? filepath;
         const chunk = await fileReader_namespaceObject.fileReader.readFileFromSystem(targetFilepath, 'buffer');
         if (null === chunk) return null;

package/dist/cjs/plugins/compat/hooks.js

@@ -33,7 +33,6 @@ function getHookRunners(context) {
         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),

package/dist/cjs/plugins/compat/index.js

@@ -36,7 +36,6 @@ const external_hooks_js_namespaceObject = require("./hooks.js");
 const compatPlugin = ()=>({
         name: '@modern-js/server-compat',
         registryHooks: {
-            fallback: (0, plugin_namespaceObject.createAsyncHook)(),
             prepareWebServer: (0, plugin_namespaceObject.createAsyncPipelineHook)(),
             prepareApiServer: (0, plugin_namespaceObject.createAsyncPipelineHook)(),
             afterMatch: (0, plugin_namespaceObject.createAsyncPipelineHook)(),

package/dist/cjs/plugins/render/inject.js

@@ -38,23 +38,14 @@ const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig })=>({
             api.onPrepare(async ()=>{
                 const { distDirectory: pwd, routes, metaName } = api.getServerContext();
                 const config = api.getServerConfig();
-                const hooks = api.getHooks();
                 if (!routes) return;
-                const onFallback = async (reason, error, context)=>{
-                    await hooks.fallback.call({
-                        reason,
-                        error,
-                        context
-                    });
-                };
                 const getRenderHandlerOptions = {
                     pwd: pwd,
                     routes,
                     config,
                     metaName,
                     cacheConfig: cacheConfig,
-                    staticGenerate,
-                    onFallback
+                    staticGenerate
                 };
                 const render = await getRenderHandler(getRenderHandlerOptions);
                 api.updateServerContext({
@@ -64,7 +55,7 @@ const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig })=>({
             });
         }
     });
-async function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate, onFallback }) {
+async function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate }) {
     const ssrConfig = config.server?.ssr;
     const ssrByEntries = config.server?.ssrByEntries;
     const forceCSR = 'object' == typeof ssrConfig ? ssrConfig.forceCSR : false;
@@ -81,8 +72,7 @@ async function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, st
         forceCSR,
         forceCSRMap,
         nonce: config.security?.nonce,
-        metaName: metaName || 'modern-js',
-        onFallback
+        metaName: metaName || 'modern-js'
     });
     return render;
 }

package/dist/cjs/plugins/render/render.js

@@ -108,7 +108,7 @@ var __webpack_exports__ = {};
         delete _headers.cookie;
         return _headers;
     }
-    async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, forceCSRMap, config, onFallback }) {
+    async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, forceCSRMap, config }) {
         const router = getRouter(routes);
         return async (req, { monitors, nodeReq, templates, serverManifest, rscClientManifest, rscSSRManifest, rscServerManifest, locals, matchEntryName, matchPathname, loaderContext, serverContext, contextForceCSR, reporter })=>{
             const forMatchpathname = matchPathname ?? (0, index_js_namespaceObject.getPathname)(req);
@@ -116,13 +116,14 @@ var __webpack_exports__ = {};
             const framework = (0, universal_namespaceObject.cutNameByHyphen)(metaName || 'modern-js');
             const fallbackHeader = `x-${framework}-ssr-fallback`;
             let fallbackReason = null;
-            const fallbackContext = {
-                request: req,
-                monitors
-            };
-            const fallbackWrapper = async (reason, error)=>{
+            const fallbackWrapper = (reason)=>{
                 fallbackReason = reason;
-                return onFallback?.(reason, error, fallbackContext);
+                monitors?.warn('fallback to CSR reason: %o', {
+                    type: reason
+                });
+                monitors?.counter('ssr-fallback', {
+                    type: reason
+                });
             };
             if (!routeInfo) return new Response((0, index_js_namespaceObject.createErrorHtml)(404), {
                 status: 404,
@@ -218,7 +219,7 @@ var __webpack_exports__ = {};
             response = await (0, external_ssrRender_js_namespaceObject.ssrRender)(request, options);
         } catch (e) {
             options.onError(e, index_js_namespaceObject.ErrorDigest.ERENDER);
-            await fallbackWrapper('error', e);
+            fallbackWrapper('error');
             response = await csrRender(request, {
                 ...options,
                 html: injectFallbackReasonToHtml({

package/dist/cjs/plugins/render/serverActionHandler.js

@@ -32,6 +32,12 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const constants_namespaceObject = require("@modern-js/utils/universal/constants");
 const serverActionHandler = async (req, { serverManifest, routeInfo, rscClientManifest })=>{
+    if ('POST' !== req.method) return new Response('Method not allowed', {
+        status: 405,
+        headers: {
+            Allow: 'POST'
+        }
+    });
     const serverBundle = serverManifest?.renderBundles?.[routeInfo.entryName || constants_namespaceObject.MAIN_ENTRY_NAME];
     if (!serverBundle) return new Response('Cannot find server bundle for server action', {
         status: 500

package/dist/cjs/utils/error.js

@@ -30,69 +30,17 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     ErrorDigest: ()=>error_ErrorDigest,
     createErrorHtml: ()=>createErrorHtml,
-    createSafeFailureHttpResult: ()=>createSafeFailureHttpResult,
-    createSafeJsonFailureResponse: ()=>createSafeJsonFailureResponse,
-    getSafeFailureStatus: ()=>getSafeFailureStatus,
+    createSafeFailureHttpResult: ()=>safe_failure_namespaceObject.createSafeFailureHttpResult,
+    createSafeJsonFailureResponse: ()=>safe_failure_namespaceObject.createSafeJsonFailureResponse,
+    getSafeFailureStatus: ()=>safe_failure_namespaceObject.getSafeFailureStatus,
     onError: ()=>onError
 });
+const safe_failure_namespaceObject = require("@modern-js/runtime-extensions/safe-failure");
 const external_request_js_namespaceObject = require("./request.js");
 const ERROR_PAGE_TEXT = {
     404: 'This page could not be found.',
     500: 'Internal Server Error.'
 };
-const SAFE_FAILURE_MESSAGES = {
-    500: 'Internal Server Error',
-    503: 'Service Unavailable'
-};
-const SAFE_FAILURE_CODES = {
-    500: 'INTERNAL_SERVER_ERROR',
-    503: 'SERVICE_UNAVAILABLE'
-};
-const readErrorProperty = (error, key)=>{
-    if ('object' != typeof error || null === error || !(key in error)) return;
-    return error[key];
-};
-const normalizeFailureStatus = (value)=>{
-    if ('number' != typeof value || !Number.isInteger(value)) return;
-    return value >= 400 && value <= 599 ? value : void 0;
-};
-const normalizeRetryAfter = (value)=>{
-    if ('number' == typeof value && Number.isFinite(value) && value >= 0) return String(Math.ceil(value));
-    if ('string' == typeof value) {
-        const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : void 0;
-    }
-    if (value instanceof Date) return value.toUTCString();
-};
-const getSafeFailureStatus = (error)=>normalizeFailureStatus(readErrorProperty(error, 'status')) ?? normalizeFailureStatus(readErrorProperty(error, 'statusCode')) ?? 500;
-const createSafeFailureHttpResult = (error)=>{
-    const status = getSafeFailureStatus(error);
-    const retryAfter = 503 === status ? normalizeRetryAfter(readErrorProperty(error, 'retryAfter')) ?? normalizeRetryAfter(readErrorProperty(error, 'retryAfterSeconds')) ?? normalizeRetryAfter('number' == typeof readErrorProperty(error, 'retryAfterMs') ? readErrorProperty(error, 'retryAfterMs') / 1000 : void 0) : void 0;
-    return {
-        status,
-        body: {
-            success: false,
-            error: {
-                code: SAFE_FAILURE_CODES[status] ?? 'REQUEST_FAILED',
-                message: SAFE_FAILURE_MESSAGES[status] ?? 'Request failed',
-                status
-            }
-        },
-        headers: {
-            'content-type': 'application/json; charset=utf-8',
-            ...retryAfter ? {
-                'Retry-After': retryAfter
-            } : {}
-        }
-    };
-};
-const createSafeJsonFailureResponse = (error)=>{
-    const result = createSafeFailureHttpResult(error);
-    return new Response(JSON.stringify(result.body), {
-        status: result.status,
-        headers: result.headers
-    });
-};
 const createErrorHtml = (status)=>{
     const text = ERROR_PAGE_TEXT[status] || '';
     const title = `${status}: ${text}`;

package/dist/esm/adapters/node/node.mjs

@@ -25,7 +25,9 @@ const createWebRequest = (req, res, body)=>{
         signal: controller.signal
     };
     res.on('close', ()=>controller.abort('res closed'));
-    const url = `http://${req.headers.host}${req.url}`;
+    const protocol = 'encrypted' in req.socket && req.socket.encrypted ? 'https' : 'http';
+    const authority = req.headers[':authority'] ?? req.headers.host;
+    const url = `${protocol}://${authority}${req.url}`;
     const needsRequestBody = body || !('GET' === method || 'HEAD' === method);
     const cloneableReq = needsRequestBody ? cloneable_readable(req) : null;
     if (needsRequestBody) {

package/dist/esm/adapters/node/plugins/staticModuleFederation.mjs

@@ -11,7 +11,11 @@ const MODULE_FEDERATION_OPTIONAL_FILES = [
     'mf-stats.json'
 ];
 const trimLeadingSlash = (value)=>value.replace(/^\/+/, '');
-const getModuleFederationRequestPath = (pathname, pathPrefix)=>trimLeadingSlash(pathname.replace(pathPrefix, ()=>''));
+const getModuleFederationRequestPath = (pathname, pathPrefix)=>{
+    const normalizedPrefix = `/${trimLeadingSlash(pathPrefix)}`.replace(/\/+$/u, '');
+    const requestPath = normalizedPrefix && (pathname === normalizedPrefix || pathname.startsWith(`${normalizedPrefix}/`)) ? pathname.slice(normalizedPrefix.length) : pathname;
+    return trimLeadingSlash(requestPath);
+};
 const isModuleFederationManifestRequest = (requestPath)=>MODULE_FEDERATION_MANIFEST_FILES.includes(requestPath);
 const isBackendModuleFederationManifestRequest = (requestPath)=>requestPath === BACKEND_MODULE_FEDERATION_MANIFEST_FILE;
 const applyModuleFederationAssetHeaders = (c)=>{

package/dist/esm/adapters/node/plugins/staticPrecompressed.mjs

@@ -7,23 +7,32 @@ const PRE_COMPRESSED_SUPPORTED_ENCODINGS = [
     'br',
     'gzip'
 ];
+const QUALITY_VALUE_PATTERN = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/u;
 const parseAcceptEncoding = (value)=>value.split(',').map((item)=>item.trim()).filter(Boolean).map((item)=>{
         const [rawName, ...params] = item.split(';');
         const name = rawName.trim().toLowerCase();
         let q = 1;
+        let qualitySeen = false;
         for (const param of params){
             const [key, rawValue] = param.split('=').map((v)=>v.trim());
-            if ('q' !== key.toLowerCase() || null == rawValue) continue;
-            const parsedQ = Number(rawValue);
-            if (!Number.isNaN(parsedQ)) q = Math.max(0, Math.min(parsedQ, 1));
+            if ('q' === key.toLowerCase()) {
+                if (qualitySeen || null == rawValue || !QUALITY_VALUE_PATTERN.test(rawValue)) {
+                    q = 0;
+                    break;
+                }
+                qualitySeen = true;
+                q = Number(rawValue);
+            }
         }
         return {
             name,
             q
         };
     });
-const getAcceptedEncodings = (value)=>{
-    if (!value) return [];
+const getAcceptedRepresentations = (value)=>{
+    if (!value) return [
+        'identity'
+    ];
     const parsed = parseAcceptEncoding(value);
     const qualityByEncoding = new Map();
     let wildcardQuality;
@@ -39,10 +48,17 @@ const getAcceptedEncodings = (value)=>{
         if (void 0 !== explicit) return explicit;
         return wildcardQuality ?? 0;
     };
-    return PRE_COMPRESSED_SUPPORTED_ENCODINGS.map((encoding)=>({
-            encoding,
-            quality: getQuality(encoding)
-        })).filter((item)=>item.quality > 0).sort((a, b)=>b.quality - a.quality).map((item)=>item.encoding);
+    const identityQuality = qualityByEncoding.get('identity') ?? (0 === wildcardQuality ? 0 : 1);
+    return [
+        ...PRE_COMPRESSED_SUPPORTED_ENCODINGS.map((encoding)=>({
+                encoding,
+                quality: getQuality(encoding)
+            })),
+        {
+            encoding: 'identity',
+            quality: identityQuality
+        }
+    ].filter((item)=>item.quality > 0).sort((a, b)=>b.quality - a.quality).map((item)=>item.encoding);
 };
 const appendVaryHeader = (c, value)=>{
     const current = c.res.headers.get('Vary');
@@ -58,34 +74,38 @@ const resolvePreCompressedAsset = async (c, filepath)=>{
         fs.pathExists(gzipPath)
     ]);
     const hasVariant = hasBr || hasGzip;
-    if (!hasVariant) return {
-        selected: null,
-        hasVariant: false
-    };
-    const acceptedEncodings = getAcceptedEncodings(c.req.header('accept-encoding'));
-    for (const encoding of acceptedEncodings){
+    const acceptedRepresentations = getAcceptedRepresentations(c.req.header('accept-encoding'));
+    for (const encoding of acceptedRepresentations){
+        if ('identity' === encoding) return {
+            selected: null,
+            hasVariant,
+            acceptable: true
+        };
         if ('br' === encoding && hasBr) return {
             selected: {
                 filepath: brPath,
                 encoding
             },
-            hasVariant: true
+            hasVariant: true,
+            acceptable: true
         };
         if ('gzip' === encoding && hasGzip) return {
             selected: {
                 filepath: gzipPath,
                 encoding
             },
-            hasVariant: true
+            hasVariant: true,
+            acceptable: true
         };
     }
     return {
         selected: null,
-        hasVariant: true
+        hasVariant,
+        acceptable: false
     };
 };
 const applyPreCompressedAssetHeaders = (c, preCompressedAsset)=>{
-    if (preCompressedAsset.hasVariant) appendVaryHeader(c, 'Accept-Encoding');
+    if (preCompressedAsset.hasVariant || !preCompressedAsset.acceptable) appendVaryHeader(c, 'Accept-Encoding');
     if (preCompressedAsset.selected) c.header('Content-Encoding', preCompressedAsset.selected.encoding);
 };
 export { applyPreCompressedAssetHeaders, resolvePreCompressedAsset };

package/dist/esm/adapters/node/plugins/staticServing.mjs

@@ -4,11 +4,16 @@ import { getMimeType } from "hono/utils/mime";
 import path from "path";
 import { applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isBackendModuleFederationManifestRequest, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath } from "./staticModuleFederation.mjs";
 import { applyPreCompressedAssetHeaders, resolvePreCompressedAsset } from "./staticPrecompressed.mjs";
+const MODULE_FEDERATION_ASSET_REFRESH_INTERVAL_MS = 1000;
 const getStaticMimeType = (filename)=>getMimeType(filename) ?? ('.cjs' === path.extname(filename).toLowerCase() ? "text/javascript; charset=UTF-8" : void 0);
 const servePreCompressedPublicRouteAsset = async (c, pwd, route)=>{
     const { entryPath } = route;
     const originFilename = path.join(pwd, entryPath);
     const preCompressedAsset = await resolvePreCompressedAsset(c, originFilename);
+    if (!preCompressedAsset.acceptable) {
+        applyPreCompressedAssetHeaders(c, preCompressedAsset);
+        return c.body(null, 406);
+    }
     const filename = preCompressedAsset.selected?.filepath ?? originFilename;
     const data = await fileReader.readFile(filename, 'buffer');
     const mimeType = getStaticMimeType(originFilename);
@@ -55,6 +60,10 @@ const servePublicDirectoryAsset = async (c, pwd)=>{
     const originFilename = await resolvePublicDirectoryAsset(pwd, c.req.path);
     if (null === originFilename) return null;
     const preCompressedAsset = await resolvePreCompressedAsset(c, originFilename);
+    if (!preCompressedAsset.acceptable) {
+        applyPreCompressedAssetHeaders(c, preCompressedAsset);
+        return c.body(null, 406);
+    }
     const selectedFilename = preCompressedAsset.selected?.filepath ?? originFilename;
     const publicDirectory = await fs.realpath(path.join(pwd, 'public'));
     let realSelectedFilename;
@@ -75,10 +84,19 @@ const servePublicDirectoryAsset = async (c, pwd)=>{
     return c.body(body, 200);
 };
 const createModuleFederationStaticServing = ({ pwd, pathPrefix })=>{
-    let moduleFederationAssetsPromise = null;
+    let moduleFederationAssets = null;
+    let moduleFederationAssetsExpiresAt = 0;
+    let moduleFederationAssetsRefresh = null;
     const getModuleFederationAssets = async ()=>{
-        if (!moduleFederationAssetsPromise) moduleFederationAssetsPromise = getModuleFederationAssetList(pwd);
-        return moduleFederationAssetsPromise;
+        if (moduleFederationAssets && Date.now() < moduleFederationAssetsExpiresAt) return moduleFederationAssets;
+        if (!moduleFederationAssetsRefresh) moduleFederationAssetsRefresh = getModuleFederationAssetList(pwd).then((assets)=>{
+            moduleFederationAssets = assets;
+            moduleFederationAssetsExpiresAt = Date.now() + MODULE_FEDERATION_ASSET_REFRESH_INTERVAL_MS;
+            return assets;
+        }).finally(()=>{
+            moduleFederationAssetsRefresh = null;
+        });
+        return moduleFederationAssetsRefresh;
     };
     const resolveRequest = async (pathname)=>{
         const requestPath = getModuleFederationRequestPath(pathname, pathPrefix);
@@ -99,8 +117,13 @@ const createModuleFederationStaticServing = ({ pwd, pathPrefix })=>{
         const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
         const preCompressedAsset = canUsePreCompressed ? await resolvePreCompressedAsset(c, filepath) : {
             selected: null,
-            hasVariant: false
+            hasVariant: false,
+            acceptable: true
         };
+        if (!preCompressedAsset.acceptable) {
+            applyPreCompressedAssetHeaders(c, preCompressedAsset);
+            return c.body(null, 406);
+        }
         const targetFilepath = preCompressedAsset.selected?.filepath ?? filepath;
         const chunk = await fileReader.readFileFromSystem(targetFilepath, 'buffer');
         if (null === chunk) return null;

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

@@ -4,7 +4,6 @@ function getHookRunners(context) {
         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),

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

@@ -1,9 +1,8 @@
-import { createAsyncHook, createAsyncPipelineHook } from "@modern-js/plugin";
+import { 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(),