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

package/dist/esm-node/rslib-runtime.mjs

@@ -0,0 +1,19 @@
+import "node:module";
+var __webpack_modules__ = {};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+export { __webpack_require__ };

package/dist/esm-node/serverBase.mjs

@@ -0,0 +1,140 @@
+import "node:module";
+import { server as server_server } from "@modern-js/plugin/server";
+import { Hono } from "hono";
+import { run } from "./context.mjs";
+import { handleSetupResult } from "./plugins/compat/hooks.mjs";
+import { loadConfig } from "./utils/index.mjs";
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+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;
+    }
+    addPlugins(plugins) {
+        this.plugins.push(...plugins);
+    }
+    get hooks() {
+        return this.serverContext.hooks;
+    }
+    get all() {
+        return this.app.all.bind(this.app);
+    }
+    get use() {
+        return this.app.use.bind(this.app);
+    }
+    get get() {
+        return this.app.get.bind(this.app);
+    }
+    get options() {
+        return this.app.options.bind(this.app);
+    }
+    get post() {
+        return this.app.post.bind(this.app);
+    }
+    get put() {
+        return this.app.put.bind(this.app);
+    }
+    get delete() {
+        return this.app.delete.bind(this.app);
+    }
+    get patch() {
+        return this.app.patch.bind(this.app);
+    }
+    get handle() {
+        return this.app.fetch.bind(this.app);
+    }
+    get request() {
+        return this.app.request.bind(this.app);
+    }
+    get notFound() {
+        return this.app.notFound.bind(this.app);
+    }
+    get onError() {
+        return this.app.onError.bind(this.app);
+    }
+    constructor(options){
+        _class_private_method_init(this, _applyMiddlewares);
+        this.plugins = [];
+        this.serverContext = null;
+        this.serverOptions = options;
+        this.app = new Hono();
+        this.app.use('*', run);
+    }
+}
+function applyMiddlewares() {
+    const { middlewares } = this.serverContext;
+    const preMiddlewares = [];
+    const defaultMiddlewares = [];
+    const postMiddlewares = [];
+    for (const middleware of middlewares)switch(middleware.order){
+        case 'pre':
+            preMiddlewares.push(middleware);
+            break;
+        case 'post':
+            postMiddlewares.push(middleware);
+            break;
+        default:
+            defaultMiddlewares.push(middleware);
+    }
+    const finalMiddlewares = [];
+    const insertMiddleware = (middleware)=>{
+        if (middleware.before) {
+            const targetIndex = finalMiddlewares.findIndex((item)=>{
+                if (middleware.before?.includes(item.name)) return true;
+                return false;
+            });
+            if (-1 !== targetIndex) finalMiddlewares.splice(targetIndex, 0, middleware);
+            else finalMiddlewares.push(middleware);
+        } else finalMiddlewares.push(middleware);
+    };
+    preMiddlewares.forEach(insertMiddleware);
+    defaultMiddlewares.forEach(insertMiddleware);
+    postMiddlewares.forEach(insertMiddleware);
+    for (const middleware of finalMiddlewares){
+        const { path = '*', method = 'all', handler } = middleware;
+        const handlers = handler2Handlers(handler);
+        if (0 === handlers.length) continue;
+        const firstHandler = handlers[0];
+        const restHandlers = handlers.slice(1);
+        const m = method;
+        const register = this.app[m];
+        register.call(this.app, path, firstHandler, ...restHandlers);
+    }
+    function handler2Handlers(handler) {
+        if (Array.isArray(handler)) return handler;
+        return [
+            handler
+        ];
+    }
+}
+function createServerBase(options) {
+    if (null == options) throw new Error('can not start server without options');
+    const server = new ServerBase(options);
+    return server;
+}
+export { ServerBase, createServerBase };

package/dist/esm-node/types/config/bff.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/types/config/dev.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/types/config/html.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/types/config/index.mjs

@@ -0,0 +1,7 @@
+import "node:module";
+export * from "./bff.mjs";
+export * from "./html.mjs";
+export * from "./output.mjs";
+export * from "./server.mjs";
+export * from "./source.mjs";
+export * from "./tools.mjs";

package/dist/esm-node/types/config/output.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/types/config/security.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/types/config/server.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/types/config/share.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/types/config/source.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/types/config/tools.mjs

@@ -0,0 +1 @@
+import "node:module";

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

@@ -0,0 +1,5 @@
+import "node:module";
+export * from "./config/index.mjs";
+export * from "./plugins/index.mjs";
+export * from "./render.mjs";
+export * from "./server.mjs";

package/dist/esm-node/types/plugins/base.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/types/plugins/index.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "./plugin.mjs";

package/dist/esm-node/types/plugins/plugin.mjs

@@ -0,0 +1 @@
+import "node:module";

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

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/types/requestHandler.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/types/server.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/utils/entry.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+const sortRoutes = (route1, route2)=>route2.urlPath.length - route1.urlPath.length;
+const uniqueKeyByRoute = (route)=>`${route.entryName}-${route.urlPath}`;
+export { sortRoutes, uniqueKeyByRoute };

package/dist/esm-node/utils/env.mjs

@@ -0,0 +1,15 @@
+import "node:module";
+const getRuntimeEnv = ()=>{
+    if (globalThis?.process?.release?.name === 'node') return 'node';
+    return 'other';
+};
+const checkIsProd = ()=>{
+    const env = getRuntimeEnv();
+    switch(env){
+        case 'node':
+            return 'production' === process.env.NODE_ENV;
+        default:
+            return false;
+    }
+};
+export { checkIsProd, getRuntimeEnv };

package/dist/esm-node/utils/error.mjs

@@ -0,0 +1,54 @@
+import "node:module";
+import { parseHeaders } from "./request.mjs";
+const ERROR_PAGE_TEXT = {
+    404: 'This page could not be found.',
+    500: 'Internal Server Error.'
+};
+const createErrorHtml = (status)=>{
+    const text = ERROR_PAGE_TEXT[status] || '';
+    const title = `${status}: ${text}`;
+    return `<!DOCTYPE html>
+  <html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width">
+    <title>${title}</title>
+    <style>
+      html,body {
+        margin: 0;
+      }
+
+      .page-container {
+        color: #000;
+        background: #fff;
+        height: 100vh;
+        text-align: center;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="page-container">
+    <h1>${status}</h1>
+    <div>${text}</div>
+  </body>
+  </html>
+  `;
+};
+var error_ErrorDigest = /*#__PURE__*/ function(ErrorDigest) {
+    ErrorDigest["ENOTF"] = "Page could not be found";
+    ErrorDigest["EINTER"] = "Internal server error";
+    ErrorDigest["ERENDER"] = "SSR render fallback";
+    return ErrorDigest;
+}({});
+function onError(digest, error, monitors, req) {
+    const headerData = req && parseHeaders(req);
+    headerData && delete headerData.cookie;
+    if (monitors) monitors.error(req ? `Server Error - ${digest}, error = %s, req.url = %s, req.headers = %o` : `Server Error - ${digest}, error = %s`, error instanceof Error ? error.stack || error.message : error, req?.url, headerData);
+    else if (req) console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error}, req.url = ${req.url}, req.headers = ${JSON.stringify(headerData)}`);
+    else console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error} `);
+}
+export { createErrorHtml, error_ErrorDigest as ErrorDigest, onError };

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

@@ -0,0 +1,10 @@
+import "node:module";
+export * from "./entry.mjs";
+export * from "./env.mjs";
+export * from "./error.mjs";
+export * from "./middlewareCollector.mjs";
+export * from "./publicDir.mjs";
+export * from "./request.mjs";
+export * from "./serverConfig.mjs";
+export * from "./transformStream.mjs";
+export * from "./warmup.mjs";

package/dist/esm-node/utils/middlewareCollector.mjs

@@ -0,0 +1,27 @@
+import "node:module";
+const mergeExtension = (users)=>{
+    const output = [];
+    return {
+        middleware: output.concat(users)
+    };
+};
+const createMiddlewareCollecter = ()=>{
+    const webMiddlewares = [];
+    const apiMiddlewares = [];
+    const addWebMiddleware = (input)=>{
+        webMiddlewares.push(input);
+    };
+    const addAPIMiddleware = (input)=>{
+        apiMiddlewares.push(input);
+    };
+    const getMiddlewares = ()=>({
+            web: webMiddlewares,
+            api: apiMiddlewares
+        });
+    return {
+        getMiddlewares,
+        addWebMiddleware,
+        addAPIMiddleware
+    };
+};
+export { createMiddlewareCollecter, mergeExtension };

package/dist/esm-node/utils/publicDir.mjs

@@ -0,0 +1,34 @@
+import "node:module";
+import path from "path";
+function normalizePublicDir(publicDir) {
+    if (!publicDir) return [];
+    return Array.isArray(publicDir) ? publicDir : [
+        publicDir
+    ];
+}
+function normalizePublicDirPath(dir) {
+    return dir.replace(/^\.\//, '').replace(/\/$/, '');
+}
+function getPublicDirRoutePrefixes(publicDir) {
+    const dirs = normalizePublicDir(publicDir);
+    return dirs.map((dir)=>{
+        const normalized = normalizePublicDirPath(dir);
+        return `/${normalized}`;
+    });
+}
+function getPublicDirPatterns(publicDir) {
+    const dirs = normalizePublicDir(publicDir);
+    return dirs.map((dir)=>{
+        const normalized = normalizePublicDirPath(dir);
+        return `${normalized}/`;
+    });
+}
+function resolvePublicDirPaths(publicDir, appDirectory) {
+    const dirs = normalizePublicDir(publicDir);
+    if (!appDirectory) return dirs;
+    return dirs.map((dir)=>path.resolve(appDirectory, dir));
+}
+function getPublicDirConfig(serverConfig) {
+    return serverConfig?.publicDir;
+}
+export { getPublicDirConfig, getPublicDirPatterns, getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath, resolvePublicDirPaths };

package/dist/esm-node/utils/request.mjs

@@ -0,0 +1,41 @@
+import "node:module";
+function parseQuery(req) {
+    const query = {};
+    const { url } = req;
+    const q = url.split('?')[1];
+    if (q) {
+        const search = new URLSearchParams(q);
+        search.forEach((v, k)=>{
+            query[k] = v;
+        });
+    }
+    return query;
+}
+function parseHeaders(request) {
+    const headersData = {};
+    request.headers.forEach((value, key)=>{
+        headersData[key] = value;
+    });
+    return headersData;
+}
+function getPathname(request) {
+    const match = request.url.match(/^https?:\/\/[^/]+(\/[^?]*)/);
+    return match?.[1] ?? '/';
+}
+function getHost(request) {
+    const { headers } = request;
+    let host = headers.get('X-Forwarded-Host');
+    if (!host) host = headers.get('Host');
+    host = host?.split(/\s*,\s*/, 1)[0] || 'undefined';
+    return host;
+}
+function parseCookie(req) {
+    const _cookie = req.headers.get('Cookie');
+    const cookie = {};
+    _cookie?.trim().split(';').forEach((item)=>{
+        const [k, v] = item.trim().split('=');
+        if (k && void 0 !== v) cookie[k] = v;
+    });
+    return cookie;
+}
+export { getHost, getPathname, parseCookie, parseHeaders, parseQuery };

package/dist/esm-node/utils/serverConfig.mjs

@@ -0,0 +1,10 @@
+import "node:module";
+import { merge } from "ts-deepmerge";
+const loadConfig = ({ cliConfig, serverConfig })=>{
+    const config = merge({
+        ...cliConfig,
+        plugins: []
+    }, serverConfig);
+    return config;
+};
+export { loadConfig };

package/dist/esm-node/utils/storage.mjs

@@ -0,0 +1,36 @@
+import "node:module";
+import * as __rspack_external_async_hooks from "async_hooks";
+const createStorage = (storageKey)=>{
+    let storage;
+    if (void 0 !== __rspack_external_async_hooks.AsyncLocalStorage) if (storageKey) {
+        const globalStore = globalThis;
+        const sharedStorage = globalStore[storageKey];
+        storage = sharedStorage ?? new __rspack_external_async_hooks.AsyncLocalStorage();
+        globalStore[storageKey] = storage;
+    } else storage = new __rspack_external_async_hooks.AsyncLocalStorage();
+    const run = (context, cb)=>{
+        if (!storage) throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        return new Promise((resolve, reject)=>{
+            storage.run(context, ()=>{
+                try {
+                    return resolve(cb());
+                } catch (error) {
+                    return reject(error);
+                }
+            });
+        });
+    };
+    const useContext = ()=>{
+        if (!storage) throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        const context = storage.getStore();
+        if (!context) throw new Error("Can't call context hook out of server scope");
+        return context;
+    };
+    return {
+        run,
+        useContext
+    };
+};
+export { createStorage };

package/dist/esm-node/utils/transformStream.mjs

@@ -0,0 +1,29 @@
+import "node:module";
+function createTransformStream(fn) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    return new TransformStream({
+        async transform (chunk, controller) {
+            const content = decoder.decode(chunk);
+            const newContent = fn ? await fn(content) : content;
+            controller.enqueue(encoder.encode(newContent));
+        }
+    });
+}
+function transformResponse(response, transformCb) {
+    let readable = null;
+    if (response.body) {
+        const stream = createTransformStream(async (before)=>{
+            if (Array.isArray(transformCb)) return transformCb.reduce(async (before, cb)=>cb(await before), Promise.resolve(before));
+            return transformCb(before);
+        });
+        response.body.pipeThrough(stream);
+        readable = stream.readable;
+    }
+    return new Response(readable, {
+        status: response.status,
+        headers: response.headers,
+        statusText: response.statusText
+    });
+}
+export { createTransformStream, transformResponse };

package/dist/esm-node/utils/warmup.mjs

@@ -0,0 +1,7 @@
+import "node:module";
+function warmup(bundles) {
+    bundles.forEach((bundle)=>{
+        bundle && import(bundle).catch((_)=>{});
+    });
+}
+export { warmup };

package/dist/types/adapters/node/helper/index.d.ts

@@ -0,0 +1,6 @@
+export { loadCacheConfig } from './loadCache';
+export { loadServerCliConfig, loadServerRuntimeConfig } from './loadConfig';
+export { loadServerEnv } from './loadEnv';
+export { loadServerPlugins } from './loadPlugin';
+export type { NodeBindings } from './utils';
+export { isResFinalized } from './utils';

package/dist/types/adapters/node/helper/loadCache.d.ts

@@ -0,0 +1,2 @@
+import type { CacheConfig } from '../../../types';
+export declare function loadCacheConfig(pwd: string): Promise<CacheConfig | undefined>;

package/dist/types/adapters/node/helper/loadConfig.d.ts

@@ -0,0 +1,3 @@
+import type { CliConfig, ServerConfig, UserConfig } from '../../../types';
+export declare function loadServerRuntimeConfig(serverConfigPath: string): Promise<ServerConfig | undefined>;
+export declare function loadServerCliConfig(pwd: string, defaultConfig?: UserConfig): CliConfig;

package/dist/types/adapters/node/helper/loadEnv.d.ts

@@ -0,0 +1,3 @@
+import type { ServerBaseOptions } from '../../../serverBase';
+/** 读取 .env.{process.env.MODERN_ENV} 文件，加载环境变量 */
+export declare function loadServerEnv(options: ServerBaseOptions): Promise<void>;

package/dist/types/adapters/node/helper/loadPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { ServerPlugin } from '@modern-js/types';
+import type { ServerPlugin as ServerPluginInstance } from '../../../types';
+export declare function loadServerPlugins(serverPlugins: ServerPlugin[], appDirectory: string): Promise<ServerPluginInstance[]>;

package/dist/types/adapters/node/helper/utils.d.ts

@@ -0,0 +1,21 @@
+import type { ClientManifest, NodeRequest, NodeResponse, SSRManifest } from '@modern-js/types/server';
+import type { HonoRequest, ServerManifest } from '../../../types';
+type ExtendedNodeRequest = NodeRequest & {
+    __honoRequest?: HonoRequest;
+    __templates?: Record<string, string>;
+    __serverManifest?: ServerManifest;
+    __rscServerManifest?: ServerManifest;
+    __rscClientManifest?: ClientManifest;
+    __rscSSRManifest?: SSRManifest;
+};
+type ExtendedNodeResponse = NodeResponse & {
+    _modernBodyPiped?: boolean;
+};
+export type NodeBindings = {
+    node: {
+        req: ExtendedNodeRequest;
+        res: ExtendedNodeResponse;
+    };
+};
+export declare const isResFinalized: (res: ExtendedNodeResponse) => boolean;
+export {};

package/dist/types/adapters/node/hono.d.ts

@@ -0,0 +1,19 @@
+import type { NodeRequest, NodeResponse } from '@modern-js/types/server';
+import type { Context, Middleware, Next, ServerEnv } from '../../types';
+import { type NodeBindings } from './helper';
+export type ServerNodeEnv = {
+    Bindings: NodeBindings;
+};
+export type ServerNodeMiddleware = Middleware<ServerNodeEnv>;
+export type ServerNodeContext = Context<ServerNodeEnv>;
+type Handler = (req: NodeRequest, res: NodeResponse) => void | Promise<void>;
+export declare const httpCallBack2HonoMid: (handler: Handler) => (context: Context<ServerNodeEnv & ServerEnv>, next: Next) => Promise<void>;
+type ConnectMiddleware = ((req: NodeRequest, res: NodeResponse, callback: (...args: unknown[]) => void) => void) | ((req: NodeRequest, res: NodeResponse) => void);
+export declare const connectMid2HonoMid: (handler: ConnectMiddleware) => Middleware;
+/**
+ * Because we are not sure how use devServer.before and devServer.after, we add a new function to handle the mock middleware
+ * And we supose mock handler always process the res directly
+ * So we need to set the context.finalized = true and resolve the promise
+ */
+export declare const connectMockMid2HonoMid: (handler: ConnectMiddleware) => Middleware;
+export {};

package/dist/types/adapters/node/index.d.ts

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

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

@@ -0,0 +1,17 @@
+import { type Server as NodeServer } from 'node:http';
+import type { Http2SecureServer } from 'node:http2';
+import type { Server as NodeHttpsServer } from 'node:https';
+import type { NodeRequest, NodeResponse } from '@modern-js/types/server';
+import type { RequestHandler } from '../../types';
+export declare const createWebRequest: (req: NodeRequest, res: NodeResponse, body?: BodyInit) => Request;
+export declare const sendResponse: (response: Response, res: NodeResponse) => Promise<void>;
+declare const getRequestListener: (handler: RequestHandler) => (req: NodeRequest, res: NodeResponse) => Promise<void>;
+type NodeServerWrapper = (NodeServer | NodeHttpsServer | Http2SecureServer) & {
+    getRequestListener: () => ReturnType<typeof getRequestListener>;
+    getRequestHandler: () => RequestHandler;
+};
+export declare const createNodeServer: (requestHandler: RequestHandler, httpsOptions?: {
+    key?: string | Buffer;
+    cert?: string | Buffer;
+}, http2?: boolean) => Promise<NodeServerWrapper>;
+export {};

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

@@ -0,0 +1,3 @@
+export * from './nodeServer';
+export * from './resource';
+export * from './static';

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

@@ -0,0 +1,6 @@
+import type { Server as NodeServer } from 'node:http';
+import type { Http2SecureServer } from 'node:http2';
+import type { ServerPlugin } from '../../../types';
+export declare const injectNodeSeverPlugin: ({ nodeServer, }: {
+    nodeServer: NodeServer | Http2SecureServer;
+}) => ServerPlugin;

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

@@ -0,0 +1,11 @@
+import type { Monitors, ServerRoute } from '@modern-js/types';
+import type { Middleware, ServerEnv, ServerManifest, ServerPlugin } from '../../../types';
+export declare function getHtmlTemplates(pwd: string, routes: ServerRoute[]): Promise<Record<string, string>>;
+export declare function injectTemplates(pwd: string, routes?: ServerRoute[], htmlTemplatePromise?: ReturnType<typeof getHtmlTemplates>): Middleware<ServerEnv>;
+export declare function getServerManifest(pwd: string, routes: ServerRoute[], monitors?: Monitors): Promise<ServerManifest>;
+export declare function injectServerManifest(pwd: string, routes?: ServerRoute[], manifestPromise?: Promise<ServerManifest>): Middleware<ServerEnv>;
+export declare function getRscServerManifest(pwd: string): Promise<any>;
+export declare function getClientManifest(pwd: string): Promise<any>;
+export declare function getRscSSRManifest(pwd: string): Promise<any>;
+export declare const injectRscManifestPlugin: (enableRsc: boolean) => ServerPlugin;
+export declare const injectResourcePlugin: () => ServerPlugin;