@modern-js/server-core 2.65.5 → 2.65.6-alpha.0

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

@@ -1,4 +1,6 @@
-import type { NodeServer, ServerPlugin } from '../../../types';
+/// <reference types="node" />
+import type { Server as NodeServer } from 'node:http';
+import type { ServerPluginLegacy } from '../../../types';
 export declare const injectNodeSeverPlugin: ({ nodeServer, }: {
     nodeServer: NodeServer;
-}) => ServerPlugin;
+}) => ServerPluginLegacy;

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

@@ -1,5 +1,5 @@
 import type { Logger, ServerRoute } from '@modern-js/types';
-import type { Middleware, ServerEnv, ServerManifest, ServerPlugin } from '../../../types';
+import type { Middleware, ServerEnv, ServerManifest, ServerPluginLegacy } 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[], logger: Logger): Promise<ServerManifest>;
@@ -7,5 +7,5 @@ export declare function injectServerManifest(pwd: string, routes?: ServerRoute[]
 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: () => ServerPlugin;
-export declare const injectResourcePlugin: () => ServerPlugin;
+export declare const injectRscManifestPlugin: () => ServerPluginLegacy;
+export declare const injectResourcePlugin: () => ServerPluginLegacy;

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

@@ -1,6 +1,6 @@
 import type { ServerRoute } from '@modern-js/types';
-import type { HtmlNormalizedConfig, Middleware, OutputNormalizedConfig, ServerPlugin } from '../../../types';
-export declare const serverStaticPlugin: () => ServerPlugin;
+import type { HtmlNormalizedConfig, Middleware, OutputNormalizedConfig, ServerPluginLegacy } from '../../../types';
+export declare const serverStaticPlugin: () => ServerPluginLegacy;
 export type PublicMiddlwareOptions = {
     pwd: string;
     routes: ServerRoute[];

package/dist/types/index.d.ts

@@ -2,11 +2,10 @@ export { createErrorHtml, onError, ErrorDigest } from './utils';
 export { AGGRED_DIR } from './constants';
 export type { ServerBase, ServerBaseOptions } from './serverBase';
 export { createServerBase } from './serverBase';
-export { PluginManager, type PluginManagerOptions } from './pluginManager';
 export type { Middleware, Context, Next, HonoRequest as InternalRequest, ServerEnv, ServerManifest, ServerLoaderBundle, } from './types';
 export { getLoaderCtx } from './helper';
 export * from './plugins';
-export * from './types/plugin';
+export * from './types/plugins';
 export * from './types/render';
 export * from '@modern-js/plugin';
 export * from './types/config';

package/dist/types/plugins/compat/hooks.d.ts

@@ -0,0 +1,8 @@
+import type { InternalServerContext } from '@modern-js/plugin-v2';
+import type { ServerPluginExtends } from '../../types';
+/**
+ * old plugin useHookRunners function result
+ */
+export declare function getHookRunners(context: InternalServerContext<ServerPluginExtends>): Record<string, any>;
+export declare function transformHookRunner(hookRunnerName: string): string;
+export declare function handleSetupResult(setupResult: Record<string, (...args: any) => any>, api: Record<string, any>): void;

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

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

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

@@ -1,12 +1,12 @@
 import type { ServerRoute, UnstableMiddleware } from '@modern-js/types';
 import type { ServerNodeEnv } from '../../adapters/node/hono';
 import type { ServerBase } from '../../serverBase';
-import type { Middleware, ServerEnv, ServerHookRunner } from '../../types';
+import type { Middleware, ServerEnv, ServerPluginHooks } from '../../types';
 export declare class CustomServer {
-    private runner;
+    private hooks;
     private serverMiddlewarePromise;
     private serverBase;
-    constructor(runner: ServerHookRunner, serverBase: ServerBase, pwd: string);
+    constructor(hooks: ServerPluginHooks, serverBase: ServerBase, pwd: string);
     getHookMiddleware(entryName: string, routes: ServerRoute[]): Middleware<ServerEnv>;
     getServerMiddleware(renderMiddlewares?: Middleware<ServerNodeEnv & ServerEnv>[]): Promise<Middleware<ServerNodeEnv & ServerEnv> | Array<Middleware<ServerNodeEnv & ServerEnv>> | undefined>;
 }

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

@@ -1,7 +1,7 @@
 import type { Logger } from '@modern-js/types';
-import type { ServerPlugin } from '../types';
+import type { ServerPlugin, ServerPluginLegacy } from '../types';
 import { type InjectRenderHandlerOptions } from './render';
 export type CreateDefaultPluginsOptions = InjectRenderHandlerOptions & {
     logger?: Logger | false;
 };
-export declare function createDefaultPlugins(options?: CreateDefaultPluginsOptions): ServerPlugin[];
+export declare function createDefaultPlugins(options?: CreateDefaultPluginsOptions): (ServerPluginLegacy | ServerPlugin)[];

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

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

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

@@ -4,3 +4,4 @@ export { injectServerTiming, injectloggerPlugin } from './monitors';
 export { processedByPlugin } from './processedBy';
 export { logPlugin } from './log';
 export { createDefaultPlugins, type CreateDefaultPluginsOptions, } from './default';
+export { compatPlugin, handleSetupResult } from './compat';

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

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

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

@@ -1,6 +1,6 @@
 import type { Logger } from '@modern-js/types';
-import type { Context, Next, ServerEnv, ServerPlugin } from '../types';
-export declare const initMonitorsPlugin: () => ServerPlugin;
-export declare const injectloggerPlugin: (inputLogger?: Logger) => ServerPlugin;
-export declare const injectServerTiming: () => ServerPlugin;
+import type { Context, Next, ServerEnv, ServerPluginLegacy } from '../types';
+export declare const initMonitorsPlugin: () => ServerPluginLegacy;
+export declare const injectloggerPlugin: (inputLogger?: Logger) => ServerPluginLegacy;
+export declare const injectServerTiming: () => ServerPluginLegacy;
 export declare function requestLatencyMiddleware(): (c: Context<ServerEnv>, next: Next) => Promise<void>;

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

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

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

@@ -1,3 +1,3 @@
-import type { ServerPlugin } from '../../types';
+import type { ServerPluginLegacy } from '../../types';
 export * from './inject';
-export declare const renderPlugin: () => ServerPlugin;
+export declare const renderPlugin: () => ServerPluginLegacy;

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

@@ -1,7 +1,7 @@
-import type { CacheConfig, GetRenderHandlerOptions, Render, ServerPlugin } from '../../types';
+import type { CacheConfig, GetRenderHandlerOptions, Render, ServerPluginLegacy } from '../../types';
 export interface InjectRenderHandlerOptions {
     staticGenerate?: boolean;
     cacheConfig?: CacheConfig;
 }
-export declare const injectRenderHandlerPlugin: ({ staticGenerate, cacheConfig, }: InjectRenderHandlerOptions) => ServerPlugin;
+export declare const injectRenderHandlerPlugin: ({ staticGenerate, cacheConfig, }: InjectRenderHandlerOptions) => ServerPluginLegacy;
 export declare function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate, onFallback, }: GetRenderHandlerOptions): Promise<Render>;

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

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

package/dist/types/serverBase.d.ts

@@ -1,44 +1,33 @@
-import type { ServerRoute } from '@modern-js/types';
+import { type ServerCreateOptions } from '@modern-js/plugin-v2/server';
 import { Hono } from 'hono';
-import type { Env, ServerConfig, ServerHookRunner, ServerPlugin } from './types';
+import type { Env, ServerConfig, ServerPlugin, ServerPluginHooks, ServerPluginLegacy } from './types';
 import type { CliConfig } from './types/config';
 declare module '@modern-js/types' {
     interface ISAppContext {
         serverBase?: ServerBase;
     }
 }
-export type ServerBaseOptions = {
+export interface ServerBaseOptions extends ServerCreateOptions {
     /** server working directory, and then also dist directory */
-    pwd: string;
     config: CliConfig;
     serverConfig?: ServerConfig;
-    metaName?: string;
-    routes?: ServerRoute[];
-    appContext: {
-        internalDirectory?: string;
-        appDirectory?: string;
-        sharedDirectory?: string;
-        apiDirectory?: string;
-        lambdaDirectory?: string;
-    };
     runMode?: 'apiOnly' | 'ssrOnly' | 'webOnly';
-};
+}
 export declare class ServerBase<E extends Env = any> {
     #private;
     options: ServerBaseOptions;
-    runner: ServerHookRunner;
     private app;
-    private appContext;
-    private pluginManager;
+    private plugins;
+    private serverContext;
     constructor(options: ServerBaseOptions);
     /**
-     * 初始化顺序
-     * - 初始化 pluginManager;
-     * - 执行 runner.prepare;
-     * - 应用 middlewares
+     * Order
+     * - server runner
+     * - apply middlewares
      */
     init(): Promise<this>;
-    addPlugins(plugins: ServerPlugin[]): void;
+    addPlugins(plugins: (ServerPlugin | ServerPluginLegacy)[]): void;
+    get hooks(): ServerPluginHooks;
     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/index.d.ts

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

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

@@ -0,0 +1,80 @@
+/// <reference types="node" />
+import type { IncomingMessage, Server as NodeServer, ServerResponse } from 'http';
+import type { CacheOption, Container, HttpMethodDecider, Logger, Metrics, MiddlewareContext, Reporter, ServerRoute, UnstableMiddleware } from '@modern-js/types';
+import type { MiddlewareHandler } from 'hono';
+import type { UserConfig } from '../config';
+import type { Render } from '../render';
+import type { ServerPlugin } from './new';
+import type { ServerPluginLegacy } from './old';
+export type { FileChangeEvent, ResetEvent } from '@modern-js/plugin-v2';
+export type FallbackReason = 'error' | 'header' | 'query';
+export type FallbackInput = {
+    reason: FallbackReason;
+    error: unknown;
+    logger: Logger;
+    metrics?: Metrics;
+    reporter?: Reporter;
+};
+export type OnFallback = (reason: FallbackReason, utils: {
+    logger: Logger;
+    metrics?: Metrics;
+    reporter?: Reporter;
+}, error?: unknown) => Promise<void>;
+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>;
+/** Plugin Api */
+type MiddlewareOrder = 'pre' | 'post' | 'default';
+export type Middleware = {
+    name: string;
+    path?: string;
+    method?: 'options' | 'get' | 'post' | 'put' | 'delete' | 'patch' | 'all';
+    handler: MiddlewareHandler | MiddlewareHandler[];
+    before?: Array<Middleware['name']>;
+    order?: MiddlewareOrder;
+};
+export interface GetRenderHandlerOptions {
+    pwd: string;
+    routes: ServerRoute[];
+    config: UserConfig;
+    onFallback?: OnFallback;
+    cacheConfig?: CacheConfig;
+    staticGenerate?: boolean;
+    metaName?: string;
+}
+declare module '@modern-js/types' {
+    interface ISAppContext {
+        middlewares: Middleware[];
+        metaName: string;
+        getRenderOptions?: GetRenderHandlerOptions;
+        render?: Render;
+        routes?: ServerRoute[];
+        nodeServer?: NodeServer;
+    }
+}
+export type NodeRequest = IncomingMessage;
+export type NodeResponse = ServerResponse;
+export type CacheConfig = {
+    strategy: CacheOption;
+    container?: Container;
+};
+type RenderMiddleware = UnstableMiddleware;
+export interface RenderConfig {
+    cache?: CacheConfig;
+    middleware?: RenderMiddleware[];
+}
+export type ServerConfig = {
+    render?: RenderConfig;
+    plugins?: (ServerPlugin | ServerPluginLegacy)[];
+} & UserConfig;

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

@@ -0,0 +1,3 @@
+export * from './new';
+export * from './old';
+export type { ServerConfig, CacheConfig, OnFallback, FallbackReason, GetRenderHandlerOptions, NodeRequest, NodeResponse, FileChangeEvent, FallbackInput, WebServerStartInput, APIServerStartInput, } from './base';

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

@@ -0,0 +1,34 @@
+import type { AsyncHook, AsyncPipelineHook, ServerContext as BaseServerContext, ServerPlugin as BaseServerPlugin, ServerPluginExtends as BaseServerPluginExtends } from '@modern-js/plugin-v2';
+import type { Hooks } from '@modern-js/plugin-v2/server';
+import type { AfterMatchContext, AfterRenderContext, AfterStreamingRenderContext, ISAppContext, UnstableMiddleware } from '@modern-js/types';
+import type { MiddlewareHandler } from 'hono';
+import type { Middleware } from './base';
+import type { APIServerStartInput, FallbackInput, ServerConfig, WebAdapter, WebServerStartInput } from './base';
+export type FallbackFn = (input: FallbackInput) => Promise<FallbackInput>;
+export type PrepareWebServerFn = (input: WebServerStartInput) => Promise<WebAdapter | Array<UnstableMiddleware> | null>;
+export type PrepareApiServerFn = (input: APIServerStartInput) => Promise<MiddlewareHandler>;
+export type AfterMatchFn = (ctx: AfterMatchContext) => Promise<any>;
+export type AfterRenderFn = (ctx: AfterRenderContext) => Promise<any>;
+export type AfterStreamingRenderContextFn = (ctx: AfterStreamingRenderContext) => Promise<AfterStreamingRenderContext>;
+export interface ServerPluginExtends extends BaseServerPluginExtends {
+    config: ServerConfig;
+    extendContext: {
+        middlewares: Middleware[];
+    };
+    extendApi: {
+        setAppContext: (c: ISAppContext) => void;
+        useAppContext: () => ISAppContext;
+        useConfigContext: () => ServerConfig;
+    };
+    extendHooks: {
+        prepareWebServer: AsyncPipelineHook<PrepareWebServerFn>;
+        fallback: AsyncHook<FallbackFn>;
+        prepareApiServer: AsyncPipelineHook<PrepareApiServerFn>;
+        afterMatch: AsyncPipelineHook<AfterMatchFn>;
+        afterRender: AsyncPipelineHook<AfterRenderFn>;
+        afterStreamingRender: AsyncPipelineHook<AfterStreamingRenderContextFn>;
+    };
+}
+export type ServerPlugin = BaseServerPlugin<ServerPluginExtends>;
+export type ServerContext = BaseServerContext<ServerPluginExtends> & ServerPluginExtends['extendContext'];
+export type ServerPluginHooks = Hooks<ServerPluginExtends> & ServerPluginExtends['extendHooks'];

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

@@ -0,0 +1,56 @@
+import type { AsyncPipeline, AsyncSetup, AsyncWaterfall, AsyncWorkflow, CommonAPI, ParallelWorkflow, PluginOptions } from '@modern-js/plugin';
+import type { AfterMatchContext, AfterRenderContext, AfterStreamingRenderContext, ISAppContext, UnstableMiddleware } from '@modern-js/types';
+import type { MiddlewareHandler } from 'hono';
+import type { APIServerStartInput, FallbackInput, ResetEvent, ServerConfig, WebAdapter, WebServerStartInput } from './base';
+export interface ServerHooks {
+    /**
+     * @deprecated
+     *
+     * deprecate it next major version
+     */
+    config: AsyncWaterfall<ServerConfig>;
+    prepare: AsyncWaterfall<void>;
+    reset: AsyncWorkflow<{
+        event: ResetEvent;
+    }, void>;
+    /**
+     * @deprecated
+     *
+     * deprecate it next major version
+     * */
+    prepareWebServer: AsyncPipeline<WebServerStartInput, WebAdapter | Array<UnstableMiddleware> | null>;
+    /**
+     * @deprecated
+     *
+     * deprecate it when server runtime entry refactor
+     *
+     */
+    fallback: ParallelWorkflow<FallbackInput>;
+    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 ServerPluginAPI = {
+    setAppContext: (c: ISAppContext) => void;
+    useAppContext: () => ISAppContext;
+    useConfigContext: () => ServerConfig;
+};
+export type PluginAPI = ServerPluginAPI & CommonAPI<ServerHooks>;
+/**old server plugin. */
+export type ServerPluginLegacy = PluginOptions<ServerHooks, AsyncSetup<ServerHooks, PluginAPI>>;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.65.5",
+  "version": "2.65.6-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -54,8 +54,9 @@
     "hono": "^3.12.2",
     "ts-deepmerge": "7.0.2",
     "@modern-js/plugin": "2.65.5",
-    "@modern-js/utils": "2.65.5",
-    "@modern-js/runtime-utils": "2.65.5"
+    "@modern-js/runtime-utils": "2.65.5",
+    "@modern-js/plugin-v2": "2.65.6-alpha.0",
+    "@modern-js/utils": "2.65.5"
   },
   "devDependencies": {
     "@types/jest": "^29",

package/dist/cjs/pluginManager.js

@@ -1,106 +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 pluginManager_exports = {};
-__export(pluginManager_exports, {
-  PluginManager: () => PluginManager
-});
-module.exports = __toCommonJS(pluginManager_exports);
-var import_class_private_field_get = require("@swc/helpers/_/_class_private_field_get");
-var import_class_private_field_init = require("@swc/helpers/_/_class_private_field_init");
-var import_class_private_field_set = require("@swc/helpers/_/_class_private_field_set");
-var import_class_private_method_get = require("@swc/helpers/_/_class_private_method_get");
-var import_class_private_method_init = require("@swc/helpers/_/_class_private_method_init");
-var import_plugin = require("@modern-js/plugin");
-var import_utils = require("./utils");
-var _appContext = /* @__PURE__ */ new WeakMap(), _plugins = /* @__PURE__ */ new WeakMap(), _options = /* @__PURE__ */ new WeakMap(), _configContext = /* @__PURE__ */ new WeakMap(), _createCoreManager = /* @__PURE__ */ new WeakSet(), _initConfigContext = /* @__PURE__ */ new WeakSet();
-class PluginManager {
-  async init() {
-    const coreManager = (0, import_class_private_method_get._)(this, _createCoreManager, createCoreManager).call(this);
-    const runner = await coreManager.init();
-    await (0, import_class_private_method_get._)(this, _initConfigContext, initConfigContext).call(this, runner);
-    return runner;
-  }
-  addPlugins(plugins) {
-    (0, import_class_private_field_get._)(this, _plugins).push(...plugins);
-  }
-  constructor(options) {
-    (0, import_class_private_method_init._)(this, _createCoreManager);
-    (0, import_class_private_method_init._)(this, _initConfigContext);
-    (0, import_class_private_field_init._)(this, _appContext, {
-      writable: true,
-      value: void 0
-    });
-    (0, import_class_private_field_init._)(this, _plugins, {
-      writable: true,
-      value: void 0
-    });
-    (0, import_class_private_field_init._)(this, _options, {
-      writable: true,
-      value: void 0
-    });
-    (0, import_class_private_field_init._)(this, _configContext, {
-      writable: true,
-      value: void 0
-    });
-    (0, import_class_private_field_set._)(this, _plugins, []);
-    (0, import_class_private_field_set._)(this, _configContext, (0, import_plugin.createContext)({}));
-    (0, import_class_private_field_set._)(this, _appContext, options.appContext);
-    (0, import_class_private_field_set._)(this, _configContext, (0, import_plugin.createContext)(options.serverConfig || {}));
-    (0, import_class_private_field_set._)(this, _options, options);
-  }
-}
-function createCoreManager() {
-  var _class_private_field_get_serverConfig;
-  const hooks = {
-    config: (0, import_plugin.createAsyncWaterfall)(),
-    prepare: (0, import_plugin.createAsyncWaterfall)(),
-    reset: (0, import_plugin.createAsyncWorkflow)(),
-    prepareWebServer: (0, import_plugin.createAsyncPipeline)(),
-    fallback: (0, import_plugin.createParallelWorkflow)(),
-    prepareApiServer: (0, import_plugin.createAsyncPipeline)(),
-    afterMatch: (0, import_plugin.createAsyncPipeline)(),
-    afterRender: (0, import_plugin.createAsyncPipeline)(),
-    afterStreamingRender: (0, import_plugin.createAsyncPipeline)()
-  };
-  const pluginApi = {
-    useConfigContext: () => (0, import_class_private_field_get._)(this, _configContext).use().value,
-    useAppContext: () => (0, import_class_private_field_get._)(this, _appContext).use().value,
-    setAppContext: (c) => (0, import_class_private_field_get._)(this, _appContext).set(c)
-  };
-  const coreManager = (0, import_plugin.createAsyncManager)(hooks, pluginApi);
-  this.addPlugins(((_class_private_field_get_serverConfig = (0, import_class_private_field_get._)(this, _options).serverConfig) === null || _class_private_field_get_serverConfig === void 0 ? void 0 : _class_private_field_get_serverConfig.plugins) || []);
-  (0, import_class_private_field_get._)(this, _plugins).forEach((p) => {
-    const plugin = coreManager.createPlugin(p.setup, p);
-    coreManager.usePlugin(plugin);
-  });
-  return coreManager;
-}
-async function initConfigContext(runner) {
-  const { serverConfig, cliConfig } = (0, import_class_private_field_get._)(this, _options);
-  const mergedConfig = (0, import_utils.loadConfig)({
-    cliConfig,
-    serverConfig: serverConfig || {}
-  });
-  const finalServerConfig = await runner.config(mergedConfig);
-  (0, import_class_private_field_get._)(this, _configContext).set(finalServerConfig);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PluginManager
-});