@bleedingdev/modern-js-server-core 3.5.0-ultramodern.36 → 3.5.0-ultramodern.38

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

@@ -41,15 +41,11 @@ __webpack_require__.d(__webpack_exports__, {
     createStaticMiddleware: ()=>createStaticMiddleware,
     serverStaticPlugin: ()=>serverStaticPlugin
 });
-const fileReader_namespaceObject = require("@modern-js/runtime-utils/fileReader");
-const utils_namespaceObject = require("@modern-js/utils");
-const mime_namespaceObject = require("hono/utils/mime");
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const index_js_namespaceObject = require("../../../utils/index.js");
 const publicDir_js_namespaceObject = require("../../../utils/publicDir.js");
-const external_staticModuleFederation_js_namespaceObject = require("./staticModuleFederation.js");
-const external_staticPrecompressed_js_namespaceObject = require("./staticPrecompressed.js");
+const external_staticServing_js_namespaceObject = require("./staticServing.js");
 const serverStaticPlugin = ()=>({
         name: '@modern-js/plugin-server-static',
         setup (api) {
@@ -74,22 +70,8 @@ function createPublicMiddleware({ pwd, routes }) {
     return async (c, next)=>{
         const route = matchPublicRoute(c.req, routes);
         if (route) {
-            const { entryPath } = route;
-            const originFilename = external_path_default().join(pwd, entryPath);
-            const preCompressedAsset = await (0, external_staticPrecompressed_js_namespaceObject.resolvePreCompressedAsset)(c, originFilename);
-            const filename = preCompressedAsset.selected?.filepath ?? originFilename;
-            const data = await fileReader_namespaceObject.fileReader.readFile(filename, 'buffer');
-            const mimeType = (0, mime_namespaceObject.getMimeType)(originFilename);
-            if (null !== data) {
-                const body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-                if (mimeType) c.header('Content-Type', mimeType);
-                Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
-                    c.header(k, v);
-                });
-                (0, external_staticPrecompressed_js_namespaceObject.applyPreCompressedAssetHeaders)(c, preCompressedAsset);
-                c.header('Content-Length', String(data.byteLength));
-                return c.body(body, 200);
-            }
+            const response = await (0, external_staticServing_js_namespaceObject.servePreCompressedPublicRouteAsset)(c, pwd, route);
+            if (null !== response) return response;
         }
         return await next();
     };
@@ -97,10 +79,6 @@ function createPublicMiddleware({ pwd, routes }) {
 function matchPublicRoute(req, routes) {
     for (const route of routes.sort(index_js_namespaceObject.sortRoutes))if (!route.isSSR && route.entryPath.startsWith('public') && req.path.startsWith(route.urlPath)) return route;
 }
-const isPathInside = (target, root)=>{
-    const relative = external_path_default().relative(external_path_default().resolve(root), external_path_default().resolve(target));
-    return '' === relative || !relative.startsWith(`..${external_path_default().sep}`) && '..' !== relative && !external_path_default().isAbsolute(relative);
-};
 const extractPathname = (url)=>{
     try {
         if (url.includes('://')) return new URL(url).pathname || '/';
@@ -144,55 +122,24 @@ function createStaticMiddleware(options) {
         pwd,
         routes: routes || []
     });
-    let moduleFederationAssetsPromise = null;
-    const getModuleFederationAssets = async ()=>{
-        if (!moduleFederationAssetsPromise) moduleFederationAssetsPromise = (0, external_staticModuleFederation_js_namespaceObject.getModuleFederationAssetList)(pwd);
-        return moduleFederationAssetsPromise;
-    };
-    const serveFile = async (c, filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false, requestPath = '')=>{
-        if (moduleFederationAsset) (0, external_staticModuleFederation_js_namespaceObject.applyModuleFederationAssetHeaders)(c);
-        const mimeType = (0, mime_namespaceObject.getMimeType)(filepath);
-        if (mimeType) c.header('Content-Type', mimeType);
-        const shouldPatchManifest = moduleFederationAsset && (0, external_staticModuleFederation_js_namespaceObject.isModuleFederationManifestRequest)(requestPath);
-        const shouldPatchRemoteEntry = moduleFederationRemoteEntry;
-        const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
-        const preCompressedAsset = canUsePreCompressed ? await (0, external_staticPrecompressed_js_namespaceObject.resolvePreCompressedAsset)(c, filepath) : {
-            selected: null,
-            hasVariant: false
-        };
-        const targetFilepath = preCompressedAsset.selected?.filepath ?? filepath;
-        const chunk = await fileReader_namespaceObject.fileReader.readFileFromSystem(targetFilepath, 'buffer');
-        if (null === chunk) return null;
-        const responseChunk = shouldPatchManifest ? (0, external_staticModuleFederation_js_namespaceObject.patchModuleFederationManifestPublicPath)(c, chunk, pathPrefix) : shouldPatchRemoteEntry ? (0, external_staticModuleFederation_js_namespaceObject.patchModuleFederationRemoteEntryPublicPath)(c, chunk, pathPrefix) : chunk;
-        (0, external_staticPrecompressed_js_namespaceObject.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);
-    };
+    const moduleFederationStaticServing = (0, external_staticServing_js_namespaceObject.createModuleFederationStaticServing)({
+        pwd,
+        pathPrefix
+    });
     return async (c, next)=>{
         const pageRoute = c.get('route');
         const pathname = c.req.path;
         if (pageRoute && '' === external_path_default().extname(pathname)) return next();
         const hit = staticPathRegExp.test(pathname);
-        const requestPath = (0, external_staticModuleFederation_js_namespaceObject.getModuleFederationRequestPath)(pathname, pathPrefix);
-        if (requestPath.includes('..')) return next();
-        const moduleFederationAssetMeta = await getModuleFederationAssets();
-        const isModuleFederationAsset = moduleFederationAssetMeta.assets.has(requestPath);
-        const isModuleFederationRemoteEntry = moduleFederationAssetMeta.remoteEntries.has(requestPath);
-        const serveByPath = async (filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false)=>{
-            if (!isPathInside(filepath, pwd)) return null;
-            if (!await utils_namespaceObject.fs.pathExists(filepath)) return null;
-            return serveFile(c, filepath, moduleFederationAsset, moduleFederationRemoteEntry, requestPath);
-        };
+        const staticServingRequest = await moduleFederationStaticServing.resolveRequest(pathname);
+        if (null === staticServingRequest) return next();
         if (hit) {
-            const response = await serveByPath(external_path_default().join(pwd, requestPath), isModuleFederationAsset, isModuleFederationRemoteEntry);
+            const response = await moduleFederationStaticServing.serveStaticHit(c, staticServingRequest);
             if (null !== response) return response;
             return next();
         }
-        if (isModuleFederationAsset) {
-            const response = await serveByPath(external_path_default().join(pwd, requestPath), true, isModuleFederationRemoteEntry);
-            if (null !== response) return response;
-        }
+        const moduleFederationResponse = await moduleFederationStaticServing.serveModuleFederationAsset(c, staticServingRequest);
+        if (null !== moduleFederationResponse) return moduleFederationResponse;
         return publicMiddleware(c, next);
     };
 }

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

@@ -37,15 +37,13 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    BACKEND_MODULE_FEDERATION_MANIFEST_FILE: ()=>BACKEND_MODULE_FEDERATION_MANIFEST_FILE,
     MODULE_FEDERATION_MANIFEST_FILE: ()=>MODULE_FEDERATION_MANIFEST_FILE,
     applyModuleFederationAssetHeaders: ()=>applyModuleFederationAssetHeaders,
     getModuleFederationAssetList: ()=>getModuleFederationAssetList,
     getModuleFederationRequestPath: ()=>getModuleFederationRequestPath,
     isModuleFederationManifestRequest: ()=>isModuleFederationManifestRequest,
     patchModuleFederationManifestPublicPath: ()=>patchModuleFederationManifestPublicPath,
-    patchModuleFederationRemoteEntryPublicPath: ()=>patchModuleFederationRemoteEntryPublicPath,
-    trimLeadingSlash: ()=>trimLeadingSlash
+    patchModuleFederationRemoteEntryPublicPath: ()=>patchModuleFederationRemoteEntryPublicPath
 });
 const fileReader_namespaceObject = require("@modern-js/runtime-utils/fileReader");
 const utils_namespaceObject = require("@modern-js/utils");
@@ -146,7 +144,6 @@ const getModuleFederationAssetList = async (pwd)=>{
         remoteEntries
     };
 };
-exports.BACKEND_MODULE_FEDERATION_MANIFEST_FILE = __webpack_exports__.BACKEND_MODULE_FEDERATION_MANIFEST_FILE;
 exports.MODULE_FEDERATION_MANIFEST_FILE = __webpack_exports__.MODULE_FEDERATION_MANIFEST_FILE;
 exports.applyModuleFederationAssetHeaders = __webpack_exports__.applyModuleFederationAssetHeaders;
 exports.getModuleFederationAssetList = __webpack_exports__.getModuleFederationAssetList;
@@ -154,17 +151,14 @@ exports.getModuleFederationRequestPath = __webpack_exports__.getModuleFederation
 exports.isModuleFederationManifestRequest = __webpack_exports__.isModuleFederationManifestRequest;
 exports.patchModuleFederationManifestPublicPath = __webpack_exports__.patchModuleFederationManifestPublicPath;
 exports.patchModuleFederationRemoteEntryPublicPath = __webpack_exports__.patchModuleFederationRemoteEntryPublicPath;
-exports.trimLeadingSlash = __webpack_exports__.trimLeadingSlash;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "BACKEND_MODULE_FEDERATION_MANIFEST_FILE",
     "MODULE_FEDERATION_MANIFEST_FILE",
     "applyModuleFederationAssetHeaders",
     "getModuleFederationAssetList",
     "getModuleFederationRequestPath",
     "isModuleFederationManifestRequest",
     "patchModuleFederationManifestPublicPath",
-    "patchModuleFederationRemoteEntryPublicPath",
-    "trimLeadingSlash"
+    "patchModuleFederationRemoteEntryPublicPath"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -28,7 +28,6 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    appendVaryHeader: ()=>appendVaryHeader,
     applyPreCompressedAssetHeaders: ()=>applyPreCompressedAssetHeaders,
     resolvePreCompressedAsset: ()=>resolvePreCompressedAsset
 });
@@ -122,11 +121,9 @@ const applyPreCompressedAssetHeaders = (c, preCompressedAsset)=>{
     if (preCompressedAsset.hasVariant) appendVaryHeader(c, 'Accept-Encoding');
     if (preCompressedAsset.selected) c.header('Content-Encoding', preCompressedAsset.selected.encoding);
 };
-exports.appendVaryHeader = __webpack_exports__.appendVaryHeader;
 exports.applyPreCompressedAssetHeaders = __webpack_exports__.applyPreCompressedAssetHeaders;
 exports.resolvePreCompressedAsset = __webpack_exports__.resolvePreCompressedAsset;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "appendVaryHeader",
     "applyPreCompressedAssetHeaders",
     "resolvePreCompressedAsset"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

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

@@ -0,0 +1,131 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, 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");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createModuleFederationStaticServing: ()=>createModuleFederationStaticServing,
+    servePreCompressedPublicRouteAsset: ()=>servePreCompressedPublicRouteAsset
+});
+const fileReader_namespaceObject = require("@modern-js/runtime-utils/fileReader");
+const utils_namespaceObject = require("@modern-js/utils");
+const mime_namespaceObject = require("hono/utils/mime");
+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 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);
+    const filename = preCompressedAsset.selected?.filepath ?? originFilename;
+    const data = await fileReader_namespaceObject.fileReader.readFile(filename, 'buffer');
+    const mimeType = (0, mime_namespaceObject.getMimeType)(originFilename);
+    if (null === data) return null;
+    const body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    if (mimeType) c.header('Content-Type', mimeType);
+    Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
+        c.header(k, v);
+    });
+    (0, external_staticPrecompressed_js_namespaceObject.applyPreCompressedAssetHeaders)(c, preCompressedAsset);
+    c.header('Content-Length', String(data.byteLength));
+    return c.body(body, 200);
+};
+const isPathInside = (target, root)=>{
+    const relative = external_path_default().relative(external_path_default().resolve(root), external_path_default().resolve(target));
+    return '' === relative || !relative.startsWith(`..${external_path_default().sep}`) && '..' !== relative && !external_path_default().isAbsolute(relative);
+};
+const createModuleFederationStaticServing = ({ pwd, pathPrefix })=>{
+    let moduleFederationAssetsPromise = null;
+    const getModuleFederationAssets = async ()=>{
+        if (!moduleFederationAssetsPromise) moduleFederationAssetsPromise = (0, external_staticModuleFederation_js_namespaceObject.getModuleFederationAssetList)(pwd);
+        return moduleFederationAssetsPromise;
+    };
+    const resolveRequest = async (pathname)=>{
+        const requestPath = (0, external_staticModuleFederation_js_namespaceObject.getModuleFederationRequestPath)(pathname, pathPrefix);
+        if (requestPath.includes('..')) return null;
+        const moduleFederationAssetMeta = await getModuleFederationAssets();
+        return {
+            requestPath,
+            isModuleFederationAsset: moduleFederationAssetMeta.assets.has(requestPath),
+            isModuleFederationRemoteEntry: moduleFederationAssetMeta.remoteEntries.has(requestPath)
+        };
+    };
+    const serveFile = async (c, filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false, requestPath = '')=>{
+        if (moduleFederationAsset) (0, external_staticModuleFederation_js_namespaceObject.applyModuleFederationAssetHeaders)(c);
+        const mimeType = (0, mime_namespaceObject.getMimeType)(filepath);
+        if (mimeType) c.header('Content-Type', mimeType);
+        const shouldPatchManifest = moduleFederationAsset && (0, external_staticModuleFederation_js_namespaceObject.isModuleFederationManifestRequest)(requestPath);
+        const shouldPatchRemoteEntry = moduleFederationRemoteEntry;
+        const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
+        const preCompressedAsset = canUsePreCompressed ? await (0, external_staticPrecompressed_js_namespaceObject.resolvePreCompressedAsset)(c, filepath) : {
+            selected: null,
+            hasVariant: false
+        };
+        const targetFilepath = preCompressedAsset.selected?.filepath ?? filepath;
+        const chunk = await fileReader_namespaceObject.fileReader.readFileFromSystem(targetFilepath, 'buffer');
+        if (null === chunk) return null;
+        const responseChunk = shouldPatchManifest ? (0, external_staticModuleFederation_js_namespaceObject.patchModuleFederationManifestPublicPath)(c, chunk, pathPrefix) : shouldPatchRemoteEntry ? (0, external_staticModuleFederation_js_namespaceObject.patchModuleFederationRemoteEntryPublicPath)(c, chunk, pathPrefix) : chunk;
+        (0, external_staticPrecompressed_js_namespaceObject.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);
+    };
+    const serveByPath = async (c, filepath, request, moduleFederationAsset = false, moduleFederationRemoteEntry = false)=>{
+        if (!isPathInside(filepath, pwd)) return null;
+        if (!await utils_namespaceObject.fs.pathExists(filepath)) return null;
+        return serveFile(c, filepath, moduleFederationAsset, moduleFederationRemoteEntry, request.requestPath);
+    };
+    const serveStaticHit = (c, request)=>serveByPath(c, external_path_default().join(pwd, request.requestPath), request, request.isModuleFederationAsset, request.isModuleFederationRemoteEntry);
+    const serveModuleFederationAsset = (c, request)=>{
+        if (!request.isModuleFederationAsset) return null;
+        return serveByPath(c, external_path_default().join(pwd, request.requestPath), request, true, request.isModuleFederationRemoteEntry);
+    };
+    return {
+        resolveRequest,
+        serveStaticHit,
+        serveModuleFederationAsset
+    };
+};
+exports.createModuleFederationStaticServing = __webpack_exports__.createModuleFederationStaticServing;
+exports.servePreCompressedPublicRouteAsset = __webpack_exports__.servePreCompressedPublicRouteAsset;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createModuleFederationStaticServing",
+    "servePreCompressedPublicRouteAsset"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -1,11 +1,7 @@
-import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { fs } from "@modern-js/utils";
-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";
+import { createModuleFederationStaticServing, servePreCompressedPublicRouteAsset } from "./staticServing.mjs";
 const serverStaticPlugin = ()=>({
         name: '@modern-js/plugin-server-static',
         setup (api) {
@@ -30,22 +26,8 @@ function createPublicMiddleware({ pwd, routes }) {
     return async (c, next)=>{
         const route = matchPublicRoute(c.req, routes);
         if (route) {
-            const { entryPath } = route;
-            const originFilename = path.join(pwd, entryPath);
-            const preCompressedAsset = await resolvePreCompressedAsset(c, originFilename);
-            const filename = preCompressedAsset.selected?.filepath ?? originFilename;
-            const data = await fileReader.readFile(filename, 'buffer');
-            const mimeType = getMimeType(originFilename);
-            if (null !== data) {
-                const body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-                if (mimeType) c.header('Content-Type', mimeType);
-                Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
-                    c.header(k, v);
-                });
-                applyPreCompressedAssetHeaders(c, preCompressedAsset);
-                c.header('Content-Length', String(data.byteLength));
-                return c.body(body, 200);
-            }
+            const response = await servePreCompressedPublicRouteAsset(c, pwd, route);
+            if (null !== response) return response;
         }
         return await next();
     };
@@ -53,10 +35,6 @@ function createPublicMiddleware({ pwd, routes }) {
 function matchPublicRoute(req, routes) {
     for (const route of routes.sort(sortRoutes))if (!route.isSSR && route.entryPath.startsWith('public') && req.path.startsWith(route.urlPath)) return route;
 }
-const isPathInside = (target, root)=>{
-    const relative = path.relative(path.resolve(root), path.resolve(target));
-    return '' === relative || !relative.startsWith(`..${path.sep}`) && '..' !== relative && !path.isAbsolute(relative);
-};
 const extractPathname = (url)=>{
     try {
         if (url.includes('://')) return new URL(url).pathname || '/';
@@ -100,55 +78,24 @@ function createStaticMiddleware(options) {
         pwd,
         routes: routes || []
     });
-    let moduleFederationAssetsPromise = null;
-    const getModuleFederationAssets = async ()=>{
-        if (!moduleFederationAssetsPromise) moduleFederationAssetsPromise = getModuleFederationAssetList(pwd);
-        return moduleFederationAssetsPromise;
-    };
-    const serveFile = async (c, filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false, requestPath = '')=>{
-        if (moduleFederationAsset) applyModuleFederationAssetHeaders(c);
-        const mimeType = getMimeType(filepath);
-        if (mimeType) c.header('Content-Type', mimeType);
-        const shouldPatchManifest = moduleFederationAsset && isModuleFederationManifestRequest(requestPath);
-        const shouldPatchRemoteEntry = moduleFederationRemoteEntry;
-        const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
-        const preCompressedAsset = canUsePreCompressed ? await resolvePreCompressedAsset(c, filepath) : {
-            selected: null,
-            hasVariant: false
-        };
-        const targetFilepath = preCompressedAsset.selected?.filepath ?? filepath;
-        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;
-        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);
-    };
+    const moduleFederationStaticServing = createModuleFederationStaticServing({
+        pwd,
+        pathPrefix
+    });
     return async (c, next)=>{
         const pageRoute = c.get('route');
         const pathname = c.req.path;
         if (pageRoute && '' === path.extname(pathname)) return next();
         const hit = staticPathRegExp.test(pathname);
-        const requestPath = getModuleFederationRequestPath(pathname, pathPrefix);
-        if (requestPath.includes('..')) return next();
-        const moduleFederationAssetMeta = await getModuleFederationAssets();
-        const isModuleFederationAsset = moduleFederationAssetMeta.assets.has(requestPath);
-        const isModuleFederationRemoteEntry = moduleFederationAssetMeta.remoteEntries.has(requestPath);
-        const serveByPath = async (filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false)=>{
-            if (!isPathInside(filepath, pwd)) return null;
-            if (!await fs.pathExists(filepath)) return null;
-            return serveFile(c, filepath, moduleFederationAsset, moduleFederationRemoteEntry, requestPath);
-        };
+        const staticServingRequest = await moduleFederationStaticServing.resolveRequest(pathname);
+        if (null === staticServingRequest) return next();
         if (hit) {
-            const response = await serveByPath(path.join(pwd, requestPath), isModuleFederationAsset, isModuleFederationRemoteEntry);
+            const response = await moduleFederationStaticServing.serveStaticHit(c, staticServingRequest);
             if (null !== response) return response;
             return next();
         }
-        if (isModuleFederationAsset) {
-            const response = await serveByPath(path.join(pwd, requestPath), true, isModuleFederationRemoteEntry);
-            if (null !== response) return response;
-        }
+        const moduleFederationResponse = await moduleFederationStaticServing.serveModuleFederationAsset(c, staticServingRequest);
+        if (null !== moduleFederationResponse) return moduleFederationResponse;
         return publicMiddleware(c, next);
     };
 }

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

@@ -96,4 +96,4 @@ const getModuleFederationAssetList = async (pwd)=>{
         remoteEntries
     };
 };
-export { BACKEND_MODULE_FEDERATION_MANIFEST_FILE, MODULE_FEDERATION_MANIFEST_FILE, applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath, trimLeadingSlash };
+export { MODULE_FEDERATION_MANIFEST_FILE, applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath };

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

@@ -88,4 +88,4 @@ 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 };
+export { applyPreCompressedAssetHeaders, resolvePreCompressedAsset };

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

@@ -0,0 +1,80 @@
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+import { fs } from "@modern-js/utils";
+import { getMimeType } from "hono/utils/mime";
+import path from "path";
+import { applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath } from "./staticModuleFederation.mjs";
+import { applyPreCompressedAssetHeaders, resolvePreCompressedAsset } from "./staticPrecompressed.mjs";
+const servePreCompressedPublicRouteAsset = async (c, pwd, route)=>{
+    const { entryPath } = route;
+    const originFilename = path.join(pwd, entryPath);
+    const preCompressedAsset = await resolvePreCompressedAsset(c, originFilename);
+    const filename = preCompressedAsset.selected?.filepath ?? originFilename;
+    const data = await fileReader.readFile(filename, 'buffer');
+    const mimeType = getMimeType(originFilename);
+    if (null === data) return null;
+    const body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    if (mimeType) c.header('Content-Type', mimeType);
+    Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
+        c.header(k, v);
+    });
+    applyPreCompressedAssetHeaders(c, preCompressedAsset);
+    c.header('Content-Length', String(data.byteLength));
+    return c.body(body, 200);
+};
+const isPathInside = (target, root)=>{
+    const relative = path.relative(path.resolve(root), path.resolve(target));
+    return '' === relative || !relative.startsWith(`..${path.sep}`) && '..' !== relative && !path.isAbsolute(relative);
+};
+const createModuleFederationStaticServing = ({ pwd, pathPrefix })=>{
+    let moduleFederationAssetsPromise = null;
+    const getModuleFederationAssets = async ()=>{
+        if (!moduleFederationAssetsPromise) moduleFederationAssetsPromise = getModuleFederationAssetList(pwd);
+        return moduleFederationAssetsPromise;
+    };
+    const resolveRequest = async (pathname)=>{
+        const requestPath = getModuleFederationRequestPath(pathname, pathPrefix);
+        if (requestPath.includes('..')) return null;
+        const moduleFederationAssetMeta = await getModuleFederationAssets();
+        return {
+            requestPath,
+            isModuleFederationAsset: moduleFederationAssetMeta.assets.has(requestPath),
+            isModuleFederationRemoteEntry: moduleFederationAssetMeta.remoteEntries.has(requestPath)
+        };
+    };
+    const serveFile = async (c, filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false, requestPath = '')=>{
+        if (moduleFederationAsset) applyModuleFederationAssetHeaders(c);
+        const mimeType = getMimeType(filepath);
+        if (mimeType) c.header('Content-Type', mimeType);
+        const shouldPatchManifest = moduleFederationAsset && isModuleFederationManifestRequest(requestPath);
+        const shouldPatchRemoteEntry = moduleFederationRemoteEntry;
+        const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
+        const preCompressedAsset = canUsePreCompressed ? await resolvePreCompressedAsset(c, filepath) : {
+            selected: null,
+            hasVariant: false
+        };
+        const targetFilepath = preCompressedAsset.selected?.filepath ?? filepath;
+        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;
+        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);
+    };
+    const serveByPath = async (c, filepath, request, moduleFederationAsset = false, moduleFederationRemoteEntry = false)=>{
+        if (!isPathInside(filepath, pwd)) return null;
+        if (!await fs.pathExists(filepath)) return null;
+        return serveFile(c, filepath, moduleFederationAsset, moduleFederationRemoteEntry, request.requestPath);
+    };
+    const serveStaticHit = (c, request)=>serveByPath(c, path.join(pwd, request.requestPath), request, request.isModuleFederationAsset, request.isModuleFederationRemoteEntry);
+    const serveModuleFederationAsset = (c, request)=>{
+        if (!request.isModuleFederationAsset) return null;
+        return serveByPath(c, path.join(pwd, request.requestPath), request, true, request.isModuleFederationRemoteEntry);
+    };
+    return {
+        resolveRequest,
+        serveStaticHit,
+        serveModuleFederationAsset
+    };
+};
+export { createModuleFederationStaticServing, servePreCompressedPublicRouteAsset };

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

@@ -8,10 +8,10 @@ import { renderRscHandler } from "./renderRscHandler.mjs";
 import { serverActionHandler } from "./serverActionHandler.mjs";
 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";
+import * as __rspack_external__modern_js_runtime_utils_router_4aa9f9b0 from "@modern-js/runtime-utils/router";
 __webpack_require__.add({
-    2420 (module) {
-        module.exports = __rspack_external__modern_js_runtime_utils_router_2aa8d96f;
+    5327 (module) {
+        module.exports = __rspack_external__modern_js_runtime_utils_router_4aa9f9b0;
     }
 });
 const DYNAMIC_ROUTE_REG = /\/:./;
@@ -163,7 +163,7 @@ async function renderHandler(request, options, mode, fallbackWrapper, framework)
         const { nestedRoutesJson } = serverManifest;
         const routes = nestedRoutesJson?.[options.routeInfo.entryName];
         if (routes) {
-            const { matchRoutes } = __webpack_require__(2420);
+            const { matchRoutes } = __webpack_require__(5327);
             const url = new URL(request.url);
             const matchedRoutes = matchRoutes(routes, url.pathname, options.routeInfo.urlPath);
             if (matchedRoutes) {

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

@@ -1,12 +1,8 @@
 import "node:module";
-import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { fs } from "@modern-js/utils";
-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";
+import { createModuleFederationStaticServing, servePreCompressedPublicRouteAsset } from "./staticServing.mjs";
 const serverStaticPlugin = ()=>({
         name: '@modern-js/plugin-server-static',
         setup (api) {
@@ -31,22 +27,8 @@ function createPublicMiddleware({ pwd, routes }) {
     return async (c, next)=>{
         const route = matchPublicRoute(c.req, routes);
         if (route) {
-            const { entryPath } = route;
-            const originFilename = path.join(pwd, entryPath);
-            const preCompressedAsset = await resolvePreCompressedAsset(c, originFilename);
-            const filename = preCompressedAsset.selected?.filepath ?? originFilename;
-            const data = await fileReader.readFile(filename, 'buffer');
-            const mimeType = getMimeType(originFilename);
-            if (null !== data) {
-                const body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-                if (mimeType) c.header('Content-Type', mimeType);
-                Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
-                    c.header(k, v);
-                });
-                applyPreCompressedAssetHeaders(c, preCompressedAsset);
-                c.header('Content-Length', String(data.byteLength));
-                return c.body(body, 200);
-            }
+            const response = await servePreCompressedPublicRouteAsset(c, pwd, route);
+            if (null !== response) return response;
         }
         return await next();
     };
@@ -54,10 +36,6 @@ function createPublicMiddleware({ pwd, routes }) {
 function matchPublicRoute(req, routes) {
     for (const route of routes.sort(sortRoutes))if (!route.isSSR && route.entryPath.startsWith('public') && req.path.startsWith(route.urlPath)) return route;
 }
-const isPathInside = (target, root)=>{
-    const relative = path.relative(path.resolve(root), path.resolve(target));
-    return '' === relative || !relative.startsWith(`..${path.sep}`) && '..' !== relative && !path.isAbsolute(relative);
-};
 const extractPathname = (url)=>{
     try {
         if (url.includes('://')) return new URL(url).pathname || '/';
@@ -101,55 +79,24 @@ function createStaticMiddleware(options) {
         pwd,
         routes: routes || []
     });
-    let moduleFederationAssetsPromise = null;
-    const getModuleFederationAssets = async ()=>{
-        if (!moduleFederationAssetsPromise) moduleFederationAssetsPromise = getModuleFederationAssetList(pwd);
-        return moduleFederationAssetsPromise;
-    };
-    const serveFile = async (c, filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false, requestPath = '')=>{
-        if (moduleFederationAsset) applyModuleFederationAssetHeaders(c);
-        const mimeType = getMimeType(filepath);
-        if (mimeType) c.header('Content-Type', mimeType);
-        const shouldPatchManifest = moduleFederationAsset && isModuleFederationManifestRequest(requestPath);
-        const shouldPatchRemoteEntry = moduleFederationRemoteEntry;
-        const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
-        const preCompressedAsset = canUsePreCompressed ? await resolvePreCompressedAsset(c, filepath) : {
-            selected: null,
-            hasVariant: false
-        };
-        const targetFilepath = preCompressedAsset.selected?.filepath ?? filepath;
-        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;
-        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);
-    };
+    const moduleFederationStaticServing = createModuleFederationStaticServing({
+        pwd,
+        pathPrefix
+    });
     return async (c, next)=>{
         const pageRoute = c.get('route');
         const pathname = c.req.path;
         if (pageRoute && '' === path.extname(pathname)) return next();
         const hit = staticPathRegExp.test(pathname);
-        const requestPath = getModuleFederationRequestPath(pathname, pathPrefix);
-        if (requestPath.includes('..')) return next();
-        const moduleFederationAssetMeta = await getModuleFederationAssets();
-        const isModuleFederationAsset = moduleFederationAssetMeta.assets.has(requestPath);
-        const isModuleFederationRemoteEntry = moduleFederationAssetMeta.remoteEntries.has(requestPath);
-        const serveByPath = async (filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false)=>{
-            if (!isPathInside(filepath, pwd)) return null;
-            if (!await fs.pathExists(filepath)) return null;
-            return serveFile(c, filepath, moduleFederationAsset, moduleFederationRemoteEntry, requestPath);
-        };
+        const staticServingRequest = await moduleFederationStaticServing.resolveRequest(pathname);
+        if (null === staticServingRequest) return next();
         if (hit) {
-            const response = await serveByPath(path.join(pwd, requestPath), isModuleFederationAsset, isModuleFederationRemoteEntry);
+            const response = await moduleFederationStaticServing.serveStaticHit(c, staticServingRequest);
             if (null !== response) return response;
             return next();
         }
-        if (isModuleFederationAsset) {
-            const response = await serveByPath(path.join(pwd, requestPath), true, isModuleFederationRemoteEntry);
-            if (null !== response) return response;
-        }
+        const moduleFederationResponse = await moduleFederationStaticServing.serveModuleFederationAsset(c, staticServingRequest);
+        if (null !== moduleFederationResponse) return moduleFederationResponse;
         return publicMiddleware(c, next);
     };
 }

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

@@ -97,4 +97,4 @@ const getModuleFederationAssetList = async (pwd)=>{
         remoteEntries
     };
 };
-export { BACKEND_MODULE_FEDERATION_MANIFEST_FILE, MODULE_FEDERATION_MANIFEST_FILE, applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath, trimLeadingSlash };
+export { MODULE_FEDERATION_MANIFEST_FILE, applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath };

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

@@ -89,4 +89,4 @@ 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 };
+export { applyPreCompressedAssetHeaders, resolvePreCompressedAsset };

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

@@ -0,0 +1,81 @@
+import "node:module";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+import { fs } from "@modern-js/utils";
+import { getMimeType } from "hono/utils/mime";
+import path from "path";
+import { applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath } from "./staticModuleFederation.mjs";
+import { applyPreCompressedAssetHeaders, resolvePreCompressedAsset } from "./staticPrecompressed.mjs";
+const servePreCompressedPublicRouteAsset = async (c, pwd, route)=>{
+    const { entryPath } = route;
+    const originFilename = path.join(pwd, entryPath);
+    const preCompressedAsset = await resolvePreCompressedAsset(c, originFilename);
+    const filename = preCompressedAsset.selected?.filepath ?? originFilename;
+    const data = await fileReader.readFile(filename, 'buffer');
+    const mimeType = getMimeType(originFilename);
+    if (null === data) return null;
+    const body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    if (mimeType) c.header('Content-Type', mimeType);
+    Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
+        c.header(k, v);
+    });
+    applyPreCompressedAssetHeaders(c, preCompressedAsset);
+    c.header('Content-Length', String(data.byteLength));
+    return c.body(body, 200);
+};
+const isPathInside = (target, root)=>{
+    const relative = path.relative(path.resolve(root), path.resolve(target));
+    return '' === relative || !relative.startsWith(`..${path.sep}`) && '..' !== relative && !path.isAbsolute(relative);
+};
+const createModuleFederationStaticServing = ({ pwd, pathPrefix })=>{
+    let moduleFederationAssetsPromise = null;
+    const getModuleFederationAssets = async ()=>{
+        if (!moduleFederationAssetsPromise) moduleFederationAssetsPromise = getModuleFederationAssetList(pwd);
+        return moduleFederationAssetsPromise;
+    };
+    const resolveRequest = async (pathname)=>{
+        const requestPath = getModuleFederationRequestPath(pathname, pathPrefix);
+        if (requestPath.includes('..')) return null;
+        const moduleFederationAssetMeta = await getModuleFederationAssets();
+        return {
+            requestPath,
+            isModuleFederationAsset: moduleFederationAssetMeta.assets.has(requestPath),
+            isModuleFederationRemoteEntry: moduleFederationAssetMeta.remoteEntries.has(requestPath)
+        };
+    };
+    const serveFile = async (c, filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false, requestPath = '')=>{
+        if (moduleFederationAsset) applyModuleFederationAssetHeaders(c);
+        const mimeType = getMimeType(filepath);
+        if (mimeType) c.header('Content-Type', mimeType);
+        const shouldPatchManifest = moduleFederationAsset && isModuleFederationManifestRequest(requestPath);
+        const shouldPatchRemoteEntry = moduleFederationRemoteEntry;
+        const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
+        const preCompressedAsset = canUsePreCompressed ? await resolvePreCompressedAsset(c, filepath) : {
+            selected: null,
+            hasVariant: false
+        };
+        const targetFilepath = preCompressedAsset.selected?.filepath ?? filepath;
+        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;
+        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);
+    };
+    const serveByPath = async (c, filepath, request, moduleFederationAsset = false, moduleFederationRemoteEntry = false)=>{
+        if (!isPathInside(filepath, pwd)) return null;
+        if (!await fs.pathExists(filepath)) return null;
+        return serveFile(c, filepath, moduleFederationAsset, moduleFederationRemoteEntry, request.requestPath);
+    };
+    const serveStaticHit = (c, request)=>serveByPath(c, path.join(pwd, request.requestPath), request, request.isModuleFederationAsset, request.isModuleFederationRemoteEntry);
+    const serveModuleFederationAsset = (c, request)=>{
+        if (!request.isModuleFederationAsset) return null;
+        return serveByPath(c, path.join(pwd, request.requestPath), request, true, request.isModuleFederationRemoteEntry);
+    };
+    return {
+        resolveRequest,
+        serveStaticHit,
+        serveModuleFederationAsset
+    };
+};
+export { createModuleFederationStaticServing, servePreCompressedPublicRouteAsset };

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

@@ -9,10 +9,10 @@ import { renderRscHandler } from "./renderRscHandler.mjs";
 import { serverActionHandler } from "./serverActionHandler.mjs";
 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";
+import * as __rspack_external__modern_js_runtime_utils_router_4aa9f9b0 from "@modern-js/runtime-utils/router";
 __webpack_require__.add({
     "@modern-js/runtime-utils/router" (module) {
-        module.exports = __rspack_external__modern_js_runtime_utils_router_2aa8d96f;
+        module.exports = __rspack_external__modern_js_runtime_utils_router_4aa9f9b0;
     }
 });
 const DYNAMIC_ROUTE_REG = /\/:./;

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

@@ -1,11 +1,9 @@
 import type { Middleware } from '../../../types';
 export declare const MODULE_FEDERATION_MANIFEST_FILE = "mf-manifest.json";
-export declare const BACKEND_MODULE_FEDERATION_MANIFEST_FILE = "backend-mf-manifest.json";
 export type ModuleFederationServeAssets = {
     assets: Set<string>;
     remoteEntries: Set<string>;
 };
-export declare const trimLeadingSlash: (value: string) => string;
 export declare const getModuleFederationRequestPath: (pathname: string, pathPrefix: string) => string;
 export declare const isModuleFederationManifestRequest: (requestPath: string) => boolean;
 export declare const applyModuleFederationAssetHeaders: (c: Parameters<Middleware>[0]) => void;

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

@@ -1,13 +1,12 @@
 import type { Middleware } from '../../../types';
 type SupportedEncoding = 'br' | 'gzip';
-export type ResolvePreCompressedAssetResult = {
+type ResolvePreCompressedAssetResult = {
     selected: {
         filepath: string;
         encoding: SupportedEncoding;
     } | null;
     hasVariant: boolean;
 };
-export declare const appendVaryHeader: (c: Parameters<Middleware>[0], value: string) => void;
 export declare const resolvePreCompressedAsset: (c: Parameters<Middleware>[0], filepath: string) => Promise<ResolvePreCompressedAssetResult>;
 export declare const applyPreCompressedAssetHeaders: (c: Parameters<Middleware>[0], preCompressedAsset: ResolvePreCompressedAssetResult) => void;
 export {};

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

@@ -0,0 +1,19 @@
+import type { ServerRoute } from '@modern-js/types';
+import type { Middleware } from '../../../types';
+type MiddlewareContext = Parameters<Middleware>[0];
+type StaticServingRequest = {
+    requestPath: string;
+    isModuleFederationAsset: boolean;
+    isModuleFederationRemoteEntry: boolean;
+};
+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 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;
+};
+export {};

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0-ultramodern.36",
+  "version": "3.5.0-ultramodern.38",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -74,21 +74,21 @@
     "@web-std/stream": "^1.0.3",
     "cloneable-readable": "^3.0.0",
     "flatted": "^3.4.2",
-    "hono": "^4.12.27",
+    "hono": "^4.12.28",
     "ts-deepmerge": "8.0.0",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.36",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.36",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.36"
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.38",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.38",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.38"
   },
   "devDependencies": {
-    "@rslib/core": "0.23.1",
+    "@rslib/core": "0.23.2",
     "@types/cloneable-readable": "^2.0.3",
     "@types/merge-deep": "^3.0.3",
-    "@types/node": "^26.0.1",
-    "@typescript/native-preview": "7.0.0-dev.20260628.1",
-    "http-proxy-middleware": "^4.1.1",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.36",
-    "@scripts/rstest-config": "2.66.0"
+    "@types/node": "^26.1.1",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "http-proxy-middleware": "^4.2.0",
+    "@scripts/rstest-config": "2.66.0",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.38"
   },
   "sideEffects": false,
   "publishConfig": {