@ecopages/core 0.2.0-alpha.1

package/src/adapters/bun/server-adapter.ts

@@ -0,0 +1,492 @@
+import type { Server, WebSocketHandler } from 'bun';
+import { appLogger } from '../../global/app-logger.ts';
+import type { EcoPagesAppConfig } from '../../internal-types.ts';
+import type { ApiHandler, ApiHandlerContext, ErrorHandler, StaticRoute } from '../../public-types.ts';
+import { HttpError } from '../../errors/http-error.ts';
+import { createRequire } from '../../utils/locals-utils.ts';
+
+import { fileSystem } from '@ecopages/file-system';
+import { SharedServerAdapter } from '../shared/server-adapter.ts';
+import type { ServerAdapterResult } from '../abstract/server-adapter.ts';
+import { ApiResponseBuilder } from '../shared/api-response.ts';
+
+import { ServerRouteHandler, type ServerRouteHandlerParams } from '../shared/server-route-handler.ts';
+import { ServerStaticBuilder, type ServerStaticBuilderParams } from '../shared/server-static-builder';
+import { ClientBridge } from './client-bridge';
+import { HmrManager } from './hmr-manager';
+import { ServerLifecycle } from './server-lifecycle.ts';
+
+type BunServerInstance = Server<unknown>;
+type BunNativeServeOptions = Bun.Serve.Options<unknown>;
+
+export type BunServerRoutes = Bun.Serve.Routes<unknown, string>;
+
+export type BunServeAdapterServerOptions = Partial<
+	Omit<BunNativeServeOptions, 'fetch'> & {
+		fetch(this: BunServerInstance, request: Request): Promise<void | Response>;
+	}
+>;
+
+export type BunServeOptions = Omit<BunNativeServeOptions, 'fetch'> & {
+	fetch?: (this: BunServerInstance, request: Request, server: BunServerInstance) => Promise<void | Response>;
+	websocket?: WebSocketHandler<unknown>;
+};
+
+export interface BunServerAdapterParams {
+	appConfig: EcoPagesAppConfig;
+	runtimeOrigin: string;
+	serveOptions: BunServeAdapterServerOptions;
+	apiHandlers?: ApiHandler<string, Request, BunServerInstance>[];
+	staticRoutes?: StaticRoute[];
+	errorHandler?: ErrorHandler;
+	options?: {
+		watch?: boolean;
+	};
+	lifecycle?: ServerLifecycle;
+	staticBuilderFactory?: (params: ServerStaticBuilderParams) => ServerStaticBuilder;
+	routeHandlerFactory?: (params: ServerRouteHandlerParams) => ServerRouteHandler;
+	hmrManager?: HmrManager;
+	bridge?: ClientBridge;
+}
+
+export interface BunServerAdapterResult extends ServerAdapterResult {
+	getServerOptions: (options?: { enableHmr?: boolean }) => BunServeOptions;
+	buildStatic: (options?: { preview?: boolean }) => Promise<void>;
+	completeInitialization: (server?: BunServerInstance | null) => Promise<void>;
+	handleRequest: (request: Request) => Promise<Response>;
+}
+
+export class BunServerAdapter extends SharedServerAdapter<BunServerAdapterParams, BunServerAdapterResult> {
+	declare appConfig: EcoPagesAppConfig;
+	declare options: BunServerAdapterParams['options'];
+	declare serveOptions: BunServeAdapterServerOptions;
+	protected apiHandlers: ApiHandler<string, Request, BunServerInstance>[];
+	protected staticRoutes: StaticRoute[];
+
+	protected errorHandler?: ErrorHandler;
+
+	private bridge!: ClientBridge;
+	private lifecycle!: ServerLifecycle;
+	public hmrManager!: HmrManager;
+	private initializationPromise: Promise<void> | null = null;
+	private fullyInitialized = false;
+	declare serverInstance: BunServerInstance | null;
+
+	private readonly lifecycleFactory?: ServerLifecycle;
+	private readonly staticBuilderFactory?: (params: ServerStaticBuilderParams) => ServerStaticBuilder;
+	private readonly routeHandlerFactory?: (params: ServerRouteHandlerParams) => ServerRouteHandler;
+	private readonly hmrManagerFactory?: HmrManager;
+	private readonly bridgeFactory?: ClientBridge;
+
+	constructor({
+		appConfig,
+		runtimeOrigin,
+		serveOptions,
+		apiHandlers,
+		staticRoutes,
+		errorHandler,
+		options,
+		lifecycle,
+		staticBuilderFactory,
+		routeHandlerFactory,
+		hmrManager,
+		bridge,
+	}: BunServerAdapterParams) {
+		super({ appConfig, runtimeOrigin, serveOptions, options });
+		this.apiHandlers = apiHandlers || [];
+		this.staticRoutes = staticRoutes || [];
+		this.errorHandler = errorHandler;
+		this.lifecycleFactory = lifecycle;
+		this.staticBuilderFactory = staticBuilderFactory;
+		this.routeHandlerFactory = routeHandlerFactory;
+		this.hmrManagerFactory = hmrManager;
+		this.bridgeFactory = bridge;
+	}
+
+	/**
+	 * Determines if HMR script should be injected.
+	 * Only injects in watch mode when HMR manager is enabled.
+	 */
+	private shouldInjectHmrScript(): boolean {
+		return this.options?.watch === true && this.hmrManager?.isEnabled() === true;
+	}
+
+	/**
+	 * Checks if a response contains HTML content.
+	 */
+	private isHtmlResponse(response: Response): boolean {
+		const contentType = response.headers.get('Content-Type');
+		return contentType !== null && contentType.startsWith('text/html');
+	}
+
+	/**
+	 * Injects HMR script into HTML responses in development mode.
+	 * Ensures explicit API handlers that return HTML get auto-reload capability.
+	 */
+	private async maybeInjectHmrScript(response: Response): Promise<Response> {
+		if (this.shouldInjectHmrScript() && this.isHtmlResponse(response)) {
+			const html = await response.text();
+			const hmrScript = `<script type="module">import '/_hmr_runtime.js';</script>`;
+			const updatedHtml = html.replace(/<\/html>/i, `${hmrScript}</html>`);
+
+			const headers = new Headers(response.headers);
+			headers.delete('Content-Length');
+
+			return new Response(updatedHtml, {
+				status: response.status,
+				statusText: response.statusText,
+				headers,
+			});
+		}
+		return response;
+	}
+
+	/**
+	 * Initializes the server adapter's core components.
+	 * Delegates to ServerLifecycle for setup.
+	 */
+	public async initialize(): Promise<void> {
+		this.bridge = this.bridgeFactory ?? new ClientBridge();
+		this.hmrManager = this.hmrManagerFactory ?? new HmrManager({ appConfig: this.appConfig, bridge: this.bridge });
+		this.lifecycle =
+			this.lifecycleFactory ??
+			new ServerLifecycle({
+				appConfig: this.appConfig,
+				runtimeOrigin: this.runtimeOrigin,
+				hmrManager: this.hmrManager,
+				bridge: this.bridge,
+			});
+
+		this.staticSiteGenerator = await this.lifecycle.initialize();
+
+		const staticBuilderOptions = {
+			appConfig: this.appConfig,
+			staticSiteGenerator: this.staticSiteGenerator,
+			serveOptions: this.serveOptions,
+		};
+
+		this.staticBuilder = this.staticBuilderFactory
+			? this.staticBuilderFactory(staticBuilderOptions)
+			: new ServerStaticBuilder(staticBuilderOptions);
+
+		await this.lifecycle.initializePlugins({ watch: this.options?.watch });
+	}
+
+	/**
+	 * Refreshes the router routes during watch mode.
+	 */
+	private async refreshRouterRoutes(): Promise<void> {
+		if (this.serverInstance && typeof this.serverInstance.reload === 'function') {
+			try {
+				await this.initSharedRouter();
+				this.configureSharedResponseHandlers(this.staticRoutes, this.hmrManager);
+				const options = this.getServerOptions({ enableHmr: true });
+				this.serverInstance.reload(options as BunNativeServeOptions);
+				appLogger.debug('Server routes updated with dynamic routes');
+			} catch (error) {
+				if (error instanceof Error) {
+					this.hmrManager.broadcast({ type: 'error', message: error.message });
+					appLogger.error('Failed to refresh router routes:', error);
+				}
+			}
+		} else {
+			appLogger.error('Server instance is not available for reloading');
+		}
+	}
+
+	private async watch(): Promise<void> {
+		await this.lifecycle.startWatching({
+			refreshRouterRoutesCallback: this.refreshRouterRoutes.bind(this),
+		});
+	}
+
+	/**
+	 * Retrieves the current server options, optionally enabling HMR.
+	 * If HMR is enabled, modifies fetch to handle WebSocket upgrades and serve HMR runtime.
+	 * Ensures original fetch logic is preserved and called for non-HMR requests.
+	 * @param options.enableHmr Whether to enable Hot Module Replacement
+	 */
+	public getServerOptions({ enableHmr = false } = {}): BunServeOptions {
+		appLogger.debug(`[BunServerAdapter] getServerOptions called with enableHmr: ${enableHmr}`);
+		const serverOptions = this.buildServerSettings();
+
+		if (enableHmr) {
+			const originalFetch = serverOptions.fetch;
+			const hmrHandler = this.hmrManager.getWebSocketHandler();
+			const hmrManager = this.hmrManager;
+
+			(serverOptions as any).development = true;
+
+			serverOptions.websocket = hmrHandler;
+			serverOptions.fetch = async function (
+				this: Server<unknown>,
+				request: Request,
+				_server: Server<unknown>,
+			): Promise<Response | void> {
+				const url = new URL(request.url);
+				appLogger.debug(`[HMR] Request: ${url.pathname}`);
+
+				/** Handle HMR WebSocket upgrade */
+				if (url.pathname === '/_hmr') {
+					const success = this.upgrade(request, {
+						data: undefined,
+					});
+					if (success) return;
+					return new Response('WebSocket upgrade failed', { status: 400 });
+				}
+
+				/** Serve HMR runtime script */
+				if (url.pathname === '/_hmr_runtime.js') {
+					appLogger.debug(`[HMR] Serving runtime from ${hmrManager.getRuntimePath()}`);
+					return new Response(fileSystem.readFileAsBuffer(hmrManager.getRuntimePath()) as BodyInit, {
+						headers: { 'Content-Type': 'application/javascript' },
+					});
+				}
+
+				/** Proceed with normal request handling */
+				let response: Response;
+				if (originalFetch) {
+					const res = await originalFetch.call(this, request, this);
+					response = res instanceof Response ? res : new Response('Not Found', { status: 404 });
+				} else {
+					response = new Response('Not Found', { status: 404 });
+				}
+
+				return response;
+			};
+		}
+
+		return serverOptions as BunServeOptions;
+	}
+
+	/**
+	 * Helper method to retrieve and parse the request body.
+	 * Handles JSON and plain text content types.
+	 * For FormData (multipart/form-data, x-www-form-urlencoded), use ctx.request.formData() directly.
+	 * Returns undefined for unsupported content types.
+	 */
+	private async retrieveBodyFromRequest(request: Request): Promise<unknown> {
+		const contentType = request.headers.get('Content-Type') || '';
+
+		if (contentType.includes('application/json')) {
+			return await request.json();
+		}
+
+		if (contentType.includes('text/plain')) {
+			return await request.text();
+		}
+
+		return undefined;
+	}
+
+	/**
+	 * Creates complete server configuration with request handling.
+	 * @returns Server options ready for Bun.serve()
+	 */
+	private buildServerSettings(): BunServeOptions {
+		const serverOptions = { ...this.serveOptions } as BunServeAdapterServerOptions;
+		const handleNoMatch = this.handleNoMatch.bind(this);
+		const waitForInit = this.waitForInitialization.bind(this);
+		const handleReq = this.handleRequest.bind(this);
+		const errorHandler = this.errorHandler;
+		const getCacheService = () => this.getCacheService();
+		const getRenderContext = () => this.getRenderContext();
+
+		appLogger.debug(`[BunServerAdapter] Building server settings`);
+
+		const finalOptions: BunServeOptions = {
+			...serverOptions,
+			async fetch(this: Server<unknown>, request: Request, _server: Server<unknown>) {
+				try {
+					await waitForInit();
+					return await handleReq(request);
+				} catch (error) {
+					if (error instanceof Response) return error;
+					if (errorHandler) {
+						try {
+							const locals: Record<string, unknown> = {};
+							const context: ApiHandlerContext<Request, BunServerInstance> = {
+								request,
+								params: {},
+								response: new ApiResponseBuilder(),
+								server: _server as BunServerInstance,
+								locals,
+								require: createRequire((): Record<string, unknown> => locals),
+								services: {
+									cache: getCacheService(),
+								},
+								...getRenderContext(),
+							};
+
+							return await errorHandler(error, context);
+						} catch (handlerError) {
+							appLogger.error(`[ecopages] Error in custom error handler: ${handlerError}`);
+						}
+					}
+					if (error instanceof HttpError) return error.toResponse();
+
+					appLogger.error(`[ecopages] Error handling request: ${error}`);
+					return new Response('Internal Server Error', { status: 500 });
+				}
+			},
+			error(this: Server<unknown>, error: Error) {
+				appLogger.error(`[ecopages] Error handling request: ${error}`);
+				return handleNoMatch(new Request('http://localhost'));
+			},
+		};
+
+		return finalOptions as unknown as BunServeOptions;
+	}
+
+	/**
+	 * Generates a static build of the site for deployment.
+	 * @param options.preview - If true, starts a preview server after build
+	 */
+	public async buildStatic(options?: { preview?: boolean }): Promise<void> {
+		if (!this.fullyInitialized) {
+			await this.initSharedRouter();
+			this.configureSharedResponseHandlers(this.staticRoutes, this.hmrManager);
+		}
+
+		await this.staticBuilder.build(options, {
+			router: this.router,
+			routeRendererFactory: this.routeRendererFactory,
+			staticRoutes: this.staticRoutes,
+		});
+	}
+
+	/**
+	 * Initializes the server with dynamic routes after server creation.
+	 * Must be called before handling any requests.
+	 * @param server - The Bun server instance
+	 */
+	public async completeInitialization(server?: BunServerInstance | null): Promise<void> {
+		if (this.fullyInitialized) {
+			if (server && !this.serverInstance) {
+				this.serverInstance = server;
+			}
+			return;
+		}
+
+		if (!this.initializationPromise) {
+			this.initializationPromise = this._performInitialization(server ?? null);
+		}
+
+		return this.initializationPromise;
+	}
+
+	/**
+	 * Performs complete server setup including routing, watchers, and HMR.
+	 */
+	private async _performInitialization(server: BunServerInstance | null): Promise<void> {
+		this.serverInstance = server;
+		appLogger.debug('Completing server initialization with dynamic routes');
+
+		await this.initSharedRouter();
+		this.configureSharedResponseHandlers(this.staticRoutes, this.hmrManager);
+
+		this.fullyInitialized = true;
+
+		if (this.options?.watch) await this.watch();
+
+		if (server && typeof server.reload === 'function') {
+			const updatedOptions = this.getServerOptions(this.options?.watch ? { enableHmr: true } : undefined);
+			server.reload(updatedOptions as BunNativeServeOptions);
+			appLogger.debug('Server routes updated with dynamic routes');
+		}
+	}
+
+	/**
+	 * Creates and initializes the Bun server adapter.
+	 * @returns Configured adapter with server methods
+	 */
+	public async createAdapter(): Promise<BunServerAdapterResult> {
+		await this.initialize();
+
+		return {
+			getServerOptions: this.getServerOptions.bind(this),
+			buildStatic: this.buildStatic.bind(this),
+			completeInitialization: this.completeInitialization.bind(this),
+			handleRequest: this.handleRequest.bind(this),
+		};
+	}
+
+	/**
+	 * Handles HTTP requests by passing them securely to the shared core router adapter.
+	 */
+	public async handleRequest(request: Request): Promise<Response> {
+		const response = await this.handleSharedRequest(request, {
+			apiHandlers: this.apiHandlers,
+			errorHandler: this.errorHandler,
+			serverInstance: this.serverInstance,
+			hmrManager: this.hmrManager,
+		});
+
+		// Check if we need to manually inject HMR script since we're bypassing route level HMR wrapping
+		return await this.maybeInjectHmrScript(response);
+	}
+
+	/**
+	 * Ensures server initialization completes before request handling.
+	 * Prevents race conditions during startup.
+	 */
+	private async waitForInitialization(): Promise<void> {
+		if (this.fullyInitialized) {
+			return;
+		}
+
+		if (this.initializationPromise) {
+			return this.initializationPromise;
+		}
+
+		throw new Error('Server not initialized. Call completeInitialization() first.');
+	}
+
+	/**
+	 * Handles HTTP requests from the router adapter.
+	 */
+	public async handleResponse(request: Request): Promise<Response> {
+		await this.waitForInitialization();
+		return this.routeHandler.handleResponse(request);
+	}
+
+	/**
+	 * Handles requests that do not match any routes.
+	 */
+	private async handleNoMatch(request: Request): Promise<Response> {
+		await this.waitForInitialization();
+		return this.routeHandler.handleNoMatch(request);
+	}
+}
+
+/**
+ * Factory function to create a Bun server adapter
+ */
+export async function createBunServerAdapter(params: BunServerAdapterParams): Promise<BunServerAdapterResult> {
+	const runtimeOrigin =
+		params.runtimeOrigin ??
+		`http://${params.serveOptions.hostname || 'localhost'}:${params.serveOptions.port || 3000}`;
+
+	const bridge = params.bridge ?? new ClientBridge();
+	const hmrManager = params.hmrManager ?? new HmrManager({ appConfig: params.appConfig, bridge });
+	const lifecycle =
+		params.lifecycle ??
+		new ServerLifecycle({
+			appConfig: params.appConfig,
+			runtimeOrigin,
+			hmrManager,
+			bridge,
+		});
+
+	const adapter = new BunServerAdapter({
+		...params,
+		runtimeOrigin,
+		bridge,
+		hmrManager,
+		lifecycle,
+		staticBuilderFactory: params.staticBuilderFactory ?? ((opts) => new ServerStaticBuilder(opts)),
+		routeHandlerFactory: params.routeHandlerFactory ?? ((p) => new ServerRouteHandler(p)),
+	});
+
+	return adapter.createAdapter();
+}

package/src/adapters/bun/server-lifecycle.d.ts

@@ -0,0 +1,52 @@
+import type { EcoPagesAppConfig } from '../../internal-types';
+import type { EcoBuildPlugin } from '../../build/build-types.js';
+import { StaticSiteGenerator } from '../../static-site-generator/static-site-generator';
+import type { ClientBridge } from './client-bridge';
+import type { HmrManager } from './hmr-manager';
+export interface WatcherCallbacks {
+    refreshRouterRoutesCallback: () => Promise<void>;
+}
+export interface ServerLifecycleParams {
+    appConfig: EcoPagesAppConfig;
+    runtimeOrigin: string;
+    hmrManager: HmrManager;
+    bridge: ClientBridge;
+}
+/**
+ * Handles server lifecycle: initialization, plugins, loaders, and file watching.
+ */
+export declare class ServerLifecycle {
+    private readonly appConfig;
+    private readonly hmrManager;
+    private readonly bridge;
+    private readonly runtimeOrigin;
+    private staticSiteGenerator;
+    constructor({ appConfig, runtimeOrigin, hmrManager, bridge }: ServerLifecycleParams);
+    /**
+     * Initializes the server's core components.
+     * @returns The static site generator instance for use by other components
+     */
+    initialize(): Promise<StaticSiteGenerator>;
+    /**
+     * Sets up Bun loaders from config.
+     * Note: This will be abstracted to a LoaderStrategy interface in #4 Runtime Abstraction.
+     */
+    setupLoaders(): void;
+    /**
+     * Copies public directory contents to dist root.
+     * Static files are served from root (e.g., /favicon.ico, /robots.txt).
+     */
+    copyPublicDir(): void;
+    /**
+     * Initializes processors and integrations.
+     * @param options.watch - Whether watch mode is enabled
+     */
+    initializePlugins(options?: {
+        watch?: boolean;
+    }): Promise<EcoBuildPlugin[]>;
+    /**
+     * Starts file watching for HMR.
+     */
+    startWatching(callbacks: WatcherCallbacks): Promise<void>;
+    getStaticSiteGenerator(): StaticSiteGenerator;
+}

package/src/adapters/bun/server-lifecycle.js

@@ -0,0 +1,120 @@
+import path from "node:path";
+import { getBunRuntime } from "../../utils/runtime.js";
+import { RESOLVED_ASSETS_DIR } from "../../constants";
+import { defaultBuildAdapter } from "../../build/build-adapter.js";
+import { appLogger } from "../../global/app-logger";
+import { fileSystem } from "@ecopages/file-system";
+import { StaticSiteGenerator } from "../../static-site-generator/static-site-generator";
+import { ProjectWatcher } from "../../watchers/project-watcher";
+class ServerLifecycle {
+  appConfig;
+  hmrManager;
+  bridge;
+  runtimeOrigin;
+  staticSiteGenerator;
+  constructor({ appConfig, runtimeOrigin, hmrManager, bridge }) {
+    this.appConfig = appConfig;
+    this.runtimeOrigin = runtimeOrigin;
+    this.hmrManager = hmrManager;
+    this.bridge = bridge;
+  }
+  /**
+   * Initializes the server's core components.
+   * @returns The static site generator instance for use by other components
+   */
+  async initialize() {
+    this.staticSiteGenerator = new StaticSiteGenerator({ appConfig: this.appConfig });
+    await this.hmrManager.buildRuntime();
+    this.setupLoaders();
+    this.copyPublicDir();
+    return this.staticSiteGenerator;
+  }
+  /**
+   * Sets up Bun loaders from config.
+   * Note: This will be abstracted to a LoaderStrategy interface in #4 Runtime Abstraction.
+   */
+  setupLoaders() {
+    const loaders = this.appConfig.loaders;
+    for (const loader of loaders.values()) {
+      defaultBuildAdapter.registerPlugin(loader);
+      getBunRuntime()?.plugin(loader);
+    }
+  }
+  /**
+   * Copies public directory contents to dist root.
+   * Static files are served from root (e.g., /favicon.ico, /robots.txt).
+   */
+  copyPublicDir() {
+    try {
+      const srcPublicDir = path.join(this.appConfig.rootDir, this.appConfig.srcDir, this.appConfig.publicDir);
+      if (fileSystem.exists(srcPublicDir)) {
+        fileSystem.copyDir(srcPublicDir, path.join(this.appConfig.rootDir, this.appConfig.distDir));
+      }
+      fileSystem.ensureDir(path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR));
+    } catch (error) {
+      appLogger.error(
+        `Failed to copy public directory: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * Initializes processors and integrations.
+   * @param options.watch - Whether watch mode is enabled
+   */
+  async initializePlugins(options) {
+    try {
+      const hmrEnabled = !!options?.watch;
+      this.hmrManager.setEnabled(hmrEnabled);
+      const processorBuildPlugins = [];
+      const processorPromises = Array.from(this.appConfig.processors.values()).map(async (processor) => {
+        await processor.setup();
+        if (processor.plugins) {
+          for (const plugin of processor.plugins) {
+            defaultBuildAdapter.registerPlugin(plugin);
+            getBunRuntime()?.plugin(plugin);
+          }
+        }
+        if (processor.buildPlugins) {
+          processorBuildPlugins.push(...processor.buildPlugins);
+        }
+      });
+      const integrationPromises = this.appConfig.integrations.map(async (integration) => {
+        integration.setConfig(this.appConfig);
+        integration.setRuntimeOrigin(this.runtimeOrigin);
+        integration.setHmrManager(this.hmrManager);
+        await integration.setup();
+        for (const plugin of integration.plugins) {
+          defaultBuildAdapter.registerPlugin(plugin);
+          getBunRuntime()?.plugin(plugin);
+        }
+      });
+      await Promise.all([...processorPromises, ...integrationPromises]);
+      const loaderPlugins = Array.from(this.appConfig.loaders.values());
+      const allBuildPlugins = [...loaderPlugins, ...processorBuildPlugins];
+      this.hmrManager.setPlugins(allBuildPlugins);
+      return allBuildPlugins;
+    } catch (error) {
+      appLogger.error(`Failed to initialize plugins: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  /**
+   * Starts file watching for HMR.
+   */
+  async startWatching(callbacks) {
+    const watcherInstance = new ProjectWatcher({
+      config: this.appConfig,
+      refreshRouterRoutesCallback: callbacks.refreshRouterRoutesCallback,
+      hmrManager: this.hmrManager,
+      bridge: this.bridge
+    });
+    await watcherInstance.createWatcherSubscription();
+  }
+  getStaticSiteGenerator() {
+    return this.staticSiteGenerator;
+  }
+}
+export {
+  ServerLifecycle
+};