@bleedingdev/modern-js-server-core 3.9.0-ultramodern.1 → 3.9.0-ultramodern.11

package/dist/cjs/utils/error.js

@@ -30,12 +30,8 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     ErrorDigest: ()=>error_ErrorDigest,
     createErrorHtml: ()=>createErrorHtml,
-    createSafeFailureHttpResult: ()=>safe_failure_namespaceObject.createSafeFailureHttpResult,
-    createSafeJsonFailureResponse: ()=>safe_failure_namespaceObject.createSafeJsonFailureResponse,
-    getSafeFailureStatus: ()=>safe_failure_namespaceObject.getSafeFailureStatus,
     onError: ()=>onError
 });
-const safe_failure_namespaceObject = require("@modern-js/runtime-extensions/safe-failure");
 const external_request_js_namespaceObject = require("./request.js");
 const ERROR_PAGE_TEXT = {
     404: 'This page could not be found.',
@@ -90,16 +86,10 @@ function onError(digest, error, monitors, req) {
 }
 exports.ErrorDigest = __webpack_exports__.ErrorDigest;
 exports.createErrorHtml = __webpack_exports__.createErrorHtml;
-exports.createSafeFailureHttpResult = __webpack_exports__.createSafeFailureHttpResult;
-exports.createSafeJsonFailureResponse = __webpack_exports__.createSafeJsonFailureResponse;
-exports.getSafeFailureStatus = __webpack_exports__.getSafeFailureStatus;
 exports.onError = __webpack_exports__.onError;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "ErrorDigest",
     "createErrorHtml",
-    "createSafeFailureHttpResult",
-    "createSafeJsonFailureResponse",
-    "getSafeFailureStatus",
     "onError"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

@@ -2,3 +2,4 @@ export { loadCacheConfig, loadServerCliConfig, loadServerEnv, loadServerPlugins,
 export { connectMid2HonoMid, connectMockMid2HonoMid, httpCallBack2HonoMid } from "./hono.mjs";
 export { createNodeServer, createWebRequest, sendResponse } from "./node.mjs";
 export { getHtmlTemplates, getServerManifest, injectNodeSeverPlugin, injectResourcePlugin, injectRscManifestPlugin, serverStaticPlugin } from "./plugins/index.mjs";
+export { serveStaticAsset } from "./plugins/static.mjs";

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

@@ -1,8 +1,55 @@
-import path_0 from "path";
+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 { createModuleFederationStaticServing, servePreCompressedPublicRouteAsset, servePublicDirectoryAsset } from "./staticServing.mjs";
-const serverStaticPlugin = ()=>({
+const isPathInside = (target, root)=>{
+    const relative = path.relative(path.resolve(root), path.resolve(target));
+    return '' === relative || !relative.startsWith(`..${path.sep}`) && '..' !== relative && !path.isAbsolute(relative);
+};
+async function serveStaticAsset(context, asset, respond) {
+    let { filename } = asset;
+    const { kind } = asset;
+    if (asset.root && !isPathInside(filename, asset.root)) return null;
+    if (asset.realpath) try {
+        const [realFilename, realRoot, stat] = await Promise.all([
+            fs.realpath(filename),
+            asset.root ? fs.realpath(asset.root) : Promise.resolve(void 0),
+            fs.stat(filename)
+        ]);
+        if (!stat.isFile() || realRoot && !isPathInside(realFilename, realRoot)) return null;
+        filename = realFilename;
+        asset = {
+            ...asset,
+            filename,
+            root: realRoot
+        };
+    } catch  {
+        return null;
+    }
+    if ('static' === kind && !await fs.pathExists(filename)) return null;
+    if (respond) return respond(asset, (representation)=>serveStaticAsset(context, {
+            ...asset,
+            ...representation,
+            filename: representation?.filename ?? asset.filename,
+            mimeFilename: asset.mimeFilename ?? filename
+        }));
+    const mimeType = getMimeType(asset.mimeFilename ?? filename);
+    if ('static' === kind && mimeType) context.header('Content-Type', mimeType);
+    const size = 'static' === kind ? (await fs.lstat(filename)).size : void 0;
+    const data = 'static' === kind ? await fileReader.readFileFromSystem(filename, 'buffer') : await fileReader.readFile(filename, 'buffer');
+    if ('static' === kind && (asset.contentLength ?? true)) context.header('Content-Length', String(true === asset.contentLength && data ? data.byteLength : size));
+    if (null === data) return null;
+    if ('public' === kind && mimeType) context.header('Content-Type', mimeType);
+    Object.entries(asset.responseHeaders || {}).forEach(([key, value])=>{
+        context.header(key, value);
+    });
+    if ('public' === kind && asset.contentLength) context.header('Content-Length', String(data.byteLength));
+    const body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    return context.body(body, 200);
+}
+const serverStaticPlugin = (options = {})=>({
         name: '@modern-js/plugin-server-static',
         setup (api) {
             api.onPrepare(()=>{
@@ -13,7 +60,9 @@ const serverStaticPlugin = ()=>({
                     routes,
                     output: config.output || {},
                     html: config.html || {},
-                    server: config.server || {}
+                    server: config.server || {},
+                    ...api.getServerContext().staticAssetResponders,
+                    ...options
                 });
                 middlewares.push({
                     name: 'server-static',
@@ -22,16 +71,33 @@ const serverStaticPlugin = ()=>({
             });
         }
     });
-function createPublicMiddleware({ pwd, routes }) {
+function createPublicMiddleware({ pwd, routes, pathPrefix = '/', respondAsset, respondPublicFallback }) {
     return async (c, next)=>{
-        const route = matchPublicRoute(c.req, routes);
-        if (route) {
-            const response = await servePreCompressedPublicRouteAsset(c, pwd, route);
-            if (null !== response) return response;
-        }
-        const generatedPublicAsset = await servePublicDirectoryAsset(c, pwd);
-        if (null !== generatedPublicAsset) return generatedPublicAsset;
-        return await next();
+        const respondPublic = async ()=>{
+            const route = matchPublicRoute(c.req, routes);
+            if (!route) return null;
+            const asset = {
+                filename: path.join(pwd, route.entryPath),
+                kind: 'public',
+                responseHeaders: route.responseHeaders
+            };
+            const serve = (representation)=>serveStaticAsset(c, {
+                    ...asset,
+                    ...representation,
+                    filename: representation?.filename ?? asset.filename,
+                    mimeFilename: asset.filename
+                });
+            const response = respondAsset ? await respondAsset(c, asset, serve, {
+                root: pwd,
+                pathPrefix
+            }) : void 0;
+            return void 0 === response ? serve() : response;
+        };
+        const response = respondPublicFallback ? await respondPublicFallback(c, respondPublic, {
+            root: pwd,
+            pathPrefix
+        }) : await respondPublic();
+        return response ?? next();
     };
 }
 function matchPublicRoute(req, routes) {
@@ -76,29 +142,38 @@ function createStaticMiddleware(options) {
         ...staticReg,
         ...iconReg
     ].join('|')})`);
-    const publicMiddleware = createPublicMiddleware({
-        pwd,
-        routes: routes || []
-    });
-    const moduleFederationStaticServing = createModuleFederationStaticServing({
-        pwd,
-        pathPrefix
-    });
     return async (c, next)=>{
         const pageRoute = c.get('route');
         const pathname = c.req.path;
-        if (pageRoute && '' === path_0.extname(pathname)) return next();
+        if (pageRoute && '' === path.extname(pathname)) return next();
         const hit = staticPathRegExp.test(pathname);
-        const staticServingRequest = await moduleFederationStaticServing.resolveRequest(pathname);
-        if (null === staticServingRequest) return next();
-        if (hit) {
-            const response = await moduleFederationStaticServing.serveStaticHit(c, staticServingRequest);
-            if (null !== response) return response;
-            return next();
+        if (!hit) return createPublicMiddleware({
+            pwd,
+            routes: routes || [],
+            pathPrefix,
+            respondAsset: options.respondAsset,
+            respondPublicFallback: options.respondPublicFallback
+        })(c, next);
+        {
+            const filepath = path.join(pwd, pathname.replace(pathPrefix, ()=>''));
+            if (!isPathInside(filepath, pwd)) return next();
+            if (!await fs.pathExists(filepath)) return next();
+            const asset = {
+                filename: filepath,
+                kind: 'static'
+            };
+            const serve = (representation)=>serveStaticAsset(c, {
+                    ...asset,
+                    ...representation,
+                    filename: representation?.filename ?? asset.filename,
+                    mimeFilename: filepath
+                });
+            const response = options.respondAsset ? await options.respondAsset(c, asset, serve, {
+                root: pwd,
+                pathPrefix
+            }) : void 0;
+            return (void 0 === response ? await serve() : response) ?? next();
         }
-        const moduleFederationResponse = await moduleFederationStaticServing.serveModuleFederationAsset(c, staticServingRequest);
-        if (null !== moduleFederationResponse) return moduleFederationResponse;
-        return publicMiddleware(c, next);
     };
 }
 const prepareFavicons = (favicon)=>{
@@ -106,4 +181,4 @@ const prepareFavicons = (favicon)=>{
     if (favicon && 'string' == typeof favicon) faviconNames.push(favicon.substring(favicon.lastIndexOf('/') + 1));
     return faviconNames;
 };
-export { createPublicMiddleware, createStaticMiddleware, serverStaticPlugin };
+export { createPublicMiddleware, createStaticMiddleware, serveStaticAsset, serverStaticPlugin };

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

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

@@ -3,6 +3,7 @@ import { getHookRunners, handleSetupResult } from "./hooks.mjs";
 const compatPlugin = ()=>({
         name: '@modern-js/server-compat',
         registryHooks: {
+            handleError: createAsyncPipelineHook(),
             prepareWebServer: createAsyncPipelineHook(),
             prepareApiServer: createAsyncPipelineHook(),
             afterMatch: createAsyncPipelineHook(),

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

@@ -1,54 +1,67 @@
 import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
 import { X_RENDER_CACHE } from "../../constants.mjs";
 import { createTransformStream, getPathname } from "../../utils/index.mjs";
+const preventsSharedCaching = (headers)=>/(?:^|,)\s*(?:private|no-store|no-cache)\s*(?:[=,]|$)/i.test(headers.get('cache-control') || '');
+const isCacheableResponse = (response)=>200 === response.status && !preventsSharedCaching(response.headers) && !response.headers.has('set-cookie') && !response.headers.get('vary');
 const removeTailSlash = (s)=>s.replace(/\/+$/, '');
 const ZERO_RENDER_LEVEL = /"renderLevel":0/;
 const NO_SSR_CACHE = /<meta\s+[^>]*name=["']no-ssr-cache["'][^>]*>/i;
 async function processCache({ request, key, requestHandler, requestHandlerOptions, ttl, container, cacheStatus }) {
     const response = await requestHandler(request, requestHandlerOptions);
     const { onError } = requestHandlerOptions;
-    const nonCacheableStatusCodes = [
-        204,
-        305,
-        404,
-        405,
-        500,
-        501,
-        502,
-        503,
-        504
-    ];
-    if (nonCacheableStatusCodes.includes(response.status)) return response;
+    const deleteCache = async ()=>{
+        try {
+            await container.delete(key);
+        } catch  {
+            (onError || console.error)('[render-cache] delete cache failed');
+        }
+    };
+    if (!isCacheableResponse(response) || !response.body) {
+        await deleteCache();
+        return response;
+    }
+    const headers = Object.fromEntries(response.headers);
     const decoder = new TextDecoder();
     if (response.body) {
         const stream = createTransformStream();
         const reader = response.body.getReader();
         const writer = stream.writable.getWriter();
         let html = '';
-        const push = ()=>reader.read().then(({ done, value })=>{
+        const push = ()=>reader.read().then(async ({ done, value })=>{
                 if (done) {
+                    html += decoder.decode();
                     const match = ZERO_RENDER_LEVEL.test(html) || NO_SSR_CACHE.test(html);
-                    if (match) return void writer.close();
+                    if (match) {
+                        await deleteCache();
+                        return writer.close();
+                    }
                     const current = Date.now();
                     const cache = {
                         val: html,
-                        cursor: current
+                        cursor: current,
+                        headers
                     };
                     container.set(key, JSON.stringify(cache), {
                         ttl
                     }).catch(()=>{
-                        if (onError) onError(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
-                        else console.error(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
+                        (onError || console.error)('[render-cache] set cache failed');
                     });
-                    writer.close();
-                    return;
+                    return writer.close();
                 }
-                const content = decoder.decode(value);
+                const content = decoder.decode(value, {
+                    stream: true
+                });
                 html += content;
-                writer.write(value);
-                push();
+                await writer.write(value);
+                return push();
             });
-        push();
+        push().catch(async (error)=>{
+            await Promise.allSettled([
+                writer.abort(error),
+                reader.cancel(error)
+            ]);
+            (onError || console.error)('[render-cache] response stream failed');
+        });
         cacheStatus && response.headers.set(X_RENDER_CACHE, cacheStatus);
         return new Response(stream.readable, {
             status: response.status,
@@ -63,9 +76,12 @@ function computedKey(req, cacheControl) {
     const pathname = getPathname(req);
     const { customKey } = cacheControl;
     const defaultKey = '/' === pathname ? pathname : removeTailSlash(pathname);
-    if (!customKey) return defaultKey;
-    if ('string' == typeof customKey) return customKey;
-    return customKey(defaultKey);
+    if (customKey) if ('string' == typeof customKey) return customKey;
+    else return customKey(defaultKey);
+    {
+        const url = new URL(req.url);
+        return `${url.origin}${defaultKey}${url.search}`;
+    }
 }
 function shouldUseCache(request) {
     const url = new URL(request.url);
@@ -95,13 +111,15 @@ function matchCacheControl(cacheOption, req) {
 async function getCacheResult(request, options) {
     const { cacheControl, container = storage, requestHandler, requestHandlerOptions } = options;
     const { onError } = requestHandlerOptions;
-    const key = computedKey(request, cacheControl);
+    const hasCredentials = request.headers.has('cookie') || request.headers.has('authorization');
+    if ('GET' !== request.method || !shouldUseCache(request) || preventsSharedCaching(request.headers) || hasCredentials && !cacheControl.customKey) return requestHandler(request, requestHandlerOptions);
+    const key = `${CACHE_NAMESPACE}:v2:${computedKey(request, cacheControl)}`;
     let value;
     try {
         value = await container.get(key);
     } catch (_) {
-        if (onError) onError(`[render-cache] get cache failed, key: ${key}`);
-        else console.error(`[render-cache] get cache failed, key: ${key}`);
+        if (onError) onError('[render-cache] get cache failed');
+        else console.error('[render-cache] get cache failed');
         value = void 0;
     }
     const { maxAge, staleWhileRevalidate } = cacheControl;
@@ -122,6 +140,7 @@ async function getCacheResult(request, options) {
             const cacheStatus = 'hit';
             return new Response(cache.val, {
                 headers: {
+                    ...cache.headers,
                     [X_RENDER_CACHE]: cacheStatus
                 }
             });
@@ -145,10 +164,13 @@ async function getCacheResult(request, options) {
                 container
             }).then(async (response)=>{
                 await response.text();
+            }).catch(()=>{
+                (onError || console.error)('[render-cache] revalidation failed');
             });
             const cacheStatus = 'stale';
             return new Response(cache.val, {
                 headers: {
+                    ...cache.headers,
                     [X_RENDER_CACHE]: cacheStatus
                 }
             });

package/dist/esm/serverBase.mjs

@@ -1,4 +1,5 @@
 import { server as server_server } from "@modern-js/plugin/server";
+import { logger } from "@modern-js/utils";
 import { Hono } from "hono";
 import { run } from "./context.mjs";
 import { handleSetupResult } from "./plugins/compat/hooks.mjs";
@@ -17,22 +18,54 @@ function _class_private_method_init(obj, privateSet) {
 var _applyMiddlewares = /*#__PURE__*/ new WeakSet();
 class ServerBase {
     async init() {
-        const { serverConfig, config: cliConfig } = this.serverOptions;
-        const mergedConfig = loadConfig({
-            cliConfig,
-            serverConfig: serverConfig || {}
-        });
-        const { serverContext } = await server_server.run({
-            plugins: this.plugins,
-            options: this.serverOptions,
-            config: mergedConfig,
-            handleSetupResult: handleSetupResult
-        });
-        serverContext.serverBase = this;
-        this.serverContext = serverContext;
-        await serverContext.hooks.onPrepare.call();
-        _class_private_method_get(this, _applyMiddlewares, applyMiddlewares).call(this);
-        return this;
+        try {
+            const { serverConfig, config: cliConfig } = this.serverOptions;
+            const mergedConfig = loadConfig({
+                cliConfig,
+                serverConfig: serverConfig || {}
+            });
+            const { serverContext } = await server_server.run({
+                plugins: this.plugins,
+                options: this.serverOptions,
+                config: mergedConfig,
+                handleSetupResult: handleSetupResult
+            });
+            serverContext.serverBase = this;
+            this.serverContext = serverContext;
+            await serverContext.hooks.onPrepare.call();
+            _class_private_method_get(this, _applyMiddlewares, applyMiddlewares).call(this);
+            return this;
+        } catch (error) {
+            await this.dispose().catch((disposeError)=>{
+                logger.error(disposeError);
+            });
+            throw error;
+        }
+    }
+    onDispose(disposer) {
+        if (this.disposePromise) throw new Error('Cannot register a disposer on a retired server.');
+        this.disposers.add(disposer);
+        return ()=>{
+            this.disposers.delete(disposer);
+        };
+    }
+    dispose() {
+        if (!this.disposePromise) {
+            const disposers = [
+                ...this.disposers
+            ].reverse();
+            this.disposers.clear();
+            this.disposePromise = Promise.resolve().then(async ()=>{
+                const errors = [];
+                for (const disposer of disposers)try {
+                    await disposer();
+                } catch (error) {
+                    errors.push(error);
+                }
+                if (errors.length > 0) throw new AggregateError(errors, 'Failed to dispose server.');
+            });
+        }
+        return this.disposePromise;
     }
     addPlugins(plugins) {
         this.plugins.push(...plugins);
@@ -78,7 +111,15 @@ class ServerBase {
     }
     constructor(options){
         _class_private_method_init(this, _applyMiddlewares);
-        this.plugins = [];
+        this.plugins = [
+            {
+                name: '@modern-js/server-lifecycle',
+                _registryApi: ()=>({
+                        onDispose: (disposer)=>this.onDispose(disposer)
+                    })
+            }
+        ];
+        this.disposers = new Set();
         this.serverContext = null;
         this.serverOptions = options;
         this.app = new Hono();

package/dist/esm/utils/error.mjs

@@ -50,5 +50,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 { createSafeFailureHttpResult, createSafeJsonFailureResponse, getSafeFailureStatus } from "@modern-js/runtime-extensions/safe-failure";
 export { createErrorHtml, error_ErrorDigest as ErrorDigest, onError };

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

@@ -3,3 +3,4 @@ export { loadCacheConfig, loadServerCliConfig, loadServerEnv, loadServerPlugins,
 export { connectMid2HonoMid, connectMockMid2HonoMid, httpCallBack2HonoMid } from "./hono.mjs";
 export { createNodeServer, createWebRequest, sendResponse } from "./node.mjs";
 export { getHtmlTemplates, getServerManifest, injectNodeSeverPlugin, injectResourcePlugin, injectRscManifestPlugin, serverStaticPlugin } from "./plugins/index.mjs";
+export { serveStaticAsset } from "./plugins/static.mjs";

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

@@ -1,9 +1,56 @@
 import "node:module";
-import path_0 from "path";
+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 { createModuleFederationStaticServing, servePreCompressedPublicRouteAsset, servePublicDirectoryAsset } from "./staticServing.mjs";
-const serverStaticPlugin = ()=>({
+const isPathInside = (target, root)=>{
+    const relative = path.relative(path.resolve(root), path.resolve(target));
+    return '' === relative || !relative.startsWith(`..${path.sep}`) && '..' !== relative && !path.isAbsolute(relative);
+};
+async function serveStaticAsset(context, asset, respond) {
+    let { filename } = asset;
+    const { kind } = asset;
+    if (asset.root && !isPathInside(filename, asset.root)) return null;
+    if (asset.realpath) try {
+        const [realFilename, realRoot, stat] = await Promise.all([
+            fs.realpath(filename),
+            asset.root ? fs.realpath(asset.root) : Promise.resolve(void 0),
+            fs.stat(filename)
+        ]);
+        if (!stat.isFile() || realRoot && !isPathInside(realFilename, realRoot)) return null;
+        filename = realFilename;
+        asset = {
+            ...asset,
+            filename,
+            root: realRoot
+        };
+    } catch  {
+        return null;
+    }
+    if ('static' === kind && !await fs.pathExists(filename)) return null;
+    if (respond) return respond(asset, (representation)=>serveStaticAsset(context, {
+            ...asset,
+            ...representation,
+            filename: representation?.filename ?? asset.filename,
+            mimeFilename: asset.mimeFilename ?? filename
+        }));
+    const mimeType = getMimeType(asset.mimeFilename ?? filename);
+    if ('static' === kind && mimeType) context.header('Content-Type', mimeType);
+    const size = 'static' === kind ? (await fs.lstat(filename)).size : void 0;
+    const data = 'static' === kind ? await fileReader.readFileFromSystem(filename, 'buffer') : await fileReader.readFile(filename, 'buffer');
+    if ('static' === kind && (asset.contentLength ?? true)) context.header('Content-Length', String(true === asset.contentLength && data ? data.byteLength : size));
+    if (null === data) return null;
+    if ('public' === kind && mimeType) context.header('Content-Type', mimeType);
+    Object.entries(asset.responseHeaders || {}).forEach(([key, value])=>{
+        context.header(key, value);
+    });
+    if ('public' === kind && asset.contentLength) context.header('Content-Length', String(data.byteLength));
+    const body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    return context.body(body, 200);
+}
+const serverStaticPlugin = (options = {})=>({
         name: '@modern-js/plugin-server-static',
         setup (api) {
             api.onPrepare(()=>{
@@ -14,7 +61,9 @@ const serverStaticPlugin = ()=>({
                     routes,
                     output: config.output || {},
                     html: config.html || {},
-                    server: config.server || {}
+                    server: config.server || {},
+                    ...api.getServerContext().staticAssetResponders,
+                    ...options
                 });
                 middlewares.push({
                     name: 'server-static',
@@ -23,16 +72,33 @@ const serverStaticPlugin = ()=>({
             });
         }
     });
-function createPublicMiddleware({ pwd, routes }) {
+function createPublicMiddleware({ pwd, routes, pathPrefix = '/', respondAsset, respondPublicFallback }) {
     return async (c, next)=>{
-        const route = matchPublicRoute(c.req, routes);
-        if (route) {
-            const response = await servePreCompressedPublicRouteAsset(c, pwd, route);
-            if (null !== response) return response;
-        }
-        const generatedPublicAsset = await servePublicDirectoryAsset(c, pwd);
-        if (null !== generatedPublicAsset) return generatedPublicAsset;
-        return await next();
+        const respondPublic = async ()=>{
+            const route = matchPublicRoute(c.req, routes);
+            if (!route) return null;
+            const asset = {
+                filename: path.join(pwd, route.entryPath),
+                kind: 'public',
+                responseHeaders: route.responseHeaders
+            };
+            const serve = (representation)=>serveStaticAsset(c, {
+                    ...asset,
+                    ...representation,
+                    filename: representation?.filename ?? asset.filename,
+                    mimeFilename: asset.filename
+                });
+            const response = respondAsset ? await respondAsset(c, asset, serve, {
+                root: pwd,
+                pathPrefix
+            }) : void 0;
+            return void 0 === response ? serve() : response;
+        };
+        const response = respondPublicFallback ? await respondPublicFallback(c, respondPublic, {
+            root: pwd,
+            pathPrefix
+        }) : await respondPublic();
+        return response ?? next();
     };
 }
 function matchPublicRoute(req, routes) {
@@ -77,29 +143,38 @@ function createStaticMiddleware(options) {
         ...staticReg,
         ...iconReg
     ].join('|')})`);
-    const publicMiddleware = createPublicMiddleware({
-        pwd,
-        routes: routes || []
-    });
-    const moduleFederationStaticServing = createModuleFederationStaticServing({
-        pwd,
-        pathPrefix
-    });
     return async (c, next)=>{
         const pageRoute = c.get('route');
         const pathname = c.req.path;
-        if (pageRoute && '' === path_0.extname(pathname)) return next();
+        if (pageRoute && '' === path.extname(pathname)) return next();
         const hit = staticPathRegExp.test(pathname);
-        const staticServingRequest = await moduleFederationStaticServing.resolveRequest(pathname);
-        if (null === staticServingRequest) return next();
-        if (hit) {
-            const response = await moduleFederationStaticServing.serveStaticHit(c, staticServingRequest);
-            if (null !== response) return response;
-            return next();
+        if (!hit) return createPublicMiddleware({
+            pwd,
+            routes: routes || [],
+            pathPrefix,
+            respondAsset: options.respondAsset,
+            respondPublicFallback: options.respondPublicFallback
+        })(c, next);
+        {
+            const filepath = path.join(pwd, pathname.replace(pathPrefix, ()=>''));
+            if (!isPathInside(filepath, pwd)) return next();
+            if (!await fs.pathExists(filepath)) return next();
+            const asset = {
+                filename: filepath,
+                kind: 'static'
+            };
+            const serve = (representation)=>serveStaticAsset(c, {
+                    ...asset,
+                    ...representation,
+                    filename: representation?.filename ?? asset.filename,
+                    mimeFilename: filepath
+                });
+            const response = options.respondAsset ? await options.respondAsset(c, asset, serve, {
+                root: pwd,
+                pathPrefix
+            }) : void 0;
+            return (void 0 === response ? await serve() : response) ?? next();
         }
-        const moduleFederationResponse = await moduleFederationStaticServing.serveModuleFederationAsset(c, staticServingRequest);
-        if (null !== moduleFederationResponse) return moduleFederationResponse;
-        return publicMiddleware(c, next);
     };
 }
 const prepareFavicons = (favicon)=>{
@@ -107,4 +182,4 @@ const prepareFavicons = (favicon)=>{
     if (favicon && 'string' == typeof favicon) faviconNames.push(favicon.substring(favicon.lastIndexOf('/') + 1));
     return faviconNames;
 };
-export { createPublicMiddleware, createStaticMiddleware, serverStaticPlugin };
+export { createPublicMiddleware, createStaticMiddleware, serveStaticAsset, serverStaticPlugin };