@ecopages/core 0.2.0-alpha.2 → 0.2.0-alpha.21

package/src/watchers/project-watcher.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import chokidar, {} from "chokidar";
 import { fileSystem } from "@ecopages/file-system";
 import { appLogger } from "../global/app-logger.js";
+import { DevelopmentInvalidationService } from "../services/invalidation/development-invalidation.service.js";
 class ProjectWatcher {
   /**
    * Duplicate identical watcher events within this window are ignored.
@@ -15,13 +16,16 @@ class ProjectWatcher {
   refreshRouterRoutesCallback;
   hmrManager;
   bridge;
+  invalidationService;
   watcher = null;
   lastHandledChange = /* @__PURE__ */ new Map();
+  changeQueue = Promise.resolve();
   constructor({ config, refreshRouterRoutesCallback, hmrManager, bridge }) {
     this.appConfig = config;
     this.refreshRouterRoutesCallback = refreshRouterRoutesCallback;
     this.hmrManager = hmrManager;
     this.bridge = bridge;
+    this.invalidationService = new DevelopmentInvalidationService(config);
     this.triggerRouterRefresh = this.triggerRouterRefresh.bind(this);
     this.handleError = this.handleError.bind(this);
     this.handleFileChange = this.handleFileChange.bind(this);
@@ -41,6 +45,12 @@ class ProjectWatcher {
       }
     }
   }
+  isRouteSourceFile(filePath) {
+    return this.invalidationService.isRouteSourceFile(filePath);
+  }
+  isIncludeSourceFile(filePath) {
+    return this.invalidationService.isIncludeSourceFile(filePath);
+  }
   /**
    * Handles public directory file changes by copying only the changed file.
    * @param filePath - Absolute path of the changed file
@@ -60,19 +70,33 @@ class ProjectWatcher {
       this.bridge.reload();
     }
   }
+  /**
+   * Serializes file change handling so that concurrent chokidar events are
+   * processed one at a time, preventing overlapping builds and race conditions.
+   */
+  enqueueChange(task) {
+    const queuedTask = this.changeQueue.then(task, task);
+    this.changeQueue = queuedTask.catch(() => void 0);
+  }
   /**
    * Handles file changes by uncaching modules, refreshing routes, and delegating appropriately.
-   * Follows 4-rule priority:
-   * 0. Public directory match? → copy file and reload
-   * 1. additionalWatchPaths match? → reload
-   * 2. Processor extension match? → processor handles (skip HMR)
-   * 3. Otherwise → HMR strategies
+   * Follows 5-rule priority:
+   * 0. Public directory match? -> copy file and reload
+   * 1. additionalWatchPaths match? -> reload
+   * 2. Include template source? -> reload after processor notifications
+   * 3. Processor-owned asset? -> processor already handled it via notification, skip HMR
+   * 4. Otherwise -> HMR strategies
+   *
+   * Processors that watch a file extension as a dependency (e.g. PostCSS watching
+   * .tsx for Tailwind class scanning) are always notified first, but do not
+   * prevent the file from flowing through the normal HMR strategy pipeline.
    *
    * Duplicate identical watcher events for the same file are coalesced within a
    * short window before any of the priority rules run.
    * @param rawPath - Path of the changed file
+   * @param event - The type of file system event
    */
-  async handleFileChange(rawPath) {
+  async handleFileChange(rawPath, event = "change") {
     const filePath = path.resolve(rawPath);
     const now = Date.now();
     const lastHandledAt = this.lastHandledChange.get(filePath);
@@ -81,23 +105,33 @@ class ProjectWatcher {
     }
     this.lastHandledChange.set(filePath, now);
     try {
-      if (this.isPublicDirFile(filePath)) {
+      const plan = this.invalidationService.planFileChange(filePath);
+      if (plan.category === "public-asset") {
         await this.handlePublicDirFileChange(filePath);
         return;
       }
       this.uncacheModules();
-      const isPageFile = filePath.startsWith(this.appConfig.absolutePaths.pagesDir);
-      if (isPageFile) {
-        this.refreshRouterRoutesCallback();
+      if (plan.invalidateServerModules) {
+        this.invalidationService.invalidateServerModules([filePath]);
+      }
+      if (plan.refreshRoutes) {
+        await this.refreshRouterRoutesCallback();
       }
-      if (this.matchesAdditionalWatchPaths(filePath)) {
+      if (plan.category === "additional-watch") {
         this.bridge.reload();
         return;
       }
-      if (this.isHandledByProcessor(filePath)) {
+      await this.notifyProcessors(filePath, event);
+      if (plan.category === "include-source") {
+        this.bridge.reload();
+        return;
+      }
+      if (plan.processorHandledAsset) {
         return;
       }
-      await this.hmrManager.handleFileChange(filePath);
+      if (plan.delegateToHmr) {
+        await this.hmrManager.handleFileChange(filePath);
+      }
     } catch (error) {
       if (error instanceof Error) {
         this.bridge.error(error.message);
@@ -105,42 +139,56 @@ class ProjectWatcher {
       }
     }
   }
+  /**
+   * Notifies all processors whose watch config matches the given file extension.
+   * This is called before checking processor ownership so that dependency-only
+   * processors (e.g. PostCSS watching .tsx for class scanning) receive their
+   * notifications regardless of whether they own the file.
+   */
+  async notifyProcessors(filePath, event) {
+    const ctx = { path: filePath, bridge: this.bridge };
+    for (const processor of this.appConfig.processors.values()) {
+      const watchConfig = processor.getWatchConfig();
+      if (!watchConfig) continue;
+      const { extensions = [] } = watchConfig;
+      if (extensions.length && !extensions.some((ext) => filePath.endsWith(ext))) {
+        continue;
+      }
+      const handler = this.getProcessorHandler(watchConfig, event);
+      if (handler) {
+        await handler(ctx);
+      }
+    }
+  }
+  getProcessorHandler(watchConfig, event) {
+    switch (event) {
+      case "change":
+        return watchConfig.onChange;
+      case "add":
+        return watchConfig.onCreate;
+      case "unlink":
+        return watchConfig.onDelete;
+    }
+  }
   /**
    * Checks if a file is in the public directory.
    */
   isPublicDirFile(filePath) {
-    return filePath.startsWith(this.appConfig.absolutePaths.publicDir);
+    return this.invalidationService.isPublicDirFile(filePath);
   }
   /**
    * Checks if file path matches any additionalWatchPaths patterns.
    */
   matchesAdditionalWatchPaths(filePath) {
-    const patterns = this.appConfig.additionalWatchPaths;
-    if (!patterns.length) return false;
-    for (const pattern of patterns) {
-      if (pattern.includes("*")) {
-        const ext = pattern.replace(/\*\*?\/\*/, "");
-        if (filePath.endsWith(ext)) return true;
-      } else {
-        if (filePath.endsWith(pattern) || filePath === path.resolve(pattern)) return true;
-      }
-    }
-    return false;
+    return this.invalidationService.matchesAdditionalWatchPaths(filePath);
   }
   /**
    * Checks if a file is handled by a processor.
-   * Processors that declare extensions own those file types.
+   * Processors that declare asset capabilities own those file types.
+   * Processors without capabilities fall back to checking watch extensions.
    */
   isHandledByProcessor(filePath) {
-    for (const processor of this.appConfig.processors.values()) {
-      const watchConfig = processor.getWatchConfig();
-      if (!watchConfig) continue;
-      const { extensions = [] } = watchConfig;
-      if (extensions.length && extensions.some((ext) => filePath.endsWith(ext))) {
-        return true;
-      }
-    }
-    return false;
+    return this.invalidationService.isProcessorOwnedAsset(filePath);
   }
   /**
    * Triggers router refresh for page directory changes.
@@ -148,10 +196,11 @@ class ProjectWatcher {
    *
    * @param {string} path - Path of the changed directory
    */
-  triggerRouterRefresh(path2) {
-    const isPageDir = path2.startsWith(this.appConfig.absolutePaths.pagesDir);
-    if (isPageDir) {
-      this.refreshRouterRoutesCallback();
+  async triggerRouterRefresh(changedPath) {
+    const resolvedPath = path.resolve(changedPath);
+    const isPageDir = resolvedPath.startsWith(this.appConfig.absolutePaths.pagesDir) && path.extname(resolvedPath) === "";
+    if (isPageDir || this.isRouteSourceFile(resolvedPath)) {
+      await this.refreshRouterRoutesCallback();
     }
   }
   /**
@@ -165,71 +214,59 @@ class ProjectWatcher {
     }
     appLogger.error(`Watcher error: ${error}`);
   }
-  /**
-   * Processes file changes for specific file extensions.
-   * Used by processors to handle their specific file types.
-   *
-   * @private
-   * @param {string} path - Path of the changed file
-   * @param {string[]} extensions - File extensions to process
-   * @param {(ctx: ProcessorWatchContext) => void} handler - Handler function for the file change
-   */
-  shouldProcess(path2, extensions, handler) {
-    if (!extensions.length || extensions.some((ext) => path2.endsWith(ext))) {
-      handler({ path: path2, bridge: this.bridge });
-    }
-  }
   /**
    * Creates and configures the file system watcher.
    * This sets up:
-   * 1. Processor-specific file watching
-   * 2. Page file watching
-   * 3. Directory watching
-   * 4. Error handling
+   * 1. Page file watching
+   * 2. Directory watching
+   * 3. Error handling
+   *
+   * Processor notifications are dispatched inside handleFileChange, ensuring
+   * a single unified event pipeline with no parallel chokidar bindings.
    *
    * Uses chokidar's built-in debouncing through `awaitWriteFinish` to handle
    * rapid file changes efficiently.
    */
   async createWatcherSubscription() {
-    if (!this.watcher) {
-      const processorPaths = [];
-      for (const processor of this.appConfig.processors.values()) {
-        const watchConfig = processor.getWatchConfig();
-        if (!watchConfig) continue;
-        processorPaths.push(...watchConfig.paths);
-      }
-      if (fileSystem.exists(this.appConfig.absolutePaths.pagesDir)) {
-        processorPaths.push(this.appConfig.absolutePaths.pagesDir);
-      }
-      if (fileSystem.exists(this.appConfig.absolutePaths.publicDir)) {
-        processorPaths.push(this.appConfig.absolutePaths.publicDir);
-      }
-      if (this.appConfig.additionalWatchPaths.length) {
-        processorPaths.push(...this.appConfig.additionalWatchPaths);
-      }
-      this.watcher = chokidar.watch(processorPaths, {
-        ignoreInitial: true,
-        ignorePermissionErrors: true,
-        awaitWriteFinish: {
-          stabilityThreshold: 50,
-          pollInterval: 50
-        }
-      });
+    if (this.watcher) {
+      return this.watcher;
     }
+    const processorPaths = [];
     for (const processor of this.appConfig.processors.values()) {
       const watchConfig = processor.getWatchConfig();
       if (!watchConfig) continue;
-      const { extensions = [], onCreate, onChange, onDelete, onError } = watchConfig;
-      if (onCreate) this.watcher.on("add", (path2) => this.shouldProcess(path2, extensions, onCreate));
-      if (onChange) this.watcher.on("change", (path2) => this.shouldProcess(path2, extensions, onChange));
-      if (onDelete) this.watcher.on("unlink", (path2) => this.shouldProcess(path2, extensions, onDelete));
-      if (onError) this.watcher.on("error", onError);
-    }
-    this.watcher.add(this.appConfig.absolutePaths.srcDir);
-    this.watcher.on("change", (path2) => this.handleFileChange(path2)).on("add", (path2) => {
-      this.handleFileChange(path2);
-      this.triggerRouterRefresh(path2);
-    }).on("addDir", (path2) => this.triggerRouterRefresh(path2)).on("unlink", (path2) => this.triggerRouterRefresh(path2)).on("unlinkDir", (path2) => this.triggerRouterRefresh(path2)).on("error", (error) => this.handleError(error));
+      processorPaths.push(...watchConfig.paths);
+    }
+    if (fileSystem.exists(this.appConfig.absolutePaths.includesDir)) {
+      processorPaths.push(this.appConfig.absolutePaths.includesDir);
+    }
+    if (fileSystem.exists(this.appConfig.absolutePaths.srcDir)) {
+      processorPaths.push(this.appConfig.absolutePaths.srcDir);
+    }
+    if (fileSystem.exists(this.appConfig.absolutePaths.pagesDir)) {
+      processorPaths.push(this.appConfig.absolutePaths.pagesDir);
+    }
+    if (fileSystem.exists(this.appConfig.absolutePaths.publicDir)) {
+      processorPaths.push(this.appConfig.absolutePaths.publicDir);
+    }
+    if (this.appConfig.additionalWatchPaths.length) {
+      processorPaths.push(...this.appConfig.additionalWatchPaths);
+    }
+    this.watcher = chokidar.watch(processorPaths, {
+      ignoreInitial: true,
+      ignorePermissionErrors: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 50,
+        pollInterval: 50
+      }
+    });
+    this.watcher.on("change", (p) => this.enqueueChange(() => this.handleFileChange(p, "change"))).on("add", (p) => this.enqueueChange(() => this.handleFileChange(p, "add"))).on("addDir", (p) => this.enqueueChange(() => this.triggerRouterRefresh(p))).on("unlink", (p) => this.enqueueChange(() => this.handleFileChange(p, "unlink"))).on("unlinkDir", (p) => this.enqueueChange(() => this.triggerRouterRefresh(p))).on("error", (error) => this.handleError(error));
+    for (const processor of this.appConfig.processors.values()) {
+      const watchConfig = processor.getWatchConfig();
+      if (watchConfig?.onError) {
+        this.watcher.on("error", watchConfig.onError);
+      }
+    }
     return this.watcher;
   }
 }

package/src/watchers/project-watcher.test-helpers.d.ts

@@ -1,4 +1,4 @@
-import type { IHmrManager } from '../internal-types';
-import type { ClientBridge } from '../adapters/bun/client-bridge';
+import type { IHmrManager } from '../types/internal-types.js';
+import type { ClientBridge } from '../adapters/bun/client-bridge.js';
 export declare const createMockHmrManager: () => IHmrManager;
 export declare const createMockBridge: () => ClientBridge;

package/src/watchers/project-watcher.test-helpers.js

@@ -9,6 +9,7 @@ const createMockHmrManager = () => ({
   setPlugins: vi.fn(() => {
   }),
   registerEntrypoint: vi.fn(async () => ""),
+  registerScriptEntrypoint: vi.fn(async () => ""),
   registerSpecifierMap: vi.fn(() => {
   }),
   registerStrategy: vi.fn(() => {

package/src/adapters/abstract/application-adapter.ts

@@ -1,337 +0,0 @@
-/**
- * This file defines the abstract class for application adapters in EcoPages.
- * It provides a common interface for different runtimes (e.g., Node.js, Deno) to implement.
- * The class includes methods for handling HTTP requests and managing application state.
- * It also includes a method for parsing command-line arguments.
- *
- * @module ApplicationAdapter
- */
-
-import { appLogger } from '../../global/app-logger.ts';
-import type { EcoPagesAppConfig } from '../../internal-types.ts';
-import { invariant } from '../../utils/invariant.ts';
-import type {
-	ApiHandler,
-	ApiHandlerContext,
-	ErrorHandler,
-	Middleware,
-	RouteOptions,
-	StaticRoute,
-	ViewLoader,
-} from '../../public-types.ts';
-import { fileSystem } from '@ecopages/file-system';
-import { parseCliArgs, type ReturnParseCliArgs } from '../../utils/parse-cli-args.ts';
-
-/**
- * Configuration options for application adapters
- */
-export interface ApplicationAdapterOptions {
-	appConfig: EcoPagesAppConfig;
-	serverOptions?: Record<string, any>;
-	/**
-	 * Options for clearing the output directory before starting the server
-	 * @default false
-	 */
-	clearOutput?: boolean;
-}
-
-/**
- * Common interface for application adapters
- */
-export interface ApplicationAdapter<T = any> {
-	start(): Promise<T | void>;
-}
-
-/**
- * Handler function type for route handlers
- */
-export type RouteHandler<
-	TRequest extends Request = Request,
-	TServer = any,
-	TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-> = (context: TContext) => Promise<Response> | Response;
-
-export type RouteGroupDefinition<TRequest extends Request = Request, TServer = any> = {
-	prefix: string;
-	middleware?: readonly Middleware<TRequest, TServer, any>[];
-	routes: readonly ApiHandler<string, TRequest, TServer>[];
-};
-
-/**
- * Abstract base class for application adapters across different runtimes
- */
-export abstract class AbstractApplicationAdapter<
-	TOptions extends ApplicationAdapterOptions = ApplicationAdapterOptions,
-	TServer = any,
-	TRequest extends Request = any,
-> implements ApplicationAdapter<TServer> {
-	protected appConfig: EcoPagesAppConfig;
-	protected serverOptions: Record<string, any>;
-	protected cliArgs: ReturnParseCliArgs;
-	protected apiHandlers: ApiHandler[] = [];
-	protected staticRoutes: StaticRoute[] = [];
-	protected errorHandler?: ErrorHandler;
-
-	constructor(options: TOptions) {
-		this.appConfig = options.appConfig;
-		this.serverOptions = options.serverOptions || {};
-		this.cliArgs = parseCliArgs();
-
-		if (options.clearOutput) {
-			this.clearDistFolder().catch((error) => {
-				appLogger.error('Error clearing dist folder', error as Error);
-			});
-		}
-	}
-
-	private async clearDistFolder(_filter: string[] = []): Promise<void> {
-		const distPath = this.appConfig.absolutePaths.distDir;
-		const distExists = fileSystem.exists(distPath);
-
-		if (!distExists) return;
-
-		try {
-			await fileSystem.removeAsync(distPath);
-			appLogger.debug(`Cleared dist folder: ${distPath}`);
-		} catch (error) {
-			appLogger.error(`Error clearing dist folder: ${distPath}`, error as Error);
-		}
-	}
-
-	/**
-	 * Register a GET route handler.
-	 *
-	 * Use verb methods for inline route definitions.
-	 * For dynamic HTTP method registration, use `route(...)`.
-	 */
-	abstract get<
-		P extends string,
-		TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-	>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this;
-
-	/**
-	 * Register a POST route handler
-	 */
-	abstract post<
-		P extends string,
-		TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-	>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this;
-
-	/**
-	 * Register a PUT route handler
-	 */
-	abstract put<
-		P extends string,
-		TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-	>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this;
-
-	/**
-	 * Register a DELETE route handler
-	 */
-	abstract delete<
-		P extends string,
-		TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-	>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this;
-
-	/**
-	 * Register a PATCH route handler
-	 */
-	abstract patch<
-		P extends string,
-		TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-	>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this;
-
-	/**
-	 * Register an OPTIONS route handler
-	 */
-	abstract options<
-		P extends string,
-		TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-	>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this;
-
-	/**
-	 * Register a HEAD route handler
-	 */
-	abstract head<
-		P extends string,
-		TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-	>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this;
-
-	/**
-	 * Register a route with an explicit HTTP method.
-	 *
-	 * This is useful when the method is determined programmatically, or when
-	 * registering a pre-built route declaration object by forwarding its
-	 * `path`, `method`, and `handler` fields.
-	 */
-	abstract route<P extends string>(
-		path: P,
-		method: ApiHandler['method'],
-		handler: RouteHandler<TRequest, TServer>,
-		options?: RouteOptions<TRequest, TServer>,
-	): this;
-
-	/**
-	 * Register a pre-built API handler declaration.
-	 */
-	abstract add(handler: ApiHandler<string, TRequest, TServer>): this;
-
-	/**
-	 * Internal method to add route handlers to the API handlers array
-	 */
-	protected addRouteHandler<
-		P extends string,
-		TSpecRequest extends TRequest = TRequest,
-		TSpecServer extends TServer = TServer,
-		TContext extends ApiHandlerContext<TSpecRequest, TSpecServer> = ApiHandlerContext<TSpecRequest, TSpecServer>,
-	>(
-		path: P,
-		method: ApiHandler['method'],
-		handler: RouteHandler<TSpecRequest, TSpecServer, TContext>,
-		middleware?: Middleware<TSpecRequest, TSpecServer, TContext>[],
-		schema?: ApiHandler['schema'],
-	): this {
-		invariant(
-			typeof path === 'string',
-			`Invalid route path for ${method}: expected a string path starting with "/" but received ${Object.prototype.toString.call(path)}. If you're passing a prebuilt ApiHandler, use app.add(handler).`,
-		);
-
-		invariant(
-			path.startsWith('/'),
-			`Invalid route path for ${method}: "${path}". Route paths must start with '/'.`,
-		);
-
-		this.apiHandlers.push({
-			path,
-			method,
-			handler: handler as ApiHandler['handler'],
-			middleware: middleware as ApiHandler['middleware'],
-			schema,
-		});
-		return this;
-	}
-
-	/**
-	 * Create a route group with shared prefix and middleware.
-	 * Routes defined within the group inherit the prefix and middleware.
-	 *
-	 * Each adapter implements this with its own builder type to support
-	 * runtime-specific features (e.g., Bun's path parameter inference).
-	 * Implementations may also support passing a pre-built group object.
-	 *
-	 * @param prefix - URL prefix for all routes in the group (e.g., '/api/v1')
-	 * @param callback - Function that receives a builder to define routes
-	 * @param options - Optional group-level middleware
-	 */
-	abstract group(
-		prefix: string,
-		callback: (builder: unknown) => void,
-		options?: {
-			middleware?: readonly Middleware<TRequest, TServer, any>[];
-		},
-	): this;
-
-	abstract group(group: RouteGroupDefinition<TRequest, TServer>): this;
-
-	/**
-	 * Get all registered API handlers
-	 */
-	getApiHandlers(): ApiHandler[] {
-		return this.apiHandlers;
-	}
-
-	/**
-	 * Register a view for static generation at build time.
-	 * The view must have staticPaths defined for dynamic routes.
-	 *
-	 * Uses a loader function to enable HMR in development.
-	 *
-	 * @param path - URL path pattern (e.g., '/posts/:slug')
-	 * @param loader - A function that dynamically imports the eco.page view module
-	 * @example
-	 * ```typescript
-	 * app.static('/login', () => import('./src/views/login.kita'))
-	 * app.static('/posts/:slug', () => import('./src/views/post-view.kita'))
-	 * ```
-	 */
-	static<P>(path: string, loader: ViewLoader<P>): this {
-		this.staticRoutes.push({ path, loader });
-		return this;
-	}
-
-	/**
-	 * Get all registered static routes
-	 */
-	getStaticRoutes(): StaticRoute[] {
-		return this.staticRoutes;
-	}
-
-	/**
-	 * Register a global error handler for all routes.
-	 * Useful for logging, monitoring integration, and custom error formatting.
-	 *
-	 * @example
-	 * ```typescript
-	 * app.onError(async (error, ctx) => {
-	 *   logger.error(error);
-	 *   return ctx.response.status(500).json({ error: 'Something went wrong' });
-	 * });
-	 * ```
-	 */
-	onError(handler: ErrorHandler<TRequest, TServer>): this {
-		this.errorHandler = handler as unknown as ErrorHandler;
-		return this;
-	}
-
-	/**
-	 * Get the registered error handler
-	 */
-	getErrorHandler(): ErrorHandler | undefined {
-		return this.errorHandler;
-	}
-
-	/**
-	 * Initialize the server adapter based on the runtime
-	 */
-	protected abstract initializeServerAdapter(): Promise<any>;
-
-	/**
-	 * Start the application server
-	 */
-	public abstract start(): Promise<TServer | void>;
-
-	/**
-	 * Handles a standard Web request without requiring a bound network server.
-	 * This is the primary interoperability surface for embedding Ecopages inside
-	 * other runtimes and frameworks.
-	 */
-	public abstract fetch(request: TRequest): Promise<Response>;
-}