@bleedingdev/modern-js-server-core 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

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

@@ -44,12 +44,14 @@ __webpack_require__.d(__webpack_exports__, {
     loadServerPlugins: ()=>index_js_namespaceObject.loadServerPlugins,
     loadServerRuntimeConfig: ()=>index_js_namespaceObject.loadServerRuntimeConfig,
     sendResponse: ()=>external_node_js_namespaceObject.sendResponse,
+    serveStaticAsset: ()=>static_js_namespaceObject.serveStaticAsset,
     serverStaticPlugin: ()=>external_plugins_index_js_namespaceObject.serverStaticPlugin
 });
 const index_js_namespaceObject = require("./helper/index.js");
 const external_hono_js_namespaceObject = require("./hono.js");
 const external_node_js_namespaceObject = require("./node.js");
 const external_plugins_index_js_namespaceObject = require("./plugins/index.js");
+const static_js_namespaceObject = require("./plugins/static.js");
 exports.connectMid2HonoMid = __webpack_exports__.connectMid2HonoMid;
 exports.connectMockMid2HonoMid = __webpack_exports__.connectMockMid2HonoMid;
 exports.createNodeServer = __webpack_exports__.createNodeServer;
@@ -66,6 +68,7 @@ exports.loadServerEnv = __webpack_exports__.loadServerEnv;
 exports.loadServerPlugins = __webpack_exports__.loadServerPlugins;
 exports.loadServerRuntimeConfig = __webpack_exports__.loadServerRuntimeConfig;
 exports.sendResponse = __webpack_exports__.sendResponse;
+exports.serveStaticAsset = __webpack_exports__.serveStaticAsset;
 exports.serverStaticPlugin = __webpack_exports__.serverStaticPlugin;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "connectMid2HonoMid",
@@ -84,6 +87,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "loadServerPlugins",
     "loadServerRuntimeConfig",
     "sendResponse",
+    "serveStaticAsset",
     "serverStaticPlugin"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

@@ -39,14 +39,62 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createPublicMiddleware: ()=>createPublicMiddleware,
     createStaticMiddleware: ()=>createStaticMiddleware,
+    serveStaticAsset: ()=>serveStaticAsset,
     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_staticServing_js_namespaceObject = require("./staticServing.js");
-const serverStaticPlugin = ()=>({
+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);
+};
+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([
+            utils_namespaceObject.fs.realpath(filename),
+            asset.root ? utils_namespaceObject.fs.realpath(asset.root) : Promise.resolve(void 0),
+            utils_namespaceObject.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 utils_namespaceObject.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 = (0, mime_namespaceObject.getMimeType)(asset.mimeFilename ?? filename);
+    if ('static' === kind && mimeType) context.header('Content-Type', mimeType);
+    const size = 'static' === kind ? (await utils_namespaceObject.fs.lstat(filename)).size : void 0;
+    const data = 'static' === kind ? await fileReader_namespaceObject.fileReader.readFileFromSystem(filename, 'buffer') : await fileReader_namespaceObject.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(()=>{
@@ -57,7 +105,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',
@@ -66,16 +116,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 (0, external_staticServing_js_namespaceObject.servePreCompressedPublicRouteAsset)(c, pwd, route);
-            if (null !== response) return response;
-        }
-        const generatedPublicAsset = await (0, external_staticServing_js_namespaceObject.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: external_path_default().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) {
@@ -120,29 +187,38 @@ function createStaticMiddleware(options) {
         ...staticReg,
         ...iconReg
     ].join('|')})`);
-    const publicMiddleware = createPublicMiddleware({
-        pwd,
-        routes: routes || []
-    });
-    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 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 = external_path_default().join(pwd, pathname.replace(pathPrefix, ()=>''));
+            if (!isPathInside(filepath, pwd)) return next();
+            if (!await utils_namespaceObject.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)=>{
@@ -152,10 +228,12 @@ const prepareFavicons = (favicon)=>{
 };
 exports.createPublicMiddleware = __webpack_exports__.createPublicMiddleware;
 exports.createStaticMiddleware = __webpack_exports__.createStaticMiddleware;
+exports.serveStaticAsset = __webpack_exports__.serveStaticAsset;
 exports.serverStaticPlugin = __webpack_exports__.serverStaticPlugin;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createPublicMiddleware",
     "createStaticMiddleware",
+    "serveStaticAsset",
     "serverStaticPlugin"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/index.js

@@ -92,22 +92,19 @@ var __webpack_exports__ = {};
     var __rspack_reexport = {};
     for(const __rspack_import_key in _plugins__rspack_import_4)if ([
         "Hono",
-        "createSafeJsonFailureResponse",
         "createErrorHtml",
         "useHonoContext",
-        "createServerBase",
         "normalizePublicDir",
+        "createServerBase",
         "resolvePublicDirPaths",
-        "getSafeFailureStatus",
         "default",
         "normalizePublicDirPath",
         "onError",
-        "createSafeFailureHttpResult",
         "ErrorDigest",
         "getPublicDirConfig",
         "getPublicDirPatterns",
-        "getLoaderCtx",
         "getPublicDirRoutePrefixes",
+        "getLoaderCtx",
         "run",
         "AGGRED_DIR"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_plugins__rspack_import_4[__rspack_import_key];
@@ -117,22 +114,19 @@ var __webpack_exports__ = {};
     var __rspack_reexport = {};
     for(const __rspack_import_key in _types_config__rspack_import_6)if ([
         "Hono",
-        "createSafeJsonFailureResponse",
         "createErrorHtml",
         "useHonoContext",
-        "createServerBase",
         "normalizePublicDir",
+        "createServerBase",
         "resolvePublicDirPaths",
-        "getSafeFailureStatus",
         "default",
         "normalizePublicDirPath",
         "onError",
-        "createSafeFailureHttpResult",
         "ErrorDigest",
         "getPublicDirConfig",
         "getPublicDirPatterns",
-        "getLoaderCtx",
         "getPublicDirRoutePrefixes",
+        "getLoaderCtx",
         "run",
         "AGGRED_DIR"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types_config__rspack_import_6[__rspack_import_key];
@@ -141,22 +135,19 @@ var __webpack_exports__ = {};
     var __rspack_reexport = {};
     for(const __rspack_import_key in _types_plugins__rspack_import_7)if ([
         "Hono",
-        "createSafeJsonFailureResponse",
         "createErrorHtml",
         "useHonoContext",
-        "createServerBase",
         "normalizePublicDir",
+        "createServerBase",
         "resolvePublicDirPaths",
-        "getSafeFailureStatus",
         "default",
         "normalizePublicDirPath",
         "onError",
-        "createSafeFailureHttpResult",
         "ErrorDigest",
         "getPublicDirConfig",
         "getPublicDirPatterns",
-        "getLoaderCtx",
         "getPublicDirRoutePrefixes",
+        "getLoaderCtx",
         "run",
         "AGGRED_DIR"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types_plugins__rspack_import_7[__rspack_import_key];
@@ -165,22 +156,19 @@ var __webpack_exports__ = {};
     var __rspack_reexport = {};
     for(const __rspack_import_key in _types_render__rspack_import_8)if ([
         "Hono",
-        "createSafeJsonFailureResponse",
         "createErrorHtml",
         "useHonoContext",
-        "createServerBase",
         "normalizePublicDir",
+        "createServerBase",
         "resolvePublicDirPaths",
-        "getSafeFailureStatus",
         "default",
         "normalizePublicDirPath",
         "onError",
-        "createSafeFailureHttpResult",
         "ErrorDigest",
         "getPublicDirConfig",
         "getPublicDirPatterns",
-        "getLoaderCtx",
         "getPublicDirRoutePrefixes",
+        "getLoaderCtx",
         "run",
         "AGGRED_DIR"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types_render__rspack_import_8[__rspack_import_key];
@@ -189,22 +177,19 @@ var __webpack_exports__ = {};
     var __rspack_reexport = {};
     for(const __rspack_import_key in _types_requestHandler__rspack_import_9)if ([
         "Hono",
-        "createSafeJsonFailureResponse",
         "createErrorHtml",
         "useHonoContext",
-        "createServerBase",
         "normalizePublicDir",
+        "createServerBase",
         "resolvePublicDirPaths",
-        "getSafeFailureStatus",
         "default",
         "normalizePublicDirPath",
         "onError",
-        "createSafeFailureHttpResult",
         "ErrorDigest",
         "getPublicDirConfig",
         "getPublicDirPatterns",
-        "getLoaderCtx",
         "getPublicDirRoutePrefixes",
+        "getLoaderCtx",
         "run",
         "AGGRED_DIR"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types_requestHandler__rspack_import_9[__rspack_import_key];
@@ -216,14 +201,11 @@ var __webpack_exports__ = {};
         ErrorDigest: ()=>_utils__rspack_import_10.ErrorDigest,
         Hono: ()=>hono__rspack_import_0.Hono,
         createErrorHtml: ()=>_utils__rspack_import_10.createErrorHtml,
-        createSafeFailureHttpResult: ()=>_utils__rspack_import_10.createSafeFailureHttpResult,
-        createSafeJsonFailureResponse: ()=>_utils__rspack_import_10.createSafeJsonFailureResponse,
         createServerBase: ()=>_serverBase__rspack_import_5.createServerBase,
         getLoaderCtx: ()=>_helper__rspack_import_3.getLoaderCtx,
         getPublicDirConfig: ()=>_utils_publicDir__rspack_import_11.getPublicDirConfig,
         getPublicDirPatterns: ()=>_utils_publicDir__rspack_import_11.getPublicDirPatterns,
         getPublicDirRoutePrefixes: ()=>_utils_publicDir__rspack_import_11.getPublicDirRoutePrefixes,
-        getSafeFailureStatus: ()=>_utils__rspack_import_10.getSafeFailureStatus,
         normalizePublicDir: ()=>_utils_publicDir__rspack_import_11.normalizePublicDir,
         normalizePublicDirPath: ()=>_utils_publicDir__rspack_import_11.normalizePublicDirPath,
         onError: ()=>_utils__rspack_import_10.onError,
@@ -236,14 +218,11 @@ exports.AGGRED_DIR = __webpack_exports__.AGGRED_DIR;
 exports.ErrorDigest = __webpack_exports__.ErrorDigest;
 exports.Hono = __webpack_exports__.Hono;
 exports.createErrorHtml = __webpack_exports__.createErrorHtml;
-exports.createSafeFailureHttpResult = __webpack_exports__.createSafeFailureHttpResult;
-exports.createSafeJsonFailureResponse = __webpack_exports__.createSafeJsonFailureResponse;
 exports.createServerBase = __webpack_exports__.createServerBase;
 exports.getLoaderCtx = __webpack_exports__.getLoaderCtx;
 exports.getPublicDirConfig = __webpack_exports__.getPublicDirConfig;
 exports.getPublicDirPatterns = __webpack_exports__.getPublicDirPatterns;
 exports.getPublicDirRoutePrefixes = __webpack_exports__.getPublicDirRoutePrefixes;
-exports.getSafeFailureStatus = __webpack_exports__.getSafeFailureStatus;
 exports.normalizePublicDir = __webpack_exports__.normalizePublicDir;
 exports.normalizePublicDirPath = __webpack_exports__.normalizePublicDirPath;
 exports.onError = __webpack_exports__.onError;
@@ -255,14 +234,11 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "ErrorDigest",
     "Hono",
     "createErrorHtml",
-    "createSafeFailureHttpResult",
-    "createSafeJsonFailureResponse",
     "createServerBase",
     "getLoaderCtx",
     "getPublicDirConfig",
     "getPublicDirPatterns",
     "getPublicDirRoutePrefixes",
-    "getSafeFailureStatus",
     "normalizePublicDir",
     "normalizePublicDirPath",
     "onError",

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

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

package/dist/cjs/serverBase.js

@@ -32,6 +32,7 @@ __webpack_require__.d(__webpack_exports__, {
     createServerBase: ()=>createServerBase
 });
 const server_namespaceObject = require("@modern-js/plugin/server");
+const utils_namespaceObject = require("@modern-js/utils");
 const external_hono_namespaceObject = require("hono");
 const external_context_js_namespaceObject = require("./context.js");
 const hooks_js_namespaceObject = require("./plugins/compat/hooks.js");
@@ -50,22 +51,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 = (0, index_js_namespaceObject.loadConfig)({
-            cliConfig,
-            serverConfig: serverConfig || {}
-        });
-        const { serverContext } = await server_namespaceObject.server.run({
-            plugins: this.plugins,
-            options: this.serverOptions,
-            config: mergedConfig,
-            handleSetupResult: hooks_js_namespaceObject.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 = (0, index_js_namespaceObject.loadConfig)({
+                cliConfig,
+                serverConfig: serverConfig || {}
+            });
+            const { serverContext } = await server_namespaceObject.server.run({
+                plugins: this.plugins,
+                options: this.serverOptions,
+                config: mergedConfig,
+                handleSetupResult: hooks_js_namespaceObject.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)=>{
+                utils_namespaceObject.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);
@@ -111,7 +144,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 external_hono_namespaceObject.Hono();

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";