@modern-js/server-core 2.53.0 → 2.54.0

package/dist/types/pluginManager.d.ts

@@ -0,0 +1,31 @@
+import type { AppContext, CliConfig, ServerPlugin, ServerConfig } from './types';
+export interface PluginManagerOptions {
+    cliConfig: CliConfig;
+    appContext: AppContext;
+    plugins?: ServerPlugin[];
+    serverConfig?: ServerConfig;
+}
+export declare class PluginManager {
+    #private;
+    constructor(options: PluginManagerOptions);
+    init(): Promise<import("@modern-js/plugin").ToRunners<{
+        config: import("@modern-js/plugin").AsyncWaterfall<ServerConfig>;
+        prepare: import("@modern-js/plugin").AsyncWaterfall<void>;
+        reset: import("@modern-js/plugin").ParallelWorkflow<{
+            event: import("./types").ResetEvent;
+        }>;
+        prepareWebServer: import("@modern-js/plugin").AsyncPipeline<import("./types").WebServerStartInput, import("./types").WebAdapter | import("@modern-js/types").UnstableMiddleware[] | null>;
+        fallback: import("@modern-js/plugin").ParallelWorkflow<{
+            reason: import("./types").FallbackReason;
+            error: unknown;
+            logger: import("@modern-js/types").Logger;
+            metrics?: import("@modern-js/types").Metrics | undefined;
+            reporter?: import("@modern-js/types").Reporter | undefined;
+        }>;
+        prepareApiServer: import("@modern-js/plugin").AsyncPipeline<import("./types").APIServerStartInput, import("hono/types").MiddlewareHandler>;
+        afterMatch: import("@modern-js/plugin").AsyncPipeline<import("@modern-js/types").AfterMatchContext, any>;
+        afterRender: import("@modern-js/plugin").AsyncPipeline<import("@modern-js/types").AfterRenderContext, any>;
+        afterStreamingRender: import("@modern-js/plugin").AsyncPipeline<import("@modern-js/types").AfterStreamingRenderContext, string>;
+    }>>;
+    addPlugins(plugins: ServerPlugin[]): void;
+}

package/dist/types/{base/middlewares → plugins}/customServer/base.d.ts

@@ -1,5 +1,5 @@
 import { HookContext } from '@modern-js/types';
-import type { Context, ServerEnv } from '../../../core/server';
+import type { Context, ServerEnv } from '../../types';
 export type ResArgs = {
     status?: number;
     headers: Headers;

package/dist/types/{base/middlewares → plugins}/customServer/context.d.ts

@@ -1,5 +1,5 @@
 import { AfterMatchContext, AfterRenderContext, MiddlewareContext, AfterStreamingRenderContext, ServerRoute, HookContext } from '@modern-js/types';
-import { Context, ServerEnv } from '../../../core/server';
+import { Context, ServerEnv } from '../../types';
 import type { ServerNodeEnv } from '../../adapters/node/hono';
 import { ResArgs } from './base';
 export declare function getAfterMatchCtx(entryName: string, baseHookCtx: HookContext): AfterMatchContext;

package/dist/types/{base/middlewares → plugins}/customServer/index.d.ts

@@ -1,7 +1,6 @@
-import { ServerRoute } from '@modern-js/types';
+import { ServerRoute, UnstableMiddleware } from '@modern-js/types';
 import { ServerBase } from '../../serverBase';
-import { ServerHookRunner } from '../../../core/plugin';
-import { Middleware, ServerEnv } from '../../../core/server';
+import { ServerHookRunner, Middleware, ServerEnv } from '../../types';
 import type { ServerNodeEnv } from '../../adapters/node/hono';
 export { getLoaderCtx } from './loader';
 export declare class CustomServer {
@@ -12,3 +11,4 @@ export declare class CustomServer {
     getHookMiddleware(entryName: string, routes: ServerRoute[]): Middleware<ServerEnv>;
     getServerMiddleware(): Promise<Middleware<ServerNodeEnv & ServerEnv> | Array<Middleware<ServerNodeEnv & ServerEnv>> | undefined>;
 }
+export declare function getServerMidFromUnstableMid(serverMiddleware: UnstableMiddleware[]): Array<Middleware<ServerNodeEnv & ServerEnv>>;

package/dist/types/{base/middlewares → plugins}/customServer/loader.d.ts

@@ -1,4 +1,4 @@
-import type { Context } from '../../../core/server';
+import type { Context } from '../../types';
 type LoaderContext = Map<string, unknown>;
 type Var = {
     loaderContext: LoaderContext;

package/dist/types/plugins/favicon.d.ts

@@ -0,0 +1,2 @@
+import { ServerPlugin } from '../types';
+export declare const faviconPlugin: () => ServerPlugin;

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

@@ -0,0 +1,6 @@
+export { renderPlugin, getRenderHandler, type RenderPluginOptions, type GetRenderHandlerOptions, } from './render';
+export { faviconPlugin } from './favicon';
+export { processedByPlugin } from './processedBy';
+export { getLoaderCtx } from './customServer';
+export { logPlugin } from './log';
+export { monitorPlugin } from './monitor';

package/dist/types/plugins/log.d.ts

@@ -0,0 +1,2 @@
+import type { ServerPlugin } from '../types';
+export declare const logPlugin: () => ServerPlugin;

package/dist/types/plugins/monitor.d.ts

@@ -0,0 +1,9 @@
+import { Logger, Metrics, Reporter } from '@modern-js/types';
+import { Context, Next, ServerEnv, ServerPlugin } from '../types';
+export interface MonitorOptions {
+    logger?: Logger;
+    metrics?: Metrics;
+    reporter?: Reporter;
+}
+export declare function initReporter(entryName: string): (c: Context<ServerEnv>, next: Next) => Promise<void>;
+export declare const monitorPlugin: (options: MonitorOptions) => ServerPlugin;

package/dist/types/plugins/processedBy.d.ts

@@ -0,0 +1,2 @@
+import { ServerPlugin } from '../types';
+export declare const processedByPlugin: () => ServerPlugin;

package/dist/types/plugins/render/index.d.ts

@@ -0,0 +1,16 @@
+import { ServerRoute } from '@modern-js/types';
+import { ServerPlugin, Render, UserConfig, CacheConfig } from '../../types';
+export interface RenderPluginOptions {
+    staticGenerate?: boolean;
+    cacheConfig?: CacheConfig;
+}
+export declare const renderPlugin: (options?: RenderPluginOptions) => ServerPlugin;
+export interface GetRenderHandlerOptions {
+    pwd: string;
+    routes: ServerRoute[];
+    config: UserConfig;
+    cacheConfig?: CacheConfig;
+    staticGenerate?: boolean;
+    metaName?: string;
+}
+export declare function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate, }: GetRenderHandlerOptions): Promise<Render>;

package/dist/types/{base/middlewares/renderHandler → plugins/render}/render.d.ts

@@ -1,19 +1,20 @@
 import { Logger, Metrics, Reporter, ServerRoute } from '@modern-js/types';
-import type { FallbackReason } from '../../../core/plugin';
-import { Render } from '../../../core/render';
+import type { CacheConfig, FallbackReason } from '../../types';
+import { Render } from '../../types';
 export type OnFallback = (reason: FallbackReason, utils: {
     logger: Logger;
     metrics?: Metrics;
     reporter?: Reporter;
 }, error?: unknown) => Promise<void>;
 interface CreateRenderOptions {
-    routes: ServerRoute[];
     pwd: string;
+    routes: ServerRoute[];
+    cacheConfig?: CacheConfig;
     staticGenerate?: boolean;
     onFallback?: OnFallback;
     metaName?: string;
     forceCSR?: boolean;
     nonce?: string;
 }
-export declare function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce, onFallback: onFallbackFn, }: CreateRenderOptions): Promise<Render>;
+export declare function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, nonce, onFallback: onFallbackFn, }: CreateRenderOptions): Promise<Render>;
 export {};

package/dist/types/plugins/render/ssrCache.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { IncomingMessage } from 'http';
+import type * as nodeStream from 'stream';
+import type { CacheControl, CacheOption, Container } from '@modern-js/types';
+import type { SSRServerContext, ServerRender } from '../../types';
+export type CacheStatus = 'hit' | 'stale' | 'expired' | 'miss';
+export type CacheResult = {
+    data: string | nodeStream.Readable | ReadableStream;
+    status?: CacheStatus;
+};
+export declare function matchCacheControl(cacheOption?: CacheOption, req?: IncomingMessage): CacheControl | Promise<CacheControl> | undefined;
+export interface GetCacheResultOptions {
+    cacheControl: CacheControl;
+    render: ServerRender;
+    ssrContext: SSRServerContext;
+    container?: Container;
+}
+export declare function getCacheResult(request: Request, options: GetCacheResultOptions): Promise<CacheResult>;

package/dist/types/{base/middlewares/renderHandler → plugins/render}/ssrRender.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import type { IncomingMessage } from 'http';
 import type { Logger, Metrics, Reporter, ServerRoute } from '@modern-js/types';
-import { ServerManifest } from '../../../core/server';
+import { CacheConfig, ServerManifest } from '../../types';
 export type Params = Record<string, any>;
 export interface SSRRenderOptions {
     pwd: string;
@@ -15,10 +15,11 @@ export interface SSRRenderOptions {
     params: Params;
     /** Produce by custom server hook */
     locals?: Record<string, any>;
+    cacheConfig?: CacheConfig;
     reporter?: Reporter;
     metrics?: Metrics;
     nodeReq?: IncomingMessage;
     nonce?: string;
 }
-export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, }: SSRRenderOptions): Promise<Response>;
+export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, cacheConfig, }: SSRRenderOptions): Promise<Response>;
 export declare function getPathnameFromNodeReq(nodeReq: IncomingMessage): string;

package/dist/types/{base/serverBase.d.ts → serverBase.d.ts}

@@ -1,8 +1,7 @@
-import { InternalPlugins, ServerRoute } from '@modern-js/types';
+import { ServerRoute } from '@modern-js/types';
 import { Hono } from 'hono';
-import { ServerHookRunner, ServerPlugin } from '../core';
-import type { Env } from '../core/server';
-import type { ServerOptions } from '../types/config';
+import type { Env, ServerConfig, ServerHookRunner, ServerPlugin } from './types';
+import type { CliConfig } from './types/config';
 declare module '@modern-js/types' {
     interface ISAppContext {
         serverBase?: ServerBase;
@@ -11,11 +10,10 @@ declare module '@modern-js/types' {
 export type ServerBaseOptions = {
     /** server working directory, and then also dist directory */
     pwd: string;
-    config: ServerOptions;
-    serverConfigFile?: string;
+    config: CliConfig;
+    serverConfig?: ServerConfig;
+    metaName?: string;
     routes?: ServerRoute[];
-    plugins?: ServerPlugin[];
-    internalPlugins?: InternalPlugins;
     appContext: {
         appDirectory?: string;
         sharedDirectory?: string;
@@ -25,36 +23,21 @@ export type ServerBaseOptions = {
     runMode?: 'apiOnly' | 'ssrOnly' | 'webOnly';
 };
 export declare class ServerBase<E extends Env = any> {
+    #private;
     options: ServerBaseOptions;
     runner: ServerHookRunner;
     private app;
-    private serverConfig;
+    private appContext;
+    private pluginManager;
     constructor(options: ServerBaseOptions);
     /**
      * 初始化顺序
-     * - 获取 server runtime config
-     * - 设置 context
-     * - 创建 hooksRunner
-     * - 合并插件，内置插件和 serverConfig 中配置的插件
-     * - 执行 config hook
-     * - 获取最终的配置
-     * - 设置配置到 context
-     * - 执行 prepare hook
+     * - 初始化 pluginManager;
+     * - 执行 runner.prepare;
+     * - 应用 middlewares
      */
     init(): Promise<this>;
-    private createHookRunner;
-    private loadInternalPlugins;
-    private loadExternalPlugins;
-    private initServerConfig;
-    private injectContext;
-    private initAppContext;
-    /**
-     * Execute config hooks
-     * @param runner
-     * @param options
-     */
-    private runConfigHook;
-    private initConfig;
+    addPlugins(plugins: ServerPlugin[]): void;
     get all(): import("hono/types").HandlerInterface<E, "all", {}, "/">;
     get use(): import("hono/types").MiddlewareHandlerInterface<E, {}, "/">;
     get get(): import("hono/types").HandlerInterface<E, "get", {}, "/">;

package/dist/types/types/config/index.d.ts

@@ -38,3 +38,4 @@ export type ServerOptions = {
     dev?: DevNormalizedConfig;
     security?: SecurityNormalizedConfig;
 };
+export type CliConfig = Required<UserConfig>;

package/dist/types/types/config/server.d.ts

@@ -36,6 +36,7 @@ export type SSR = boolean | {
     disablePrerender?: boolean;
     unsafeHeaders?: string[];
     scriptLoading?: 'defer' | 'blocking' | 'module' | 'async';
+    loaderFailureMode?: 'clientRender' | 'errorBoundary';
 };
 export type SSRByEntries = Record<string, SSR>;
 export interface ServerUserConfig {

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

@@ -0,0 +1,4 @@
+export * from './config';
+export * from './plugin';
+export * from './render';
+export * from './server';

package/dist/types/types/plugin.d.ts

@@ -0,0 +1,134 @@
+/// <reference types="node" />
+/** Hooks */
+import type { Server as NodeServer, IncomingMessage, ServerResponse } from 'http';
+import { AsyncWaterfall, ParallelWorkflow, ToRunners, ToThreads, CommonAPI, PluginOptions, AsyncSetup, createContext, AsyncPipeline } from '@modern-js/plugin';
+import { AfterMatchContext, AfterRenderContext, AfterStreamingRenderContext, CacheOption, Container, HttpMethodDecider, ISAppContext, Logger, Metrics, MiddlewareContext, Reporter, ServerRoute, UnstableMiddleware } from '@modern-js/types';
+import { MiddlewareHandler } from 'hono';
+import { UserConfig } from './config';
+import { Render } from './render';
+export type ChangeEvent = 'add' | 'change' | 'unlink';
+export interface Change {
+    filename: string;
+    event: ChangeEvent;
+}
+export interface RepackEvent {
+    type: 'repack';
+}
+export interface FileChangeEvent {
+    type: 'file-change';
+    payload: Change[];
+}
+export type ResetEvent = RepackEvent | FileChangeEvent;
+export type FallbackReason = 'error' | 'header' | 'query';
+type FallbackInput = {
+    reason: FallbackReason;
+    error: unknown;
+    logger: Logger;
+    metrics?: Metrics;
+    reporter?: Reporter;
+};
+export type APIServerStartInput = {
+    pwd: string;
+    prefix?: string;
+    httpMethodDecider?: HttpMethodDecider;
+    config?: {
+        middleware?: Array<any>;
+    };
+    render?: Render | null;
+};
+export type WebServerStartInput = {
+    pwd: string;
+    config: Record<string, any>;
+};
+export type WebAdapter = (ctx: MiddlewareContext) => void | Promise<void>;
+export interface ServerHooks {
+    config: AsyncWaterfall<ServerConfig>;
+    prepare: AsyncWaterfall<void>;
+    reset: ParallelWorkflow<{
+        event: ResetEvent;
+    }>;
+    /**
+     * @deprecated
+     *
+     * deprecate it next major version
+     * */
+    prepareWebServer: AsyncPipeline<WebServerStartInput, WebAdapter | Array<UnstableMiddleware> | null>;
+    /**
+     * @deprecated
+     *
+     * deprecate it when server runtime entry refactor
+     *
+     */
+    fallback: ParallelWorkflow<FallbackInput>;
+    /**
+     * @deprecated
+     *
+     * deprecate it next major version
+     */
+    prepareApiServer: AsyncPipeline<APIServerStartInput, MiddlewareHandler>;
+    /**
+     * @deprecated
+     *
+     * deprecate it next major version
+     */
+    afterMatch: AsyncPipeline<AfterMatchContext, any>;
+    /**
+     * @deprecated
+     *
+     * deprecate it next major version
+     */
+    afterRender: AsyncPipeline<AfterRenderContext, any>;
+    /**
+     * @deprecated
+     *
+     * deprecate it next major version
+     * */
+    afterStreamingRender: AsyncPipeline<AfterStreamingRenderContext, string>;
+}
+export type ServerHookCallback = ToThreads<ServerHooks>;
+/** Plugin Api */
+type MiddlewareOrder = 'pre' | 'post' | 'default';
+type Middleware = {
+    name: string;
+    path?: string;
+    method?: 'options' | 'get' | 'post' | 'put' | 'delete' | 'patch' | 'all';
+    handler: MiddlewareHandler | MiddlewareHandler[];
+    before?: Array<Middleware['name']>;
+    order?: MiddlewareOrder;
+};
+declare module '@modern-js/types' {
+    interface ISAppContext {
+        middlewares: Middleware[];
+        metaName: string;
+        routes?: ServerRoute[];
+        nodeServer?: NodeServer;
+    }
+}
+export type NodeRequest = IncomingMessage;
+export type NodeResponse = ServerResponse;
+export { NodeServer };
+export type AppContext = ReturnType<typeof createContext<ISAppContext>>;
+export type ConfigContext = ReturnType<typeof createContext<ServerConfig>>;
+export type ServerPluginAPI = {
+    setAppContext: (c: ISAppContext) => void;
+    useAppContext: () => ISAppContext;
+    useConfigContext: () => ServerConfig;
+};
+export type PluginAPI = ServerPluginAPI & CommonAPI<ServerHooks>;
+/** Runner */
+export type ServerHookRunner = ToRunners<ServerHooks>;
+/** Plugin options of a server plugin. */
+export type ServerPlugin = PluginOptions<ServerHooks, AsyncSetup<ServerHooks, PluginAPI>>;
+export type CacheConfig = {
+    strategy: CacheOption;
+    container?: Container;
+};
+type RenderMiddleware = UnstableMiddleware;
+export interface RenderConfig {
+    cache?: CacheConfig;
+    middleware?: RenderMiddleware[];
+}
+export type ServerConfig = {
+    render?: RenderConfig;
+    plugins?: ServerPlugin[];
+} & UserConfig;

package/dist/types/{base/utils → utils}/index.d.ts

@@ -5,3 +5,4 @@ export * from './error';
 export * from './warmup';
 export * from './entry';
 export * from './request';
+export * from './serverConfig';

package/dist/types/utils/serverConfig.d.ts

@@ -0,0 +1,8 @@
+import { CliConfig, ServerConfig } from '../types';
+/**
+ * 对配置进行合并，cliConfig 与 serverConfig 进行深合并
+ */
+export declare const loadConfig: ({ cliConfig, serverConfig, }: {
+    cliConfig: CliConfig;
+    serverConfig: ServerConfig;
+}) => ServerConfig;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.53.0",
+  "version": "2.54.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -23,26 +23,13 @@
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
-      "node": {
-        "jsnext:source": "./src/index.ts",
-        "import": "./dist/esm/index.js",
-        "require": "./dist/cjs/index.js"
-      },
+      "import": "./dist/esm-node/index.d.ts",
       "default": "./dist/cjs/index.js"
     },
-    "./base": {
-      "types": "./dist/types/base/index.d.ts",
-      "jsnext:source": "./src/base/index.ts",
-      "node": {
-        "require": "./dist/cjs/base/index.js",
-        "import": "./dist/esm/base/index.js"
-      },
-      "default": "./dist/esm-node/base/index.js"
-    },
-    "./base/node": {
-      "types": "./dist/types/base/adapters/node/index.d.ts",
-      "import": "./dist/esm/base/adapters/node/index.js",
-      "default": "./dist/cjs/base/adapters/node/index.js"
+    "./node": {
+      "types": "./dist/types/adapters/node/index.d.ts",
+      "import": "./dist/esm-node/adapters/node/index.js",
+      "default": "./dist/cjs/adapters/node/index.js"
     }
   },
   "typesVersions": {
@@ -50,11 +37,8 @@
       ".": [
         "./dist/types/index.d.ts"
       ],
-      "base": [
-        "./dist/types/base/index.d.ts"
-      ],
-      "base/node": [
-        "./dist/types/base/adapters/node/index.d.ts"
+      "node": [
+        "./dist/types/adapters/node/index.d.ts"
       ]
     }
   },
@@ -67,11 +51,11 @@
     "@web-std/stream": "^1.0.3",
     "@web-std/file": "^3.0.3",
     "hono": "^3.12.2",
+    "deepmerge-ts": "7.0.2",
     "isbot": "3.8.0",
-    "merge-deep": "^3.0.3",
-    "@modern-js/plugin": "2.53.0",
-    "@modern-js/runtime-utils": "2.53.0",
-    "@modern-js/utils": "2.53.0"
+    "@modern-js/runtime-utils": "2.54.0",
+    "@modern-js/utils": "2.54.0",
+    "@modern-js/plugin": "2.54.0"
   },
   "devDependencies": {
     "@types/jest": "^29",
@@ -81,9 +65,9 @@
     "jest": "^29",
     "ts-jest": "^29.1.0",
     "typescript": "^5",
-    "@scripts/build": "2.53.0",
-    "@modern-js/types": "2.53.0",
-    "@scripts/jest-config": "2.53.0"
+    "@scripts/build": "2.54.0",
+    "@modern-js/types": "2.54.0",
+    "@scripts/jest-config": "2.54.0"
   },
   "sideEffects": false,
   "publishConfig": {

package/dist/cjs/base/adapters/node/bff.js

@@ -1,70 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var bff_exports = {};
-__export(bff_exports, {
-  bindBFFHandler: () => bindBFFHandler
-});
-module.exports = __toCommonJS(bff_exports);
-var import_utils = require("@modern-js/utils");
-var import_middlewares = require("../../../base/middlewares");
-var import_utils2 = require("../../utils");
-const bindBFFHandler = async (server, options) => {
-  var _options_config_bff, _options_config, _options_config_bff1, _options_config1, _options_config_bff2, _options_config2;
-  const prefix = (options === null || options === void 0 ? void 0 : (_options_config = options.config) === null || _options_config === void 0 ? void 0 : (_options_config_bff = _options_config.bff) === null || _options_config_bff === void 0 ? void 0 : _options_config_bff.prefix) || "/api";
-  const enableHandleWeb = options === null || options === void 0 ? void 0 : (_options_config1 = options.config) === null || _options_config1 === void 0 ? void 0 : (_options_config_bff1 = _options_config1.bff) === null || _options_config_bff1 === void 0 ? void 0 : _options_config_bff1.enableHandleWeb;
-  const httpMethodDecider = options === null || options === void 0 ? void 0 : (_options_config2 = options.config) === null || _options_config2 === void 0 ? void 0 : (_options_config_bff2 = _options_config2.bff) === null || _options_config_bff2 === void 0 ? void 0 : _options_config_bff2.httpMethodDecider;
-  const runtimeEnv = (0, import_utils2.getRuntimeEnv)();
-  if (runtimeEnv !== "node") {
-    return;
-  }
-  const { getMiddlewares, ...collector } = (0, import_utils2.createMiddlewareCollecter)();
-  const { runner } = server;
-  await runner.gather(collector);
-  const webOnly = await (0, import_utils.isWebOnly)();
-  let handler;
-  if (webOnly) {
-    handler = async (c, next) => {
-      c.body("");
-      await next();
-    };
-  } else {
-    const renderHandler = enableHandleWeb ? await (0, import_middlewares.getRenderHandler)(options, server) : null;
-    handler = await server.runner.prepareApiServer({
-      pwd: options.pwd,
-      prefix,
-      render: renderHandler,
-      httpMethodDecider
-    }, {
-      onLast: () => null
-    });
-  }
-  if (handler) {
-    server.all(`*`, (c, next) => {
-      if (!c.req.path.startsWith(prefix) && !enableHandleWeb) {
-        return next();
-      } else {
-        return handler(c, next);
-      }
-    });
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  bindBFFHandler
-});