@modern-js/server-core 2.69.7 → 3.0.0-alpha.1

package/dist/esm/adapters/node/helper/utils.mjs

@@ -0,0 +1,2 @@
+const isResFinalized = (res)=>res.headersSent || res._modernBodyPiped || res.writableEnded || res.finished || !res.socket?.writable;
+export { isResFinalized };

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

@@ -0,0 +1,53 @@
+import { isResFinalized } from "./helper";
+const httpCallBack2HonoMid = (handler)=>async (context, next)=>{
+        const { req, res } = context.env.node;
+        const onPipe = ()=>{
+            res._modernBodyPiped = true;
+        };
+        res.once('pipe', onPipe);
+        req.__honoRequest = context.req;
+        req.__templates = context.get('templates') || {};
+        req.__serverManifest = context.get('serverManifest') || {};
+        req.__rscServerManifest = context.get('rscServerManifest');
+        req.__rscClientManifest = context.get('rscClientManifest');
+        req.__rscSSRManifest = context.get('rscSSRManifest');
+        try {
+            await handler(req, res);
+        } finally{
+            delete req.__honoRequest;
+            delete req.__templates;
+            delete req.__serverManifest;
+            delete req.__rscServerManifest;
+            delete req.__rscClientManifest;
+            delete req.__rscSSRManifest;
+            res.removeListener('pipe', onPipe);
+        }
+        if (isResFinalized(res)) {
+            context.res;
+            context.finalized = true;
+        } else await next();
+    };
+const noop = ()=>{};
+const connectMid2HonoMid = (handler)=>async (context, next)=>new Promise((resolve, reject)=>{
+            const { req, res } = context.env.node;
+            if (handler.length < 3) resolve(handler(req, res, noop));
+            else handler(req, res, (err)=>{
+                if (err) reject(err);
+                else resolve(next());
+            });
+        });
+const connectMockMid2HonoMid = (handler)=>async (context, next)=>new Promise((resolve, reject)=>{
+            const { req, res } = context.env.node;
+            if (handler.length < 3) {
+                res.once('finish', ()=>{
+                    context.res;
+                    context.finalized = true;
+                    resolve();
+                });
+                handler(req, res, noop);
+            } else handler(req, res, (err)=>{
+                if (err) reject(err);
+                else resolve(next());
+            });
+        });
+export { connectMid2HonoMid, connectMockMid2HonoMid, httpCallBack2HonoMid };

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

@@ -0,0 +1,5 @@
+import { connectMid2HonoMid, connectMockMid2HonoMid, httpCallBack2HonoMid } from "./hono";
+import { createNodeServer, createWebRequest, sendResponse } from "./node";
+import { getHtmlTemplates, getServerManifest, injectNodeSeverPlugin, injectResourcePlugin, injectRscManifestPlugin, serverStaticPlugin } from "./plugins";
+import { loadCacheConfig, loadServerCliConfig, loadServerEnv, loadServerPlugins, loadServerRuntimeConfig } from "./helper";
+export { connectMid2HonoMid, connectMockMid2HonoMid, createNodeServer, createWebRequest, getHtmlTemplates, getServerManifest, httpCallBack2HonoMid, injectNodeSeverPlugin, injectResourcePlugin, injectRscManifestPlugin, loadCacheConfig, loadServerCliConfig, loadServerEnv, loadServerPlugins, loadServerRuntimeConfig, sendResponse, serverStaticPlugin };

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

@@ -0,0 +1,129 @@
+import { ServerResponse } from "node:http";
+import { Readable, Writable } from "node:stream";
+import cloneable_readable from "cloneable-readable";
+import { isResFinalized } from "./helper";
+const createWebRequest = (req, res, body)=>{
+    const headerRecord = [];
+    for (const [key, value] of Object.entries(req.headers))if (!key.startsWith(':')) {
+        if (Array.isArray(value)) {
+            for (const item of value)if (void 0 !== item) headerRecord.push([
+                key,
+                item
+            ]);
+        } else if (void 0 !== value) {
+            if ('string' == typeof value) headerRecord.push([
+                key,
+                value
+            ]);
+        }
+    }
+    const { method } = req;
+    const controller = new AbortController();
+    const init = {
+        method,
+        headers: headerRecord,
+        signal: controller.signal
+    };
+    res.on('close', ()=>controller.abort('res closed'));
+    const url = `http://${req.headers.host}${req.url}`;
+    const needsRequestBody = body || !('GET' === method || 'HEAD' === method);
+    const cloneableReq = needsRequestBody ? cloneable_readable(req) : null;
+    if (needsRequestBody) {
+        if (body) init.body = body;
+        else {
+            const stream = cloneableReq.clone();
+            init.body = Readable.toWeb(stream);
+        }
+        init.duplex = 'half';
+    }
+    const originalRequest = new Request(url, init);
+    if (needsRequestBody) {
+        const interceptedMethods = [
+            'json',
+            'text',
+            'blob',
+            'arrayBuffer',
+            'formData'
+        ];
+        return new Proxy(originalRequest, {
+            get (target, prop) {
+                if (interceptedMethods.includes(prop)) return (...args)=>{
+                    cloneableReq.resume();
+                    return target[prop].call(target, ...args);
+                };
+                const value = target[prop];
+                if ('body' === prop) {
+                    cloneableReq.resume();
+                    return value;
+                }
+                if ('function' == typeof value) return (...args)=>value.apply(target, args);
+                return value;
+            }
+        });
+    }
+    return originalRequest;
+};
+const sendResponse = async (response, res)=>{
+    res.statusMessage = response.statusText;
+    res.statusCode = response.status;
+    const cookies = [];
+    for (const [key, value] of response.headers.entries())if ('set-cookie' === key) cookies.push(value);
+    else res.setHeader(key, value);
+    if (cookies.length > 0) res.setHeader('set-cookie', cookies);
+    if (response.headers.get('Content-Type')?.match(/text\/event-stream/i) && res instanceof ServerResponse) res.flushHeaders();
+    if (response.body) {
+        const writable = Writable.toWeb(res);
+        await response.body.pipeTo(writable);
+    } else res.end();
+};
+const handleResponseError = (e, res)=>{
+    const err = e instanceof Error ? e : new Error('unknown error', {
+        cause: e
+    });
+    if ('ABORT_ERR' === err.code || 'ERR_STREAM_PREMATURE_CLOSE' === err.code) console.info('The user aborted a request.');
+    else {
+        console.error(e);
+        if (!res.headersSent) res.writeHead(500, {
+            'Content-Type': 'text/plain'
+        });
+        res.end(`Error: ${err.message}`);
+        res.destroy(err);
+    }
+};
+const getRequestListener = (handler)=>async (req, res)=>{
+        try {
+            const request = createWebRequest(req, res);
+            const response = await handler(request, {
+                node: {
+                    req,
+                    res
+                }
+            });
+            if (!response.res && !isResFinalized(res)) await sendResponse(response, res);
+        } catch (error) {
+            return handleResponseError(error, res);
+        }
+    };
+const createNodeServer = async (requestHandler, httpsOptions, http2)=>{
+    const requestListener = getRequestListener(requestHandler);
+    let nodeServer;
+    if (httpsOptions) if (http2) {
+        const { createSecureServer } = await import("node:http2");
+        nodeServer = createSecureServer({
+            allowHTTP1: true,
+            maxSessionMemory: 1024,
+            ...httpsOptions
+        }, (req, res)=>requestListener(req, res));
+    } else {
+        const { createServer } = await import("node:https");
+        nodeServer = createServer(httpsOptions, requestListener);
+    }
+    else {
+        const { createServer } = await import("node:http");
+        nodeServer = createServer(requestListener);
+    }
+    nodeServer.getRequestListener = ()=>requestListener;
+    nodeServer.getRequestHandler = ()=>requestHandler;
+    return nodeServer;
+};
+export { createNodeServer, createWebRequest, sendResponse };

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

@@ -0,0 +1,9 @@
+const injectNodeSeverPlugin = ({ nodeServer })=>({
+        name: '@modern-js/plugin-inject-node-server',
+        setup (api) {
+            api.updateServerContext({
+                nodeServer
+            });
+        }
+    });
+export { injectNodeSeverPlugin };

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

@@ -0,0 +1,137 @@
+import path from "path";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, compatibleRequire, fs, isProd } from "@modern-js/utils";
+import { uniqueKeyByRoute } from "../../../utils";
+async function getHtmlTemplates(pwd, routes) {
+    const htmlRoutes = routes.filter((route)=>route.entryName);
+    const htmls = await Promise.all(htmlRoutes.map(async (route)=>{
+        let html;
+        try {
+            const htmlPath = path.join(pwd, route.entryPath);
+            html = (await fileReader.readFile(htmlPath, 'utf-8'))?.toString();
+        } catch (e) {}
+        return [
+            uniqueKeyByRoute(route),
+            html
+        ];
+    }) || []);
+    const templates = Object.fromEntries(htmls);
+    return templates;
+}
+function injectTemplates(pwd, routes, htmlTemplatePromise) {
+    return async (c, next)=>{
+        if (routes && !c.get('templates')) {
+            const templates = await (htmlTemplatePromise || getHtmlTemplates(pwd, routes));
+            c.set('templates', templates);
+        }
+        await next();
+    };
+}
+const loadBundle = async (filepath, logger)=>{
+    if (!await fs.pathExists(filepath)) return;
+    try {
+        const module = await compatibleRequire(filepath, false);
+        return module;
+    } catch (e) {
+        logger.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
+        return;
+    }
+};
+async function getServerManifest(pwd, routes, logger) {
+    const loaderBundles = {};
+    const renderBundles = {};
+    await Promise.all(routes.filter((route)=>Boolean(route.bundle)).map(async (route)=>{
+        const entryName = route.entryName || MAIN_ENTRY_NAME;
+        const renderBundlePath = path.join(pwd, route.bundle || '');
+        const loaderBundlePath = path.join(pwd, SERVER_BUNDLE_DIRECTORY, `${entryName}-server-loaders.js`);
+        const renderBundle = await loadBundle(renderBundlePath, logger);
+        const loaderBundle = await loadBundle(loaderBundlePath, logger);
+        renderBundle && (renderBundles[entryName] = renderBundle);
+        loaderBundle && (loaderBundles[entryName] = loaderBundle?.loadModules ? await loaderBundle?.loadModules() : loaderBundle);
+    }));
+    const loadableUri = path.join(pwd, LOADABLE_STATS_FILE);
+    const loadableStats = await compatibleRequire(loadableUri).catch((_)=>({}));
+    const routesManifestUri = path.join(pwd, ROUTE_MANIFEST_FILE);
+    const routeManifest = await compatibleRequire(routesManifestUri).catch((_)=>({}));
+    const nestedRoutesJsonPath = path.join(pwd, NESTED_ROUTE_SPEC_FILE);
+    const nestedRoutesJson = await compatibleRequire(nestedRoutesJsonPath).catch((_)=>({}));
+    return {
+        loaderBundles,
+        renderBundles,
+        loadableStats,
+        routeManifest,
+        nestedRoutesJson
+    };
+}
+function injectServerManifest(pwd, routes, manifestPromise) {
+    return async (c, next)=>{
+        if (routes && !c.get('serverManifest')) {
+            const logger = c.get('logger');
+            const serverManifest = await (manifestPromise || getServerManifest(pwd, routes, logger));
+            c.set('serverManifest', serverManifest);
+        }
+        await next();
+    };
+}
+async function getRscServerManifest(pwd) {
+    const rscServerManifest = await compatibleRequire(path.join(pwd, 'bundles', 'react-server-manifest.json')).catch((_)=>void 0);
+    return rscServerManifest;
+}
+async function getClientManifest(pwd) {
+    const rscClientManifest = await compatibleRequire(path.join(pwd, 'react-client-manifest.json')).catch((_)=>void 0);
+    return rscClientManifest;
+}
+async function getRscSSRManifest(pwd) {
+    const rscSSRManifest = await compatibleRequire(path.join(pwd, 'react-ssr-manifest.json')).catch((_)=>void 0);
+    return rscSSRManifest;
+}
+const injectRscManifestPlugin = (enableRsc)=>({
+        name: '@modern-js/plugin-inject-rsc-manifest',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, distDirectory: pwd } = api.getServerContext();
+                if (!enableRsc) return;
+                middlewares.push({
+                    name: 'inject-rsc-manifest',
+                    handler: async (c, next)=>{
+                        if (!c.get('rscServerManifest')) {
+                            const rscServerManifest = await getRscServerManifest(pwd);
+                            c.set('rscServerManifest', rscServerManifest);
+                        }
+                        if (!c.get('rscClientManifest')) {
+                            const rscClientManifest = await getClientManifest(pwd);
+                            c.set('rscClientManifest', rscClientManifest);
+                        }
+                        if (!c.get('rscSSRManifest')) {
+                            const rscSSRManifest = await getRscSSRManifest(pwd);
+                            c.set('rscSSRManifest', rscSSRManifest);
+                        }
+                        await next();
+                    }
+                });
+            });
+        }
+    });
+const injectResourcePlugin = ()=>({
+        name: '@modern-js/plugin-inject-resource',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, routes, distDirectory: pwd } = api.getServerContext();
+                let htmlTemplatePromise;
+                let manifestPromise;
+                if (isProd()) {
+                    manifestPromise = getServerManifest(pwd, routes || [], console);
+                    htmlTemplatePromise = getHtmlTemplates(pwd, routes || []);
+                }
+                middlewares.push({
+                    name: 'inject-server-manifest',
+                    handler: injectServerManifest(pwd, routes, manifestPromise)
+                });
+                middlewares.push({
+                    name: 'inject-html',
+                    handler: injectTemplates(pwd, routes, htmlTemplatePromise)
+                });
+            });
+        }
+    });
+export { getClientManifest, getHtmlTemplates, getRscSSRManifest, getRscServerManifest, getServerManifest, injectResourcePlugin, injectRscManifestPlugin, injectServerManifest, injectTemplates };

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

@@ -0,0 +1,118 @@
+import path from "path";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+import { fs } from "@modern-js/utils";
+import { getMimeType } from "hono/utils/mime";
+import { sortRoutes } from "../../../utils";
+import { getPublicDirPatterns } from "../../../utils/publicDir";
+const serverStaticPlugin = ()=>({
+        name: '@modern-js/plugin-server-static',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, distDirectory: pwd, routes } = api.getServerContext();
+                const config = api.getServerConfig();
+                const serverStaticMiddleware = createStaticMiddleware({
+                    pwd: pwd,
+                    routes,
+                    output: config.output || {},
+                    html: config.html || {},
+                    server: config.server || {}
+                });
+                middlewares.push({
+                    name: 'server-static',
+                    handler: serverStaticMiddleware
+                });
+            });
+        }
+    });
+function createPublicMiddleware({ pwd, routes }) {
+    return async (c, next)=>{
+        const route = matchPublicRoute(c.req, routes);
+        if (route) {
+            const { entryPath } = route;
+            const filename = path.join(pwd, entryPath);
+            const data = await fileReader.readFile(filename, 'buffer');
+            const mimeType = getMimeType(filename);
+            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);
+                });
+                return c.body(body, 200);
+            }
+        }
+        return await next();
+    };
+}
+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 extractPathname = (url)=>{
+    try {
+        if (url.includes('://')) return new URL(url).pathname || '/';
+        if (url.startsWith('//')) return new URL(`http:${url}`).pathname || '/';
+        return url;
+    } catch (e) {
+        return url;
+    }
+};
+function createStaticMiddleware(options) {
+    const { pwd, routes } = options;
+    const prefix = options.output.assetPrefix || '/';
+    const pathPrefix = extractPathname(prefix);
+    const { distPath: { css: cssPath, js: jsPath, media: mediaPath } = {} } = options.output;
+    const { favicon } = options.html;
+    const { publicDir } = options.server;
+    const favicons = prepareFavicons(favicon);
+    const staticFiles = [
+        cssPath,
+        jsPath,
+        mediaPath
+    ].filter((v)=>Boolean(v));
+    const publicDirPatterns = getPublicDirPatterns(publicDir);
+    const staticReg = [
+        'static/',
+        'upload/',
+        ...staticFiles,
+        ...publicDirPatterns
+    ];
+    const iconReg = [
+        'favicon.ico',
+        'icon.png',
+        ...favicons
+    ];
+    const regPrefix = pathPrefix.endsWith('/') ? pathPrefix : `${pathPrefix}/`;
+    const staticPathRegExp = new RegExp(`^${regPrefix}(${[
+        ...staticReg,
+        ...iconReg
+    ].join('|')})`);
+    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);
+        if (!hit) return createPublicMiddleware({
+            pwd,
+            routes: routes || []
+        })(c, next);
+        {
+            const filepath = path.join(pwd, pathname.replace(pathPrefix, ()=>''));
+            if (!await fs.pathExists(filepath)) return next();
+            const mimeType = getMimeType(filepath);
+            if (mimeType) c.header('Content-Type', mimeType);
+            const stat = await fs.lstat(filepath);
+            const { size } = stat;
+            const chunk = await fileReader.readFileFromSystem(filepath, 'buffer');
+            c.header('Content-Length', String(size));
+            if (null === chunk) return next();
+            const body = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+            return c.body(body, 200);
+        }
+    };
+}
+const prepareFavicons = (favicon)=>{
+    const faviconNames = [];
+    if (favicon && 'string' == typeof favicon) faviconNames.push(favicon.substring(favicon.lastIndexOf('/') + 1));
+    return faviconNames;
+};
+export { createPublicMiddleware, createStaticMiddleware, serverStaticPlugin };

package/dist/esm/constants.mjs

@@ -0,0 +1,28 @@
+const AGGRED_DIR = {
+    mock: 'config/mock',
+    server: 'server',
+    api: 'api',
+    shared: 'shared',
+    lambda: 'lambda'
+};
+const REPLACE_REG = {
+    before: {
+        head: '<head\\b[^>]*>',
+        body: '<body\\b[^>]*>'
+    },
+    after: {
+        head: '</head>',
+        body: '</body>'
+    }
+};
+var constants_ServerTimings = /*#__PURE__*/ function(ServerTimings) {
+    ServerTimings["SERVER_HANDLE_REQUEST"] = "server-handle-request";
+    ServerTimings["SERVER_MIDDLEWARE"] = "server-middleware";
+    ServerTimings["SERVER_HOOK_AFTER_RENDER"] = "server-hook-after-render";
+    ServerTimings["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
+    return ServerTimings;
+}({});
+const SERVER_TIMING = 'Server-Timing';
+const X_RENDER_CACHE = 'x-render-cache';
+const X_MODERNJS_RENDER = 'x-modernjs-render';
+export { AGGRED_DIR, REPLACE_REG, SERVER_TIMING, constants_ServerTimings as ServerTimings, X_MODERNJS_RENDER, X_RENDER_CACHE };

package/dist/{esm-node/context.js → esm/context.mjs}

@@ -1,6 +1,3 @@
 import { createStorage } from "./utils/storage";
 const { run, useHonoContext } = createStorage();
-export {
-  run,
-  useHonoContext
-};
+export { run, useHonoContext };

package/dist/esm/helper.mjs

@@ -0,0 +1,11 @@
+const LOADER_CONTEXT = 'loaderContext';
+function getLoaderCtx(c) {
+    const loaderContext = c.get(LOADER_CONTEXT);
+    if (loaderContext) return loaderContext;
+    {
+        const loaderContext = new Map();
+        c.set(LOADER_CONTEXT, loaderContext);
+        return loaderContext;
+    }
+}
+export { getLoaderCtx };

package/dist/esm/hono.mjs

@@ -0,0 +1,3 @@
+import { deleteCookie, getCookie, setCookie } from "hono/cookie";
+import { languageDetector } from "hono/language";
+export { deleteCookie, getCookie, languageDetector, setCookie };

package/dist/esm/index.mjs

@@ -0,0 +1,13 @@
+import { ErrorDigest, createErrorHtml, onError } from "./utils";
+import { getPublicDirConfig, getPublicDirPatterns, getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath, resolvePublicDirPaths } from "./utils/publicDir";
+import { AGGRED_DIR } from "./constants";
+import { createServerBase } from "./serverBase";
+import { useHonoContext } from "./context";
+import { Hono } from "hono";
+import { getLoaderCtx } from "./helper";
+export * from "./plugins";
+export * from "./types/plugins";
+export * from "./types/render";
+export * from "./types/config";
+export * from "./types/requestHandler";
+export { AGGRED_DIR, ErrorDigest, Hono, createErrorHtml, createServerBase, getLoaderCtx, getPublicDirConfig, getPublicDirPatterns, getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath, onError, resolvePublicDirPaths, useHonoContext };

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

@@ -0,0 +1,40 @@
+function getHookRunners(context) {
+    const { hooks } = context;
+    return {
+        config: (params)=>hooks.modifyConfig.call(params),
+        prepare: ()=>hooks.onPrepare.call(),
+        reset: (params)=>hooks.onReset.call(params),
+        fallback: (input)=>hooks.fallback.call(input),
+        prepareWebServer: (input)=>hooks.prepareWebServer.call(input),
+        prepareApiServer: (input)=>hooks.prepareApiServer.call(input),
+        afterMatch: (ctx)=>hooks.afterMatch.call(ctx),
+        afterRender: (ctx)=>hooks.afterRender.call(ctx),
+        afterStreamingRender: (ctx)=>hooks.afterStreamingRender.call(ctx)
+    };
+}
+function transformHookRunner(hookRunnerName) {
+    switch(hookRunnerName){
+        case 'config':
+            return 'modifyConfig';
+        case 'prepare':
+            return 'onPrepare';
+        case 'reset':
+            return 'onReset';
+        default:
+            return hookRunnerName;
+    }
+}
+function handleSetupResult(setupResult, api) {
+    if (!setupResult) return;
+    Object.keys(setupResult).forEach((key)=>{
+        const fn = setupResult[key];
+        if ('function' == typeof fn) {
+            const newAPI = transformHookRunner(key);
+            if (api[newAPI]) api[newAPI]((...params)=>{
+                const res = fn(...params);
+                return res;
+            });
+        }
+    });
+}
+export { getHookRunners, handleSetupResult, transformHookRunner };

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

@@ -0,0 +1,27 @@
+import { createAsyncHook, createAsyncPipelineHook } from "@modern-js/plugin";
+import { getHookRunners, handleSetupResult } from "./hooks";
+const compatPlugin = ()=>({
+        name: '@modern-js/server-compat',
+        registryHooks: {
+            fallback: createAsyncHook(),
+            prepareWebServer: createAsyncPipelineHook(),
+            prepareApiServer: createAsyncPipelineHook(),
+            afterMatch: createAsyncPipelineHook(),
+            afterRender: createAsyncPipelineHook(),
+            afterStreamingRender: createAsyncPipelineHook()
+        },
+        _registryApi: (getServerContext, updateServerContext)=>{
+            const getInternalContext = ()=>getServerContext()._internalContext;
+            return {
+                useConfigContext: ()=>getInternalContext().config,
+                useAppContext: ()=>{
+                    const { _internalContext, ...serverContext } = getServerContext();
+                    return serverContext;
+                },
+                setAppContext: (context)=>updateServerContext(context),
+                useHookRunners: ()=>getHookRunners(getInternalContext())
+            };
+        },
+        setup: ()=>{}
+    });
+export { compatPlugin, handleSetupResult };

package/dist/esm/plugins/default.mjs

@@ -0,0 +1,25 @@
+import { compatPlugin } from "./compat";
+import { logPlugin } from "./log";
+import { initMonitorsPlugin, injectServerTiming, injectloggerPlugin } from "./monitors";
+import { processedByPlugin } from "./processedBy";
+import { injectRenderHandlerPlugin } from "./render";
+import { injectRoutePlugin } from "./route";
+function createSilenceLogger() {
+    return new Proxy({}, {
+        get: ()=>()=>{}
+    });
+}
+function createDefaultPlugins(options = {}) {
+    const plugins = [
+        compatPlugin(),
+        logPlugin(),
+        initMonitorsPlugin(),
+        injectRenderHandlerPlugin(options),
+        injectloggerPlugin(options.logger ? options.logger : createSilenceLogger()),
+        injectServerTiming(),
+        processedByPlugin(),
+        injectRoutePlugin()
+    ];
+    return plugins;
+}
+export { createDefaultPlugins };

package/dist/esm/plugins/favicon.mjs

@@ -0,0 +1,14 @@
+const faviconPlugin = ()=>({
+        name: '@modern-js/plugin-favicon',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'favicon-fallback',
+                    path: '/favicon.ico',
+                    handler: async (c, _next)=>c.body(null, 204)
+                });
+            });
+        }
+    });
+export { faviconPlugin };

package/dist/{esm-node/plugins/index.js → esm/plugins/index.mjs}

@@ -1,4 +1,4 @@
-import { renderPlugin, injectRenderHandlerPlugin, getRenderHandler } from "./render";
+import { getRenderHandler, injectRenderHandlerPlugin, renderPlugin } from "./render";
 import { faviconPlugin } from "./favicon";
 import { injectServerTiming, injectloggerPlugin } from "./monitors";
 import { processedByPlugin } from "./processedBy";
@@ -6,17 +6,4 @@ import { logPlugin } from "./log";
 import { createDefaultPlugins } from "./default";
 import { compatPlugin, handleSetupResult } from "./compat";
 import { injectConfigMiddlewarePlugin } from "./middlewares";
-export {
-  compatPlugin,
-  createDefaultPlugins,
-  faviconPlugin,
-  getRenderHandler,
-  handleSetupResult,
-  injectConfigMiddlewarePlugin,
-  injectRenderHandlerPlugin,
-  injectServerTiming,
-  injectloggerPlugin,
-  logPlugin,
-  processedByPlugin,
-  renderPlugin
-};
+export { compatPlugin, createDefaultPlugins, faviconPlugin, getRenderHandler, handleSetupResult, injectConfigMiddlewarePlugin, injectRenderHandlerPlugin, injectServerTiming, injectloggerPlugin, logPlugin, processedByPlugin, renderPlugin };