@ecopages/core 0.2.0-alpha.25 → 0.2.0-alpha.26

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

@@ -0,0 +1,194 @@
+/**
+ * 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 type { SourceModuleLoader } from '../../services/module-loading/module-loading-types.js';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import type { ApiHandler, ApiHandlerContext, ErrorHandler, Middleware, RouteOptions, StaticRoute, ViewLoader } from '../../types/public-types.js';
+import { type ReturnParseCliArgs } from '../../utils/parse-cli-args.js';
+/**
+ * Runtime bootstrap options layered on top of the app config.
+ *
+ * These options let a host runtime embed Ecopages without mutating process
+ * globals or app runtime state before calling `createApp()`.
+ */
+export interface ApplicationRuntimeOptions {
+    /**
+     * Forces the app into the embedded-runtime CLI mode used by host
+     * environments.
+     *
+     * When enabled and no explicit `hostModuleLoader` is provided, the
+     * adapter auto-detects a host module loader from the global scope.
+     */
+    embedded?: boolean;
+    /**
+     * Explicit source module loader for request-time imports.
+     *
+     * When omitted in embedded mode, the adapter attempts automatic
+     * detection from globals set by the host environment.
+     */
+    hostModuleLoader?: SourceModuleLoader;
+}
+/**
+ * Configuration options for application adapters
+ */
+export interface ApplicationAdapterOptions {
+    appConfig: EcoPagesAppConfig;
+    serverOptions?: Record<string, any>;
+    runtime?: ApplicationRuntimeOptions;
+    /**
+     * 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 declare 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 runtimeOptions: ApplicationRuntimeOptions;
+    protected apiHandlers: ApiHandler[];
+    protected staticRoutes: StaticRoute[];
+    protected errorHandler?: ErrorHandler;
+    constructor(options: TOptions);
+    private clearDistFolder;
+    /**
+     * 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;
+    /**
+     * 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[];
+    /**
+     * 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;
+    /**
+     * Get all registered static routes
+     */
+    getStaticRoutes(): StaticRoute[];
+    /**
+     * 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;
+    /**
+     * Get the registered error handler
+     */
+    getErrorHandler(): ErrorHandler | undefined;
+    /**
+     * Initialize the server adapter based on the runtime
+     */
+    protected abstract initializeServerAdapter(): Promise<any>;
+    /**
+     * Start the application server
+     */
+    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.
+     */
+    abstract fetch(request: TRequest): Promise<Response>;
+}

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

@@ -0,0 +1,121 @@
+import { appLogger } from "../../global/app-logger.js";
+import {
+  getAppModuleLoader,
+  setAppHostModuleLoader
+} from "../../services/module-loading/app-server-module-transpiler.service.js";
+import { getHostModuleLoader } from "../../services/module-loading/host-module-loader-registry.js";
+import { invariant } from "../../utils/invariant.js";
+import { fileSystem } from "@ecopages/file-system";
+import { parseCliArgs } from "../../utils/parse-cli-args.js";
+class AbstractApplicationAdapter {
+  appConfig;
+  serverOptions;
+  cliArgs;
+  runtimeOptions;
+  apiHandlers = [];
+  staticRoutes = [];
+  errorHandler;
+  constructor(options) {
+    this.appConfig = options.appConfig;
+    this.serverOptions = options.serverOptions || {};
+    this.runtimeOptions = options.runtime ?? {};
+    this.cliArgs = parseCliArgs({ embeddedRuntime: this.runtimeOptions.embedded });
+    const hostModuleLoader = this.runtimeOptions.hostModuleLoader ?? (this.runtimeOptions.embedded ? getHostModuleLoader() : void 0);
+    if (hostModuleLoader) {
+      setAppHostModuleLoader(this.appConfig, hostModuleLoader);
+    }
+    getAppModuleLoader(this.appConfig);
+    if (options.clearOutput) {
+      this.clearDistFolder().catch((error) => {
+        appLogger.error("Error clearing dist folder", error);
+      });
+    }
+  }
+  async clearDistFolder() {
+    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);
+    }
+  }
+  /**
+   * Internal method to add route handlers to the API handlers array
+   */
+  addRouteHandler(path, method, handler, middleware, schema) {
+    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,
+      middleware,
+      schema
+    });
+    return this;
+  }
+  /**
+   * Get all registered API handlers
+   */
+  getApiHandlers() {
+    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(path, loader) {
+    this.staticRoutes.push({ path, loader });
+    return this;
+  }
+  /**
+   * Get all registered static routes
+   */
+  getStaticRoutes() {
+    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) {
+    this.errorHandler = handler;
+    return this;
+  }
+  /**
+   * Get the registered error handler
+   */
+  getErrorHandler() {
+    return this.errorHandler;
+  }
+}
+export {
+  AbstractApplicationAdapter
+};

package/src/adapters/abstract/router-adapter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This file contains the abstract router adapter class and its methods.
+ * It is designed to be extended by specific router adapters for different runtimes.
+ * The class provides methods for converting paths, creating route handlers,
+ * and adapting routes to the expected format of the runtime.
+ *
+ * @module RouterAdapter
+ */
+import type { Routes } from '../../types/internal-types.js';
+/**
+ * Abstract base class for router adapters across different runtimes
+ */
+export declare abstract class AbstractRouterAdapter<TRouteFormat = any> {
+    /**
+     * Convert a route path to the format expected by the runtime
+     */
+    protected abstract convertPath(pathname: string): string;
+    /**
+     * Create a route handler compatible with the runtime
+     */
+    protected abstract createRouteHandler(route: any): any;
+    /**
+     * Adapt framework routes to the format expected by the runtime
+     */
+    abstract adaptRoutes(routes: Routes): TRouteFormat;
+}

package/src/adapters/abstract/router-adapter.js

@@ -0,0 +1,5 @@
+class AbstractRouterAdapter {
+}
+export {
+  AbstractRouterAdapter
+};

package/src/adapters/abstract/server-adapter.d.ts

@@ -0,0 +1,69 @@
+/**
+ * This file contains the abstract server adapter class and its related types.
+ * It is designed to be extended by specific server adapters for different runtimes.
+ * The class provides methods for initializing the server, creating server options,
+ * building static files, and handling HTTP requests.
+ *
+ * @module ServerAdapter
+ */
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import type { ApiHandler } from '../../types/public-types.js';
+/**
+ * Configuration options for all server adapters
+ */
+export interface ServerAdapterOptions {
+    appConfig: EcoPagesAppConfig;
+    apiHandlers?: ApiHandler<string, any>[];
+    options?: {
+        watch?: boolean;
+        [key: string]: any;
+    };
+    serveOptions?: Record<string, any>;
+    runtimeOrigin: string;
+}
+/**
+ * Base adapter result containing common functionalities
+ * across different runtime implementations
+ */
+export interface ServerAdapterResult {
+    getServerOptions: (options?: {
+        enableHmr?: boolean;
+    }) => any;
+    buildStatic: (options?: {
+        preview?: boolean;
+    }) => Promise<void>;
+}
+/**
+ * Abstract base class for server adapters across different runtimes
+ */
+export declare abstract class AbstractServerAdapter<TOptions extends ServerAdapterOptions = ServerAdapterOptions, TResult extends ServerAdapterResult = ServerAdapterResult> {
+    protected appConfig: EcoPagesAppConfig;
+    protected options: TOptions['options'];
+    protected serveOptions: TOptions['serveOptions'];
+    protected runtimeOrigin: string;
+    constructor(options: TOptions);
+    /**
+     * Initialize the server adapter
+     */
+    abstract initialize(): Promise<void>;
+    /**
+     * Create server options specific to the runtime
+     */
+    abstract getServerOptions(options?: {
+        enableHmr?: boolean;
+    }): any;
+    /**
+     * Build static files for the application
+     */
+    abstract buildStatic(options?: {
+        preview?: boolean;
+    }): Promise<void>;
+    /**
+     * Factory method to create a server adapter with runtime-specific functionality
+     */
+    abstract createAdapter(): Promise<TResult>;
+    /**
+     * Handle HTTP requests
+     */
+    abstract handleRequest(request: Request): Promise<Response>;
+}

package/src/adapters/abstract/server-adapter.js

@@ -0,0 +1,15 @@
+class AbstractServerAdapter {
+  appConfig;
+  options;
+  serveOptions;
+  runtimeOrigin;
+  constructor(options) {
+    this.appConfig = options.appConfig;
+    this.options = options.options || {};
+    this.serveOptions = options.serveOptions || {};
+    this.runtimeOrigin = options.runtimeOrigin;
+  }
+}
+export {
+  AbstractServerAdapter
+};

package/src/adapters/bun/client-bridge.d.ts

@@ -0,0 +1,34 @@
+import type { ServerWebSocket } from 'bun';
+import type { ClientBridgeEvent, IClientBridge } from '../../types/public-types.js';
+type BunSocket = ServerWebSocket<unknown>;
+/**
+ * Manages WebSocket subscribers and broadcasts development events.
+ * Bridges the gap between the server and the development client.
+ */
+export declare class ClientBridge implements IClientBridge {
+    private subscribers;
+    subscribe(ws: BunSocket): void;
+    unsubscribe(ws: BunSocket): void;
+    /**
+     * Broadcast a raw event to all connected clients.
+     */
+    broadcast(event: ClientBridgeEvent): void;
+    /**
+     * Trigger a full page reload on all connected clients.
+     */
+    reload(): void;
+    /**
+     * Broadcast a CSS update for hot stylesheet reload.
+     */
+    cssUpdate(path: string): void;
+    /**
+     * Broadcast a JS module update for hot module replacement.
+     */
+    update(path: string): void;
+    /**
+     * Broadcast an error message to connected clients.
+     */
+    error(message: string): void;
+    get subscriberCount(): number;
+}
+export {};

package/src/adapters/bun/client-bridge.js

@@ -0,0 +1,48 @@
+class ClientBridge {
+  subscribers = /* @__PURE__ */ new Set();
+  subscribe(ws) {
+    this.subscribers.add(ws);
+  }
+  unsubscribe(ws) {
+    this.subscribers.delete(ws);
+  }
+  /**
+   * Broadcast a raw event to all connected clients.
+   */
+  broadcast(event) {
+    const payload = JSON.stringify(event);
+    for (const ws of this.subscribers) {
+      ws.send(payload);
+    }
+  }
+  /**
+   * Trigger a full page reload on all connected clients.
+   */
+  reload() {
+    this.broadcast({ type: "reload" });
+  }
+  /**
+   * Broadcast a CSS update for hot stylesheet reload.
+   */
+  cssUpdate(path) {
+    this.broadcast({ type: "css-update", path, timestamp: Date.now() });
+  }
+  /**
+   * Broadcast a JS module update for hot module replacement.
+   */
+  update(path) {
+    this.broadcast({ type: "update", path, timestamp: Date.now() });
+  }
+  /**
+   * Broadcast an error message to connected clients.
+   */
+  error(message) {
+    this.broadcast({ type: "error", message });
+  }
+  get subscriberCount() {
+    return this.subscribers.size;
+  }
+}
+export {
+  ClientBridge
+};

package/src/adapters/bun/create-app.d.ts

@@ -0,0 +1,52 @@
+/**
+ * This file contains the implementation of the Bun application adapter for EcoPages.
+ * It extends the AbstractApplicationAdapter class and provides methods for handling
+ * HTTP requests, initializing the server adapter, and starting the Bun application server.
+ * The adapter is designed to work with the Bun runtime and provides a way to create
+ * EcoPages applications using Bun's features.
+ *
+ * @module EcopagesApp
+ */
+import type { Server } from 'bun';
+import type { ApiHandlerContext, RouteGroupBuilder } from '../../types/public-types.js';
+import { SharedApplicationAdapter } from '../shared/application-adapter.js';
+import type { EcopagesAppOptions } from '../create-app.js';
+import { type BunServerAdapterResult } from './server-adapter.js';
+/**
+ * Bun-specific route group builder that properly infers route params from path patterns.
+ * When you define a route like `/posts/:slug`, the handler context will have
+ * `ctx.params.slug` typed as `string`.
+ *
+ * @typeParam WebSocketData - WebSocket data type for the server
+ * @typeParam TContext - Extended context type from middleware (e.g., `{ user: User }`)
+ */
+export type BunRouteGroupBuilder<WebSocketData = undefined, TContext extends ApiHandlerContext<Request, Server<WebSocketData>> = ApiHandlerContext<Request, Server<WebSocketData>>> = RouteGroupBuilder<Request, Server<WebSocketData>, TContext>;
+/**
+ * Bun-specific application adapter implementation
+ * This class extends the {@link AbstractApplicationAdapter}
+ * and provides methods for handling HTTP requests and managing the server.
+ */
+export declare class BunEcopagesApp<WebSocketData = undefined> extends SharedApplicationAdapter<EcopagesAppOptions, Server<WebSocketData>, Request> {
+    serverAdapter: BunServerAdapterResult | undefined;
+    private server;
+    fetch(request: Request): Promise<Response>;
+    /**
+     * Complete the initialization of the server adapter by processing dynamic routes
+     * @param server The Bun server instance
+     */
+    completeInitialization(server: Server<WebSocketData>): Promise<void>;
+    /**
+     * Initialize the Bun server adapter
+     */
+    protected initializeServerAdapter(): Promise<BunServerAdapterResult>;
+    /**
+     * Start the Bun application server
+     * @param options Optional settings
+     * @param options.autoCompleteInitialization Whether to automatically complete initialization with dynamic routes after server start (defaults to true)
+     */
+    start(): Promise<Server<WebSocketData> | void>;
+}
+/**
+ * Factory function to create a Bun application
+ */
+export declare function createApp<WebSocketData = undefined>(options: EcopagesAppOptions): Promise<BunEcopagesApp<WebSocketData>>;

package/src/adapters/bun/create-app.js

@@ -0,0 +1,116 @@
+import { DEFAULT_ECOPAGES_HOSTNAME, DEFAULT_ECOPAGES_PORT } from "../../config/constants.js";
+import { appLogger } from "../../global/app-logger.js";
+import { getBunRuntime } from "../../utils/runtime.js";
+import { SharedApplicationAdapter } from "../shared/application-adapter.js";
+import { createBunServerAdapter } from "./server-adapter.js";
+class BunEcopagesApp extends SharedApplicationAdapter {
+  serverAdapter;
+  server = null;
+  async fetch(request) {
+    if (!this.serverAdapter) {
+      this.serverAdapter = await this.initializeServerAdapter();
+    }
+    await this.serverAdapter.completeInitialization(this.server);
+    return this.serverAdapter.handleRequest(request);
+  }
+  /**
+   * Complete the initialization of the server adapter by processing dynamic routes
+   * @param server The Bun server instance
+   */
+  async completeInitialization(server) {
+    if (!this.serverAdapter) {
+      throw new Error("Server adapter not initialized. Call start() first.");
+    }
+    await this.serverAdapter.completeInitialization(server);
+  }
+  /**
+   * Initialize the Bun server adapter
+   */
+  async initializeServerAdapter() {
+    const { dev } = this.cliArgs;
+    const { port: cliPort, hostname: cliHostname } = this.cliArgs;
+    const envPort = process.env.ECOPAGES_PORT ? process.env.ECOPAGES_PORT : void 0;
+    const envHostname = process.env.ECOPAGES_HOSTNAME;
+    const preferredPort = cliPort ?? envPort ?? DEFAULT_ECOPAGES_PORT;
+    const preferredHostname = cliHostname ?? envHostname ?? DEFAULT_ECOPAGES_HOSTNAME;
+    appLogger.debug("initializeServerAdapter", {
+      dev,
+      cliPort,
+      cliHostname,
+      envPort,
+      envHostname,
+      preferredPort,
+      preferredHostname,
+      composedUrl: `http://${preferredHostname}:${preferredPort}`
+    });
+    return await createBunServerAdapter({
+      runtimeOrigin: `http://${preferredHostname}:${preferredPort}`,
+      appConfig: this.appConfig,
+      apiHandlers: this.apiHandlers,
+      staticRoutes: this.staticRoutes,
+      errorHandler: this.errorHandler,
+      options: { watch: dev },
+      serveOptions: {
+        port: preferredPort,
+        hostname: preferredHostname,
+        ...this.serverOptions
+      }
+    });
+  }
+  /**
+   * Start the Bun application server
+   * @param options Optional settings
+   * @param options.autoCompleteInitialization Whether to automatically complete initialization with dynamic routes after server start (defaults to true)
+   */
+  async start() {
+    if (!this.serverAdapter) {
+      this.serverAdapter = await this.initializeServerAdapter();
+    }
+    const { dev, preview, build } = this.cliArgs;
+    const requiresFetchRuntime = this.appConfig.integrations.some(
+      (integration) => integration.staticBuildStep === "fetch"
+    );
+    const canBuildWithoutRuntimeServer = (build || preview) && !requiresFetchRuntime;
+    if (canBuildWithoutRuntimeServer) {
+      appLogger.debugTime("Building static pages");
+      await this.serverAdapter.buildStatic({ preview });
+      appLogger.debugTimeEnd("Building static pages");
+      if (build) {
+        process.exit(0);
+      }
+      return;
+    }
+    const enableHmr = dev || !preview && !build;
+    const serverOptions = this.serverAdapter.getServerOptions({ enableHmr });
+    const bun = getBunRuntime();
+    if (!bun) {
+      throw new Error("Bun runtime is required for the Bun adapter");
+    }
+    const bunServer = bun.serve(serverOptions);
+    this.server = bunServer;
+    await this.serverAdapter.completeInitialization(this.server).catch((error) => {
+      appLogger.error(`Failed to complete initialization: ${error}`);
+    });
+    if (!this.server) {
+      throw new Error("Server failed to start");
+    }
+    appLogger.info(`Server running at http://${this.server.hostname}:${this.server.port}`);
+    if (build || preview) {
+      appLogger.debugTime("Building static pages");
+      await this.serverAdapter.buildStatic({ preview });
+      this.server.stop(true);
+      appLogger.debugTimeEnd("Building static pages");
+      if (build) {
+        process.exit(0);
+      }
+    }
+    return this.server;
+  }
+}
+async function createApp(options) {
+  return new BunEcopagesApp(options);
+}
+export {
+  BunEcopagesApp,
+  createApp
+};