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

package/dist/esm/plugins/render/inject.mjs

@@ -5,23 +5,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({
@@ -31,7 +22,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;
@@ -48,8 +39,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/esm/plugins/render/render.mjs

@@ -67,7 +67,7 @@ function getHeadersWithoutCookie(headers) {
     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 ?? getPathname(req);
@@ -75,13 +75,14 @@ async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig
         const framework = 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(createErrorHtml(404), {
             status: 404,
@@ -177,7 +178,7 @@ async function renderHandler(request, options, mode, fallbackWrapper, framework)
         response = await ssrRender(request, options);
     } catch (e) {
         options.onError(e, ErrorDigest.ERENDER);
-        await fallbackWrapper('error', e);
+        fallbackWrapper('error');
         response = await csrRender(request, {
             ...options,
             html: injectFallbackReasonToHtml({

package/dist/esm/plugins/render/serverActionHandler.mjs

@@ -1,5 +1,11 @@
 import { MAIN_ENTRY_NAME } from "@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 || MAIN_ENTRY_NAME];
     if (!serverBundle) return new Response('Cannot find server bundle for server action', {
         status: 500

package/dist/esm/utils/error.mjs

@@ -3,59 +3,6 @@ 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}`;
@@ -103,4 +50,5 @@ function onError(digest, error, monitors, req) {
     else if (req) console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error}, req.url = ${req.url}, req.headers = ${JSON.stringify(headerData)}`);
     else console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error} `);
 }
-export { createErrorHtml, createSafeFailureHttpResult, createSafeJsonFailureResponse, error_ErrorDigest as ErrorDigest, getSafeFailureStatus, onError };
+export { createSafeFailureHttpResult, createSafeJsonFailureResponse, getSafeFailureStatus } from "@modern-js/runtime-extensions/safe-failure";
+export { createErrorHtml, error_ErrorDigest as ErrorDigest, onError };

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

@@ -26,7 +26,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-node/adapters/node/plugins/staticModuleFederation.mjs

@@ -12,7 +12,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-node/adapters/node/plugins/staticPrecompressed.mjs

@@ -8,23 +8,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;
@@ -40,10 +49,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');
@@ -59,34 +75,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-node/adapters/node/plugins/staticServing.mjs

@@ -5,11 +5,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);
@@ -56,6 +61,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;
@@ -76,10 +85,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);
@@ -100,8 +118,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-node/plugins/compat/hooks.mjs

@@ -5,7 +5,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-node/plugins/compat/index.mjs

@@ -1,10 +1,9 @@
 import "node:module";
-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(),

package/dist/esm-node/plugins/render/inject.mjs

@@ -6,23 +6,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({
@@ -32,7 +23,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;
@@ -49,8 +40,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/esm-node/plugins/render/render.mjs

@@ -68,7 +68,7 @@ function getHeadersWithoutCookie(headers) {
     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 ?? getPathname(req);
@@ -76,13 +76,14 @@ async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig
         const framework = 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(createErrorHtml(404), {
             status: 404,
@@ -178,7 +179,7 @@ async function renderHandler(request, options, mode, fallbackWrapper, framework)
         response = await ssrRender(request, options);
     } catch (e) {
         options.onError(e, ErrorDigest.ERENDER);
-        await fallbackWrapper('error', e);
+        fallbackWrapper('error');
         response = await csrRender(request, {
             ...options,
             html: injectFallbackReasonToHtml({

package/dist/esm-node/plugins/render/serverActionHandler.mjs

@@ -1,6 +1,12 @@
 import "node:module";
 import { MAIN_ENTRY_NAME } from "@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 || MAIN_ENTRY_NAME];
     if (!serverBundle) return new Response('Cannot find server bundle for server action', {
         status: 500

package/dist/esm-node/utils/error.mjs

@@ -4,59 +4,6 @@ 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}`;
@@ -104,4 +51,5 @@ function onError(digest, error, monitors, req) {
     else if (req) console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error}, req.url = ${req.url}, req.headers = ${JSON.stringify(headerData)}`);
     else console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error} `);
 }
-export { createErrorHtml, createSafeFailureHttpResult, createSafeJsonFailureResponse, error_ErrorDigest as ErrorDigest, getSafeFailureStatus, onError };
+export { createSafeFailureHttpResult, createSafeJsonFailureResponse, getSafeFailureStatus } from "@modern-js/runtime-extensions/safe-failure";
+export { createErrorHtml, error_ErrorDigest as ErrorDigest, onError };

package/dist/types/adapters/node/plugins/staticPrecompressed.d.ts

@@ -6,6 +6,7 @@ type ResolvePreCompressedAssetResult = {
         encoding: SupportedEncoding;
     } | null;
     hasVariant: boolean;
+    acceptable: boolean;
 };
 export declare const resolvePreCompressedAsset: (c: Parameters<Middleware>[0], filepath: string) => Promise<ResolvePreCompressedAssetResult>;
 export declare const applyPreCompressedAssetHeaders: (c: Parameters<Middleware>[0], preCompressedAsset: ResolvePreCompressedAssetResult) => void;

package/dist/types/adapters/node/plugins/staticServing.d.ts

@@ -10,16 +10,16 @@ type StaticServingOptions = {
     pwd: string;
     pathPrefix: string;
 };
-export declare const servePreCompressedPublicRouteAsset: (c: MiddlewareContext, pwd: string, route: ServerRoute) => Promise<(Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null>;
+export declare const servePreCompressedPublicRouteAsset: (c: MiddlewareContext, pwd: string, route: ServerRoute) => Promise<(Response & import("hono").TypedResponse<null, 406, "body">) | (Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null>;
 /**
  * Serves post-build convention assets generated under dist/public at their
  * root URL. This is intentionally independent of config/public and route.json:
  * the generator runs after the route manifest is built.
  */
-export declare const servePublicDirectoryAsset: (c: MiddlewareContext, pwd: string) => Promise<(Response & import("hono").TypedResponse<null, 200, "body">) | (Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null>;
+export declare const servePublicDirectoryAsset: (c: MiddlewareContext, pwd: string) => Promise<(Response & import("hono").TypedResponse<null, 200, "body">) | (Response & import("hono").TypedResponse<null, 406, "body">) | (Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null>;
 export declare const createModuleFederationStaticServing: ({ pwd, pathPrefix, }: StaticServingOptions) => {
     resolveRequest: (pathname: string) => Promise<StaticServingRequest | null>;
-    serveStaticHit: (c: MiddlewareContext, request: StaticServingRequest) => Promise<(Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null>;
-    serveModuleFederationAsset: (c: MiddlewareContext, request: StaticServingRequest) => Promise<(Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null> | null;
+    serveStaticHit: (c: MiddlewareContext, request: StaticServingRequest) => Promise<(Response & import("hono").TypedResponse<null, 406, "body">) | (Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null>;
+    serveModuleFederationAsset: (c: MiddlewareContext, request: StaticServingRequest) => Promise<(Response & import("hono").TypedResponse<null, 406, "body">) | (Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null> | null;
 };
 export {};

package/dist/types/plugins/render/inject.d.ts

@@ -4,4 +4,4 @@ export interface InjectRenderHandlerOptions {
     cacheConfig?: CacheConfig;
 }
 export declare const injectRenderHandlerPlugin: ({ staticGenerate, cacheConfig, }: InjectRenderHandlerOptions) => ServerPlugin;
-export declare function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate, onFallback, }: GetRenderHandlerOptions): Promise<Render>;
+export declare function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate, }: GetRenderHandlerOptions): Promise<Render>;

package/dist/types/plugins/render/render.d.ts

@@ -1,6 +1,6 @@
 import type { ServerRoute } from '@modern-js/types';
 import type { Router } from 'hono/router';
-import type { CacheConfig, OnFallback, Render, UserConfig } from '../../types';
+import type { CacheConfig, Render, UserConfig } from '../../types';
 import type { Params } from '../../types/requestHandler';
 interface CreateRenderOptions {
     pwd: string;
@@ -8,7 +8,6 @@ interface CreateRenderOptions {
     config: UserConfig;
     cacheConfig?: CacheConfig;
     staticGenerate?: boolean;
-    onFallback?: OnFallback;
     metaName?: string;
     forceCSR?: boolean;
     forceCSRMap?: Map<string, boolean>;
@@ -16,5 +15,5 @@ interface CreateRenderOptions {
 }
 type MatchedRoute = [ServerRoute | undefined, Params];
 export declare function matchRoute(router: Router<ServerRoute>, pathname: string, entryName?: string): MatchedRoute;
-export declare function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, forceCSRMap, config, onFallback, }: CreateRenderOptions): Promise<Render>;
+export declare function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, forceCSRMap, config, }: CreateRenderOptions): Promise<Render>;
 export {};

package/dist/types/types/plugins/base.d.ts

@@ -1,20 +1,9 @@
-import type { CacheOption, Container, HttpMethodDecider, MiddlewareContext, Monitors, ServerRoute } from '@modern-js/types';
+import type { CacheOption, Container, HttpMethodDecider, MiddlewareContext, ServerRoute } from '@modern-js/types';
 import type { Context, MiddlewareHandler } from 'hono';
 import type { UserConfig } from '../config';
 import type { Render } from '../render';
 import type { ServerPlugin } from './plugin';
 export type { FileChangeEvent, ResetEvent } from '@modern-js/plugin';
-export type FallbackReason = 'error' | 'header' | 'query' | `header,${string}`;
-export type FallbackContext = {
-    request: Request;
-    monitors?: Monitors;
-};
-export type FallbackInput = {
-    reason: FallbackReason;
-    error: unknown;
-    context?: FallbackContext;
-};
-export type OnFallback = (reason: FallbackReason, error?: unknown, context?: FallbackContext) => Promise<void>;
 export type APIServerStartInput = {
     pwd: string;
     prefix?: string;
@@ -44,7 +33,6 @@ export interface GetRenderHandlerOptions {
     pwd: string;
     routes: ServerRoute[];
     config: UserConfig;
-    onFallback?: OnFallback;
     cacheConfig?: CacheConfig;
     staticGenerate?: boolean;
     metaName?: string;

package/dist/types/types/plugins/index.d.ts

@@ -1,2 +1,2 @@
-export type { APIServerStartInput, CacheConfig, FallbackContext, FallbackInput, FallbackReason, FileChangeEvent, GetRenderHandlerOptions, MiddlewareObj, OnFallback, ServerConfig, ServerMiddleware, WebServerStartInput, } from './base';
+export type { APIServerStartInput, CacheConfig, FileChangeEvent, GetRenderHandlerOptions, MiddlewareObj, ServerConfig, ServerMiddleware, WebServerStartInput, } from './base';
 export * from './plugin';