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

package/dist/cjs/utils/warmup.js

@@ -1,11 +1,15 @@
 "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__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{
@@ -23,14 +27,14 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    warmup: ()=>warmup
-});
 function warmup(bundles) {
     bundles.forEach((bundle)=>{
         bundle && import(bundle).catch((_)=>{});
     });
 }
+__webpack_require__.d(__webpack_exports__, {
+    warmup: ()=>warmup
+});
 exports.warmup = __webpack_exports__.warmup;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "warmup"

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

@@ -2,7 +2,6 @@ import { fileReader } from "@modern-js/runtime-utils/fileReader";
 import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, compatibleRequire, fs, isProd } from "@modern-js/utils";
 import path from "path";
 import { uniqueKeyByRoute } from "../../../utils/index.mjs";
-import { collectDirectRemoteModuleFederationCss } from "./moduleFederationCss.mjs";
 async function getHtmlTemplates(pwd, routes) {
     const htmlRoutes = routes.filter((route)=>route.entryName);
     const htmls = await Promise.all(htmlRoutes.map(async (route)=>{
@@ -57,16 +56,12 @@ async function getServerManifest(pwd, routes, monitors) {
     const routeManifest = await compatibleRequire(routesManifestUri).catch((_)=>({}));
     const nestedRoutesJsonPath = path.join(pwd, NESTED_ROUTE_SPEC_FILE);
     const nestedRoutesJson = await compatibleRequire(nestedRoutesJsonPath).catch((_)=>({}));
-    const moduleFederationCssAssets = await collectDirectRemoteModuleFederationCss(pwd, {
-        monitors
-    });
     return {
         loaderBundles,
         renderBundles,
         loadableStats,
         routeManifest,
-        nestedRoutesJson,
-        moduleFederationCssAssets
+        nestedRoutesJson
     };
 }
 function injectServerManifest(pwd, routes, manifestPromise) {

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

@@ -4,6 +4,8 @@ import { getMimeType } from "hono/utils/mime";
 import path from "path";
 import { sortRoutes } from "../../../utils/index.mjs";
 import { getPublicDirPatterns } from "../../../utils/publicDir.mjs";
+import { applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath } from "./staticModuleFederation.mjs";
+import { applyPreCompressedAssetHeaders, resolvePreCompressedAsset } from "./staticPrecompressed.mjs";
 const serverStaticPlugin = ()=>({
         name: '@modern-js/plugin-server-static',
         setup (api) {
@@ -24,91 +26,6 @@ const serverStaticPlugin = ()=>({
             });
         }
     });
-const PRE_COMPRESSED_ASSET_EXTENSIONS = {
-    br: '.br',
-    gzip: '.gz'
-};
-const PRE_COMPRESSED_SUPPORTED_ENCODINGS = [
-    'br',
-    'gzip'
-];
-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;
-        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));
-        }
-        return {
-            name,
-            q
-        };
-    });
-const getAcceptedEncodings = (value)=>{
-    if (!value) return [];
-    const parsed = parseAcceptEncoding(value);
-    const qualityByEncoding = new Map();
-    let wildcardQuality;
-    for (const { name, q } of parsed){
-        if ('*' === name) {
-            wildcardQuality = q;
-            continue;
-        }
-        qualityByEncoding.set(name, q);
-    }
-    const getQuality = (encoding)=>{
-        const explicit = qualityByEncoding.get(encoding);
-        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 appendVaryHeader = (c, value)=>{
-    const current = c.res.headers.get('Vary');
-    if (!current) return void c.header('Vary', value);
-    const values = current.split(',').map((item)=>item.trim().toLowerCase()).filter(Boolean);
-    if (!values.includes(value.toLowerCase())) c.header('Vary', `${current}, ${value}`);
-};
-const resolvePreCompressedAsset = async (c, filepath)=>{
-    const brPath = `${filepath}${PRE_COMPRESSED_ASSET_EXTENSIONS.br}`;
-    const gzipPath = `${filepath}${PRE_COMPRESSED_ASSET_EXTENSIONS.gzip}`;
-    const [hasBr, hasGzip] = await Promise.all([
-        fs.pathExists(brPath),
-        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){
-        if ('br' === encoding && hasBr) return {
-            selected: {
-                filepath: brPath,
-                encoding
-            },
-            hasVariant: true
-        };
-        if ('gzip' === encoding && hasGzip) return {
-            selected: {
-                filepath: gzipPath,
-                encoding
-            },
-            hasVariant: true
-        };
-    }
-    return {
-        selected: null,
-        hasVariant: true
-    };
-};
 function createPublicMiddleware({ pwd, routes }) {
     return async (c, next)=>{
         const route = matchPublicRoute(c.req, routes);
@@ -125,8 +42,7 @@ function createPublicMiddleware({ pwd, routes }) {
                 Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
                     c.header(k, v);
                 });
-                if (preCompressedAsset.hasVariant) appendVaryHeader(c, 'Accept-Encoding');
-                if (preCompressedAsset.selected) c.header('Content-Encoding', preCompressedAsset.selected.encoding);
+                applyPreCompressedAssetHeaders(c, preCompressedAsset);
                 c.header('Content-Length', String(data.byteLength));
                 return c.body(body, 200);
             }
@@ -146,91 +62,6 @@ const extractPathname = (url)=>{
         return url;
     }
 };
-const MODULE_FEDERATION_MANIFEST_FILE = 'mf-manifest.json';
-const MODULE_FEDERATION_OPTIONAL_FILES = [
-    'mf-stats.json'
-];
-const trimLeadingSlash = (value)=>value.replace(/^\/+/, '');
-const joinModuleFederationAssetPath = (assetPath, assetName)=>{
-    if (!assetName) return '';
-    return trimLeadingSlash(path.posix.join(assetPath || '', assetName));
-};
-const appendModuleFederationAsset = (set, assetPath)=>{
-    if (!assetPath) return;
-    set.add(trimLeadingSlash(assetPath));
-};
-const appendModuleFederationAssets = (set, assets)=>{
-    assets?.js?.sync?.forEach((asset)=>appendModuleFederationAsset(set, asset));
-    assets?.js?.async?.forEach((asset)=>appendModuleFederationAsset(set, asset));
-    assets?.css?.sync?.forEach((asset)=>appendModuleFederationAsset(set, asset));
-    assets?.css?.async?.forEach((asset)=>appendModuleFederationAsset(set, asset));
-};
-const hasAbsoluteProtocol = (value)=>/^https?:\/\//i.test(value) || value.startsWith('//');
-const ensureLeadingSlash = (value)=>{
-    if ('' === value) return '/';
-    return value.startsWith('/') ? value : `/${value}`;
-};
-const ensureTrailingSlash = (value)=>value.endsWith('/') ? value : `${value}/`;
-const patchModuleFederationManifestPublicPath = (c, manifestBuffer, pathPrefix)=>{
-    try {
-        const manifest = JSON.parse(manifestBuffer.toString('utf-8'));
-        const publicPath = manifest.metaData?.publicPath;
-        if (!publicPath || hasAbsoluteProtocol(publicPath)) return manifestBuffer;
-        const requestURL = new URL(c.req.url);
-        const prefixPath = ensureTrailingSlash(ensureLeadingSlash(pathPrefix || '/'));
-        manifest.metaData = {
-            ...manifest.metaData,
-            publicPath: `${requestURL.origin}${prefixPath}`
-        };
-        return Buffer.from(JSON.stringify(manifest), 'utf-8');
-    } catch  {
-        return manifestBuffer;
-    }
-};
-const patchModuleFederationRemoteEntryPublicPath = (c, remoteEntryBuffer, pathPrefix)=>{
-    const requestURL = new URL(c.req.url);
-    const prefixPath = ensureTrailingSlash(ensureLeadingSlash(pathPrefix || '/'));
-    const publicPath = `${requestURL.origin}${prefixPath}`;
-    const source = remoteEntryBuffer.toString('utf-8');
-    const patched = source.replace(/__webpack_require__\.p\s*=\s*(['"`])[^'"`]*\1;/, `__webpack_require__.p = ${JSON.stringify(publicPath)};`).replace(/__rspack_require__\.p\s*=\s*(['"`])[^'"`]*\1;/, `__rspack_require__.p = ${JSON.stringify(publicPath)};`);
-    if (patched === source) return remoteEntryBuffer;
-    return Buffer.from(patched, 'utf-8');
-};
-const getModuleFederationAssetList = async (pwd)=>{
-    const assets = new Set();
-    const manifestPath = path.join(pwd, MODULE_FEDERATION_MANIFEST_FILE);
-    if (!await fs.pathExists(manifestPath)) return {
-        assets,
-        remoteEntry: null
-    };
-    assets.add(MODULE_FEDERATION_MANIFEST_FILE);
-    const manifestBuffer = await fileReader.readFileFromSystem(manifestPath, 'buffer');
-    if (null === manifestBuffer) return {
-        assets,
-        remoteEntry: null
-    };
-    for (const filename of MODULE_FEDERATION_OPTIONAL_FILES)if (await fs.pathExists(path.join(pwd, filename))) assets.add(filename);
-    let remoteEntryFile = null;
-    try {
-        const manifest = JSON.parse(manifestBuffer.toString('utf-8'));
-        const remoteEntry = joinModuleFederationAssetPath(manifest.metaData?.remoteEntry?.path, manifest.metaData?.remoteEntry?.name);
-        const dtsZip = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.zip);
-        const dtsApi = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.api);
-        if (remoteEntry) {
-            assets.add(remoteEntry);
-            remoteEntryFile = remoteEntry;
-        }
-        if (dtsZip) assets.add(dtsZip);
-        if (dtsApi) assets.add(dtsApi);
-        manifest.shared?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
-        manifest.remotes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
-        manifest.exposes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
-    } catch  {}
-    return {
-        assets,
-        remoteEntry: remoteEntryFile
-    };
-};
 function createStaticMiddleware(options) {
     const { pwd, routes } = options;
     const prefix = options.output.assetPrefix || '/';
@@ -271,14 +102,10 @@ function createStaticMiddleware(options) {
         return moduleFederationAssetsPromise;
     };
     const serveFile = async (c, filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false, requestPath = '')=>{
-        if (moduleFederationAsset) {
-            c.header('Access-Control-Allow-Origin', '*');
-            c.header('Access-Control-Allow-Headers', '*');
-            c.header('Access-Control-Allow-Methods', 'GET,HEAD,OPTIONS');
-        }
+        if (moduleFederationAsset) applyModuleFederationAssetHeaders(c);
         const mimeType = getMimeType(filepath);
         if (mimeType) c.header('Content-Type', mimeType);
-        const shouldPatchManifest = moduleFederationAsset && requestPath === MODULE_FEDERATION_MANIFEST_FILE;
+        const shouldPatchManifest = moduleFederationAsset && isModuleFederationManifestRequest(requestPath);
         const shouldPatchRemoteEntry = moduleFederationRemoteEntry;
         const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
         const preCompressedAsset = canUsePreCompressed ? await resolvePreCompressedAsset(c, filepath) : {
@@ -289,8 +116,7 @@ function createStaticMiddleware(options) {
         const chunk = await fileReader.readFileFromSystem(targetFilepath, 'buffer');
         if (null === chunk) return null;
         const responseChunk = shouldPatchManifest ? patchModuleFederationManifestPublicPath(c, chunk, pathPrefix) : shouldPatchRemoteEntry ? patchModuleFederationRemoteEntryPublicPath(c, chunk, pathPrefix) : chunk;
-        if (preCompressedAsset.hasVariant) appendVaryHeader(c, 'Accept-Encoding');
-        if (preCompressedAsset.selected) c.header('Content-Encoding', preCompressedAsset.selected.encoding);
+        applyPreCompressedAssetHeaders(c, preCompressedAsset);
         c.header('Content-Length', String(responseChunk.byteLength));
         const body = new Uint8Array(responseChunk.buffer, responseChunk.byteOffset, responseChunk.byteLength);
         return c.body(body, 200);
@@ -300,7 +126,7 @@ function createStaticMiddleware(options) {
         const pathname = c.req.path;
         if (pageRoute && '' === path.extname(pathname)) return next();
         const hit = staticPathRegExp.test(pathname);
-        const requestPath = trimLeadingSlash(pathname.replace(pathPrefix, ()=>''));
+        const requestPath = getModuleFederationRequestPath(pathname, pathPrefix);
         if (requestPath.includes('..')) return next();
         const moduleFederationAssetMeta = await getModuleFederationAssets();
         const isModuleFederationAsset = moduleFederationAssetMeta.assets.has(requestPath);

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

@@ -0,0 +1,96 @@
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+import { fs } from "@modern-js/utils";
+import path from "path";
+const MODULE_FEDERATION_MANIFEST_FILE = 'mf-manifest.json';
+const MODULE_FEDERATION_OPTIONAL_FILES = [
+    'mf-stats.json'
+];
+const trimLeadingSlash = (value)=>value.replace(/^\/+/, '');
+const getModuleFederationRequestPath = (pathname, pathPrefix)=>trimLeadingSlash(pathname.replace(pathPrefix, ()=>''));
+const isModuleFederationManifestRequest = (requestPath)=>requestPath === MODULE_FEDERATION_MANIFEST_FILE;
+const applyModuleFederationAssetHeaders = (c)=>{
+    c.header('Access-Control-Allow-Origin', '*');
+    c.header('Access-Control-Allow-Headers', '*');
+    c.header('Access-Control-Allow-Methods', 'GET,HEAD,OPTIONS');
+};
+const joinModuleFederationAssetPath = (assetPath, assetName)=>{
+    if (!assetName) return '';
+    return trimLeadingSlash(path.posix.join(assetPath || '', assetName));
+};
+const appendModuleFederationAsset = (set, assetPath)=>{
+    if (!assetPath) return;
+    set.add(trimLeadingSlash(assetPath));
+};
+const appendModuleFederationAssets = (set, assets)=>{
+    assets?.js?.sync?.forEach((asset)=>appendModuleFederationAsset(set, asset));
+    assets?.js?.async?.forEach((asset)=>appendModuleFederationAsset(set, asset));
+    assets?.css?.sync?.forEach((asset)=>appendModuleFederationAsset(set, asset));
+    assets?.css?.async?.forEach((asset)=>appendModuleFederationAsset(set, asset));
+};
+const hasAbsoluteProtocol = (value)=>/^https?:\/\//i.test(value) || value.startsWith('//');
+const ensureLeadingSlash = (value)=>{
+    if ('' === value) return '/';
+    return value.startsWith('/') ? value : `/${value}`;
+};
+const ensureTrailingSlash = (value)=>value.endsWith('/') ? value : `${value}/`;
+const patchModuleFederationManifestPublicPath = (c, manifestBuffer, pathPrefix)=>{
+    try {
+        const manifest = JSON.parse(manifestBuffer.toString('utf-8'));
+        const publicPath = manifest.metaData?.publicPath;
+        if (!publicPath || hasAbsoluteProtocol(publicPath)) return manifestBuffer;
+        const requestURL = new URL(c.req.url);
+        const prefixPath = ensureTrailingSlash(ensureLeadingSlash(pathPrefix || '/'));
+        manifest.metaData = {
+            ...manifest.metaData,
+            publicPath: `${requestURL.origin}${prefixPath}`
+        };
+        return Buffer.from(JSON.stringify(manifest), 'utf-8');
+    } catch  {
+        return manifestBuffer;
+    }
+};
+const patchModuleFederationRemoteEntryPublicPath = (c, remoteEntryBuffer, pathPrefix)=>{
+    const requestURL = new URL(c.req.url);
+    const prefixPath = ensureTrailingSlash(ensureLeadingSlash(pathPrefix || '/'));
+    const publicPath = `${requestURL.origin}${prefixPath}`;
+    const source = remoteEntryBuffer.toString('utf-8');
+    const patched = source.replace(/__webpack_require__\.p\s*=\s*(['"`])[^'"`]*\1;/, `__webpack_require__.p = ${JSON.stringify(publicPath)};`).replace(/__rspack_require__\.p\s*=\s*(['"`])[^'"`]*\1;/, `__rspack_require__.p = ${JSON.stringify(publicPath)};`);
+    if (patched === source) return remoteEntryBuffer;
+    return Buffer.from(patched, 'utf-8');
+};
+const getModuleFederationAssetList = async (pwd)=>{
+    const assets = new Set();
+    const manifestPath = path.join(pwd, MODULE_FEDERATION_MANIFEST_FILE);
+    if (!await fs.pathExists(manifestPath)) return {
+        assets,
+        remoteEntry: null
+    };
+    assets.add(MODULE_FEDERATION_MANIFEST_FILE);
+    const manifestBuffer = await fileReader.readFileFromSystem(manifestPath, 'buffer');
+    if (null === manifestBuffer) return {
+        assets,
+        remoteEntry: null
+    };
+    for (const filename of MODULE_FEDERATION_OPTIONAL_FILES)if (await fs.pathExists(path.join(pwd, filename))) assets.add(filename);
+    let remoteEntryFile = null;
+    try {
+        const manifest = JSON.parse(manifestBuffer.toString('utf-8'));
+        const remoteEntry = joinModuleFederationAssetPath(manifest.metaData?.remoteEntry?.path, manifest.metaData?.remoteEntry?.name);
+        const dtsZip = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.zip);
+        const dtsApi = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.api);
+        if (remoteEntry) {
+            assets.add(remoteEntry);
+            remoteEntryFile = remoteEntry;
+        }
+        if (dtsZip) assets.add(dtsZip);
+        if (dtsApi) assets.add(dtsApi);
+        manifest.shared?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
+        manifest.remotes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
+        manifest.exposes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
+    } catch  {}
+    return {
+        assets,
+        remoteEntry: remoteEntryFile
+    };
+};
+export { MODULE_FEDERATION_MANIFEST_FILE, applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath, trimLeadingSlash };

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

@@ -0,0 +1,91 @@
+import { fs } from "@modern-js/utils";
+const PRE_COMPRESSED_ASSET_EXTENSIONS = {
+    br: '.br',
+    gzip: '.gz'
+};
+const PRE_COMPRESSED_SUPPORTED_ENCODINGS = [
+    'br',
+    'gzip'
+];
+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;
+        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));
+        }
+        return {
+            name,
+            q
+        };
+    });
+const getAcceptedEncodings = (value)=>{
+    if (!value) return [];
+    const parsed = parseAcceptEncoding(value);
+    const qualityByEncoding = new Map();
+    let wildcardQuality;
+    for (const { name, q } of parsed){
+        if ('*' === name) {
+            wildcardQuality = q;
+            continue;
+        }
+        qualityByEncoding.set(name, q);
+    }
+    const getQuality = (encoding)=>{
+        const explicit = qualityByEncoding.get(encoding);
+        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 appendVaryHeader = (c, value)=>{
+    const current = c.res.headers.get('Vary');
+    if (!current) return void c.header('Vary', value);
+    const values = current.split(',').map((item)=>item.trim().toLowerCase()).filter(Boolean);
+    if (!values.includes(value.toLowerCase())) c.header('Vary', `${current}, ${value}`);
+};
+const resolvePreCompressedAsset = async (c, filepath)=>{
+    const brPath = `${filepath}${PRE_COMPRESSED_ASSET_EXTENSIONS.br}`;
+    const gzipPath = `${filepath}${PRE_COMPRESSED_ASSET_EXTENSIONS.gzip}`;
+    const [hasBr, hasGzip] = await Promise.all([
+        fs.pathExists(brPath),
+        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){
+        if ('br' === encoding && hasBr) return {
+            selected: {
+                filepath: brPath,
+                encoding
+            },
+            hasVariant: true
+        };
+        if ('gzip' === encoding && hasGzip) return {
+            selected: {
+                filepath: gzipPath,
+                encoding
+            },
+            hasVariant: true
+        };
+    }
+    return {
+        selected: null,
+        hasVariant: true
+    };
+};
+const applyPreCompressedAssetHeaders = (c, preCompressedAsset)=>{
+    if (preCompressedAsset.hasVariant) appendVaryHeader(c, 'Accept-Encoding');
+    if (preCompressedAsset.selected) c.header('Content-Encoding', preCompressedAsset.selected.encoding);
+};
+export { appendVaryHeader, applyPreCompressedAssetHeaders, resolvePreCompressedAsset };

package/dist/esm/index.mjs

@@ -8,5 +8,5 @@ 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 { ErrorDigest, createErrorHtml, createSafeFailureHttpResult, createSafeJsonFailureResponse, getSafeFailureStatus, onError } from "./utils/index.mjs";
 export { getPublicDirConfig, getPublicDirPatterns, getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath, resolvePublicDirPaths } from "./utils/publicDir.mjs";

package/dist/esm/plugins/default.mjs

@@ -4,7 +4,6 @@ import { initMonitorsPlugin, injectServerTiming, injectloggerPlugin } from "./mo
 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: ()=>()=>{}
@@ -15,7 +14,6 @@ function createDefaultPlugins(options = {}) {
         compatPlugin(),
         logPlugin(),
         initMonitorsPlugin(),
-        injectTelemetryPlugin(),
         injectRenderHandlerPlugin(options),
         injectloggerPlugin(options.logger ? options.logger : createSilenceLogger()),
         injectServerTiming(),

package/dist/esm/plugins/index.mjs

@@ -1,6 +1,4 @@
 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";
@@ -8,4 +6,3 @@ 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/plugins/render/inject.mjs

@@ -7,10 +7,11 @@ const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig })=>({
                 const config = api.getServerConfig();
                 const hooks = api.getHooks();
                 if (!routes) return;
-                const onFallback = async (reason, error)=>{
+                const onFallback = async (reason, error, context)=>{
                     await hooks.fallback.call({
                         reason,
-                        error
+                        error,
+                        context
                     });
                 };
                 const getRenderHandlerOptions = {

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

@@ -10,7 +10,7 @@ import { ssrRender } from "./ssrRender.mjs";
 import { __webpack_require__ } from "../../rslib-runtime.mjs";
 import * as __rspack_external__modern_js_runtime_utils_router_2aa8d96f from "@modern-js/runtime-utils/router";
 __webpack_require__.add({
-    "@modern-js/runtime-utils/router" (module) {
+    2420 (module) {
         module.exports = __rspack_external__modern_js_runtime_utils_router_2aa8d96f;
     }
 });
@@ -75,9 +75,13 @@ 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)=>{
             fallbackReason = reason;
-            return onFallback?.(reason, error);
+            return onFallback?.(reason, error, fallbackContext);
         };
         if (!routeInfo) return new Response(createErrorHtml(404), {
             status: 404,
@@ -158,7 +162,7 @@ async function renderHandler(request, options, mode, fallbackWrapper, framework)
         const { nestedRoutesJson } = serverManifest;
         const routes = nestedRoutesJson?.[options.routeInfo.entryName];
         if (routes) {
-            const { matchRoutes } = __webpack_require__("@modern-js/runtime-utils/router");
+            const { matchRoutes } = __webpack_require__(2420);
             const url = new URL(request.url);
             const matchedRoutes = matchRoutes(routes, url.pathname, options.routeInfo.urlPath);
             if (matchedRoutes) {

package/dist/esm/utils/error.mjs

@@ -3,6 +3,59 @@ 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}`;
@@ -50,4 +103,4 @@ 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, error_ErrorDigest as ErrorDigest, onError };
+export { createErrorHtml, createSafeFailureHttpResult, createSafeJsonFailureResponse, error_ErrorDigest as ErrorDigest, getSafeFailureStatus, onError };