@ecopages/core 0.2.0-alpha.54 → 0.2.0-alpha.55

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

@@ -0,0 +1,450 @@
+import path from "node:path";
+import { DEFAULT_ECOPAGES_HOSTNAME, DEFAULT_ECOPAGES_PORT } from "../../config/constants.js";
+import { RESOLVED_ASSETS_DIR } from "../../config/constants.js";
+import { appLogger } from "../../global/app-logger.js";
+import { HttpError } from "../../errors/http-error.js";
+import { createRequire } from "../../utils/locals-utils.js";
+import { fileSystem } from "@ecopages/file-system";
+import { getAppBrowserBuildPlugins, setupAppRuntimePlugins } from "../../build/build-adapter.js";
+import { installAppRuntimeBuildExecutor } from "../../build/runtime-build-executor.js";
+import { StaticSiteGenerator } from "../../static-site-generator/static-site-generator.js";
+import { ProjectWatcher } from "../../watchers/project-watcher.js";
+import { SharedServerAdapter } from "../shared/server-adapter.js";
+import { ApiResponseBuilder } from "../shared/api-response.js";
+import { ServerStaticBuilder } from "../shared/server-static-builder.js";
+import {
+  injectHmrRuntimeIntoHtmlResponse,
+  isHtmlResponse,
+  shouldInjectHmrHtmlResponse
+} from "../shared/hmr-html-response.js";
+import { resolveServeRuntimeOrigin } from "../shared/runtime-app-bootstrap.js";
+import { ClientBridge } from "./client-bridge.js";
+import { HmrManager } from "./hmr-manager.js";
+import { BunStaticPreviewHost } from "./static-preview-host.js";
+class BunServerAdapter extends SharedServerAdapter {
+  apiHandlers;
+  staticRoutes;
+  errorHandler;
+  bridge;
+  hmrManager;
+  initializationPromise = null;
+  fullyInitialized = false;
+  previewHost;
+  /**
+   * Creates a Bun server adapter with already-resolved runtime collaborators.
+   *
+   * @remarks
+   * The public params interface keeps `hmrManager`, `bridge`, and `previewHost`
+   * optional so factory callers can omit them. By the time the concrete adapter
+   * is constructed, those collaborators are mandatory because the adapter cannot
+   * initialize Bun HMR or preview flows without them.
+   */
+  constructor({
+    appConfig,
+    runtimeOrigin,
+    serveOptions,
+    apiHandlers,
+    staticRoutes,
+    errorHandler,
+    options,
+    hmrManager,
+    bridge,
+    previewHost
+  }) {
+    super({ appConfig, runtimeOrigin, serveOptions, options });
+    this.apiHandlers = apiHandlers || [];
+    this.staticRoutes = staticRoutes || [];
+    this.errorHandler = errorHandler;
+    this.bridge = bridge;
+    this.hmrManager = hmrManager;
+    this.previewHost = previewHost;
+  }
+  /**
+   * Returns whether adapter-level HTML responses still need HMR runtime injection.
+   *
+   * @remarks
+   * Filesystem-routed pages are wrapped later in the shared route layer. This
+   * adapter-level check exists for explicit API handlers that return HTML and
+   * would otherwise bypass the route wrapper entirely.
+   */
+  shouldInjectHmrScript() {
+    return shouldInjectHmrHtmlResponse(this.options?.watch === true, this.hmrManager);
+  }
+  /**
+   * Delegates the HTML-response test to the shared response helper used by both
+   * adapters.
+   */
+  isHtmlResponse(response) {
+    return isHtmlResponse(response);
+  }
+  /**
+   * Injects HMR script into HTML responses in development mode.
+   * Ensures explicit API handlers that return HTML get auto-reload capability.
+   */
+  async maybeInjectHmrScript(response) {
+    if (this.shouldInjectHmrScript() && this.isHtmlResponse(response)) {
+      return injectHmrRuntimeIntoHtmlResponse(response);
+    }
+    return response;
+  }
+  /**
+   * Initializes the server adapter's core runtime components.
+   */
+  async initialize() {
+    installAppRuntimeBuildExecutor(this.appConfig);
+    this.staticSiteGenerator = new StaticSiteGenerator({ appConfig: this.appConfig });
+    await this.hmrManager.buildRuntime();
+    this.prepareRuntimePublicDir();
+    const staticBuilderOptions = {
+      appConfig: this.appConfig,
+      staticSiteGenerator: this.staticSiteGenerator,
+      serveOptions: this.serveOptions,
+      apiHandlers: this.apiHandlers
+    };
+    this.staticBuilder = new ServerStaticBuilder(staticBuilderOptions);
+    await this.initializeRuntimePlugins({ watch: this.options?.watch });
+  }
+  /**
+   * Copies the source `public` directory into the runtime output and ensures the
+   * HMR assets directory exists before any runtime bundles are emitted.
+   */
+  prepareRuntimePublicDir() {
+    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));
+  }
+  /**
+   * Registers runtime plugins and propagates the final HMR manager into each
+   * integration.
+   *
+   * @remarks
+   * This is where Bun's runtime-plugin registration path meets the integration
+   * lifecycle. A failure here leaves the runtime partially bootstrapped, so the
+   * method logs the underlying error and rethrows instead of trying to limp on.
+   */
+  async initializeRuntimePlugins(options) {
+    try {
+      this.hmrManager.setEnabled(Boolean(options?.watch));
+      await setupAppRuntimePlugins({
+        appConfig: this.appConfig,
+        runtimeOrigin: this.runtimeOrigin,
+        hmrManager: this.hmrManager,
+        onRuntimePlugin: (plugin) => {
+          Bun.plugin(plugin);
+        }
+      });
+      const browserBuildPlugins = getAppBrowserBuildPlugins(this.appConfig);
+      this.hmrManager.setPlugins(browserBuildPlugins);
+      for (const integration of this.appConfig.integrations) {
+        integration.setHmrManager(this.hmrManager);
+      }
+    } catch (error) {
+      appLogger.error(`Failed to initialize plugins: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  /**
+   * Rebuilds the shared routing state and hot-reloads the live Bun server when a
+   * watched route file changes.
+   */
+  async refreshRouterRoutes() {
+    if (!this.serverInstance || typeof this.serverInstance.reload !== "function") {
+      appLogger.error("Server instance is not available for reloading");
+      return;
+    }
+    await this.createSharedWatchRefreshCallback({
+      staticRoutes: this.staticRoutes,
+      hmrManager: this.hmrManager,
+      onRoutesReady: () => {
+        const options = this.getServerOptions({ enableHmr: true });
+        this.serverInstance.reload(options);
+        appLogger.debug("Server routes updated with dynamic routes");
+      },
+      onError: (error) => {
+        this.hmrManager.broadcast({ type: "error", message: error.message });
+        appLogger.error("Failed to refresh router routes:", error);
+      }
+    })();
+  }
+  async watch() {
+    const watcher = new ProjectWatcher({
+      config: this.appConfig,
+      refreshRouterRoutesCallback: this.refreshRouterRoutes.bind(this),
+      hmrManager: this.hmrManager,
+      bridge: this.bridge
+    });
+    await watcher.createWatcherSubscription();
+  }
+  /**
+   * Builds the `Bun.serve()` options for the current adapter state.
+   *
+   * @remarks
+   * The HMR-enabled variant wraps the base fetch handler so one Bun server can
+   * serve normal requests, accept HMR websocket upgrades, and expose the HMR
+   * runtime asset without splitting responsibility across separate listeners.
+   */
+  getServerOptions({ enableHmr = false } = {}) {
+    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.development = true;
+      serverOptions.websocket = hmrHandler;
+      serverOptions.fetch = async function(request, _server) {
+        const url = new URL(request.url);
+        appLogger.debug(`[HMR] Request: ${url.pathname}`);
+        if (url.pathname === "/_hmr") {
+          const success = this.upgrade(request, {
+            data: void 0
+          });
+          if (success) return;
+          return new Response("WebSocket upgrade failed", { status: 400 });
+        }
+        if (url.pathname === "/_hmr_runtime.js") {
+          appLogger.debug(`[HMR] Serving runtime from ${hmrManager.getRuntimePath()}`);
+          return new Response(fileSystem.readFileAsBuffer(hmrManager.getRuntimePath()), {
+            headers: { "Content-Type": "application/javascript" }
+          });
+        }
+        let 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;
+  }
+  /**
+   * 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.
+   */
+  async retrieveBodyFromRequest(request) {
+    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 void 0;
+  }
+  /**
+   * Composes the base Bun server settings that all runtime modes build from.
+   *
+   * @remarks
+   * This method centralizes the Bun-specific error boundary. It preserves the
+   * shared route pipeline while still allowing adapter-level custom error-handler
+   * execution and `HttpError` passthrough.
+   */
+  buildServerSettings() {
+    const serverOptions = { ...this.serveOptions };
+    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 = {
+      ...serverOptions,
+      async fetch(request, _server) {
+        try {
+          await waitForInit();
+          return await handleReq(request);
+        } catch (error) {
+          if (error instanceof Response) return error;
+          if (errorHandler) {
+            try {
+              const locals = {};
+              const context = {
+                request,
+                params: {},
+                response: new ApiResponseBuilder(),
+                server: _server,
+                locals,
+                require: createRequire(() => 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(error) {
+        appLogger.error(`[ecopages] Error handling request: ${error}`);
+        return handleNoMatch(new Request("http://localhost"));
+      }
+    };
+    return finalOptions;
+  }
+  /**
+   * Generates a static build of the site for deployment.
+   * @param options.preview - If true, starts a preview server after build
+   */
+  async buildStatic(options) {
+    if (!this.fullyInitialized) {
+      await this.initializeSharedRouteHandling({
+        staticRoutes: this.staticRoutes,
+        hmrManager: this.hmrManager
+      });
+    }
+    const buildRuntimeOrigin = this.serverInstance ? `http://${this.serverInstance.hostname || DEFAULT_ECOPAGES_HOSTNAME}:${this.serverInstance.port || DEFAULT_ECOPAGES_PORT}` : void 0;
+    await this.staticBuilder.build(
+      { ...options, preview: false, baseUrl: buildRuntimeOrigin },
+      {
+        router: this.router,
+        routeRendererFactory: this.routeRendererFactory,
+        staticRoutes: this.staticRoutes
+      }
+    );
+    if (!options?.preview) {
+      return;
+    }
+    const previewHostname = this.serveOptions.hostname || DEFAULT_ECOPAGES_HOSTNAME;
+    const previewPort = Number(this.serveOptions.port || DEFAULT_ECOPAGES_PORT);
+    const activePreviewPort = await this.previewHost.start({
+      appConfig: this.appConfig,
+      hostname: String(previewHostname),
+      port: previewPort
+    });
+    if (activePreviewPort) {
+      appLogger.info(`Preview running at http://${previewHostname}:${activePreviewPort}`);
+      return;
+    }
+  }
+  /**
+   * Initializes the server with dynamic routes after server creation.
+   * Must be called before handling any requests.
+   * @param server - The Bun server instance
+   */
+  async completeInitialization(server) {
+    if (this.fullyInitialized) {
+      if (server && !this.serverInstance) {
+        this.serverInstance = server;
+      }
+      return;
+    }
+    if (!this.initializationPromise) {
+      this.initializationPromise = this._performInitialization(server ?? null);
+    }
+    return this.initializationPromise;
+  }
+  /**
+   * Performs the one-time post-bind initialization path for Bun servers.
+   *
+   * @remarks
+   * This is intentionally split from `initialize()` because shared route handling
+   * and file watching need the live server instance to exist before Bun can
+   * reload updated route handlers in place.
+   */
+  async _performInitialization(server) {
+    this.serverInstance = server;
+    appLogger.debug("Completing server initialization with dynamic routes");
+    await this.initializeSharedRouteHandling({
+      staticRoutes: this.staticRoutes,
+      hmrManager: 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 } : void 0);
+      server.reload(updatedOptions);
+      appLogger.debug("Server routes updated with dynamic routes");
+    }
+  }
+  /**
+   * Creates and initializes the Bun server adapter.
+   * @returns Configured adapter with server methods
+   */
+  async createAdapter() {
+    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.
+   *
+   * @remarks
+   * Filesystem page responses are wrapped by `ServerRouteHandler`. This
+   * adapter-level pass only covers HTML returned by explicit API handlers,
+   * which bypass that route-layer wrapper and would otherwise miss the
+   * dev HMR runtime — so the HMR script injection happens here, after
+   * the shared handler runs.
+   */
+  async handleRequest(request) {
+    const response = await this.handleSharedRequest(request, {
+      apiHandlers: this.apiHandlers,
+      errorHandler: this.errorHandler,
+      serverInstance: this.serverInstance,
+      hmrManager: this.hmrManager
+    });
+    return await this.maybeInjectHmrScript(response);
+  }
+  /**
+   * Ensures server initialization completes before request handling.
+   * Prevents race conditions during startup.
+   */
+  async waitForInitialization() {
+    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.
+   */
+  async handleResponse(request) {
+    await this.waitForInitialization();
+    return this.routeHandler.handleResponse(request);
+  }
+  /**
+   * Handles requests that do not match any routes.
+   */
+  async handleNoMatch(request) {
+    await this.waitForInitialization();
+    return this.routeHandler.handleNoMatch(request);
+  }
+}
+async function createBunServerAdapter(params) {
+  const runtimeOrigin = params.runtimeOrigin ?? resolveServeRuntimeOrigin(params.serveOptions);
+  const bridge = params.bridge ?? new ClientBridge();
+  const hmrManager = params.hmrManager ?? new HmrManager({ appConfig: params.appConfig, bridge });
+  const previewHost = params.previewHost ?? new BunStaticPreviewHost();
+  const adapter = new BunServerAdapter({
+    ...params,
+    runtimeOrigin,
+    bridge,
+    hmrManager,
+    previewHost
+  });
+  return adapter.createAdapter();
+}
+export {
+  BunServerAdapter,
+  createBunServerAdapter
+};

package/src/adapters/bun/static-preview-host.d.ts

@@ -0,0 +1,28 @@
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import type { StaticPreviewHost, StaticPreviewHostStartOptions } from '../shared/static-preview-host.js';
+type BunStaticPreviewServer = {
+    server: {
+        port?: number;
+    } | null;
+    stop(): void;
+};
+type BunStaticPreviewServerFactory = {
+    createServer(args: {
+        appConfig: EcoPagesAppConfig;
+        options: {
+            port: number;
+        };
+    }): BunStaticPreviewServer;
+};
+type BunStaticPreviewLogger = {
+    error(message: string): unknown;
+};
+export declare class BunStaticPreviewHost implements StaticPreviewHost {
+    private readonly previewServerFactory;
+    private readonly logger;
+    private previewServer;
+    constructor(previewServerFactory?: BunStaticPreviewServerFactory, logger?: BunStaticPreviewLogger);
+    start(options: StaticPreviewHostStartOptions): Promise<number | null>;
+    stop(): Promise<void>;
+}
+export {};

package/src/adapters/bun/static-preview-host.js

@@ -0,0 +1,45 @@
+import { StaticContentServer } from "../../dev/sc-server.js";
+import { appLogger } from "../../global/app-logger.js";
+class BunStaticPreviewHost {
+  constructor(previewServerFactory = StaticContentServer, logger = appLogger) {
+    this.previewServerFactory = previewServerFactory;
+    this.logger = logger;
+  }
+  previewServerFactory;
+  logger;
+  previewServer = null;
+  async start(options) {
+    await this.stop();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+      try {
+        this.previewServer = this.previewServerFactory.createServer({
+          appConfig: options.appConfig,
+          options: { port: options.port }
+        });
+        const previewPort = this.previewServer.server?.port;
+        if (previewPort) {
+          return previewPort;
+        }
+        break;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorCode = typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+        const isPortReleaseRace = errorCode === "EADDRINUSE" || errorMessage.includes("EADDRINUSE");
+        if (!isPortReleaseRace || attempt === 19) {
+          throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    }
+    this.logger.error("Failed to start preview server");
+    return null;
+  }
+  async stop() {
+    this.previewServer?.stop();
+    this.previewServer = null;
+  }
+}
+export {
+  BunStaticPreviewHost
+};

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

@@ -0,0 +1,20 @@
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
+import { AbstractApplicationAdapter } from './abstract/application-adapter.js';
+import type { ApplicationAdapterOptions } from './abstract/application-adapter.js';
+import { SharedApplicationAdapter } from './shared/application-adapter.js';
+export interface EcopagesAppOptions extends ApplicationAdapterOptions {
+    appConfig: EcoPagesAppConfig;
+    serverOptions?: Record<string, any>;
+}
+export type UniversalEcopagesApp = AbstractApplicationAdapter<EcopagesAppOptions, unknown, Request>;
+export declare function createApp<WebSocketData = undefined>(options: EcopagesAppOptions): Promise<UniversalEcopagesApp>;
+export declare class EcopagesApp extends SharedApplicationAdapter<EcopagesAppOptions, unknown, Request> {
+    private readonly appOptions;
+    private runtimeApp;
+    private runtimeAppPromise;
+    constructor(options: EcopagesAppOptions);
+    private getRuntimeApp;
+    protected initializeServerAdapter(): Promise<UniversalEcopagesApp>;
+    start(): Promise<unknown>;
+    fetch(request: Request): Promise<Response>;
+}

package/src/adapters/create-app.js

@@ -0,0 +1,66 @@
+import { AbstractApplicationAdapter } from "./abstract/application-adapter.js";
+import { SharedApplicationAdapter } from "./shared/application-adapter.js";
+import { createApp as createBunApp } from "./bun/create-app.js";
+import { createNodeApp } from "./node/create-app.js";
+async function createRuntimeApp(options) {
+  const bun = globalThis.Bun;
+  if (bun) {
+    return await createBunApp(options);
+  }
+  return await createNodeApp(options);
+}
+async function createApp(options) {
+  return createRuntimeApp(options);
+}
+class EcopagesApp extends SharedApplicationAdapter {
+  appOptions;
+  runtimeApp = null;
+  runtimeAppPromise = null;
+  constructor(options) {
+    super(options);
+    this.appOptions = options;
+  }
+  async getRuntimeApp() {
+    if (this.runtimeApp) {
+      return this.runtimeApp;
+    }
+    if (!this.runtimeAppPromise) {
+      this.runtimeAppPromise = createRuntimeApp({
+        ...this.appOptions,
+        clearOutput: false
+      }).then((app) => {
+        for (const handler of this.apiHandlers) {
+          app.add(handler);
+        }
+        for (const route of this.staticRoutes) {
+          app.static(route.path, route.loader);
+        }
+        if (this.errorHandler) {
+          app.onError(this.errorHandler);
+        }
+        this.runtimeApp = app;
+        return app;
+      });
+    }
+    return this.runtimeAppPromise;
+  }
+  async initializeServerAdapter() {
+    return this.getRuntimeApp();
+  }
+  async start() {
+    const runtimeApp = await this.getRuntimeApp();
+    return runtimeApp.start();
+  }
+  async fetch(request) {
+    const runtimeApp = await this.getRuntimeApp();
+    const candidate = runtimeApp;
+    if (!candidate.fetch) {
+      throw new Error("The selected runtime adapter does not expose fetch()");
+    }
+    return candidate.fetch(request);
+  }
+}
+export {
+  EcopagesApp,
+  createApp
+};

package/src/adapters/index.d.ts

@@ -0,0 +1,2 @@
+export { EcopagesApp, createApp } from './create-app.js';
+export { defineApiHandler, defineGroupHandler, type GroupHandler } from './shared/define-api-handler.js';

package/src/adapters/index.js

@@ -0,0 +1,8 @@
+import { EcopagesApp, createApp } from "./create-app.js";
+import { defineApiHandler, defineGroupHandler } from "./shared/define-api-handler.js";
+export {
+  EcopagesApp,
+  createApp,
+  defineApiHandler,
+  defineGroupHandler
+};

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

@@ -0,0 +1,24 @@
+import { SharedApplicationAdapter } from '../shared/application-adapter.js';
+import type { RuntimeHost } from '../shared/runtime-host.js';
+import type { EcopagesAppOptions } from '../create-app.js';
+import { type NodeServerAdapterResult, createNodeServerAdapter } from './server-adapter.js';
+import type { NodeServerInstance } from './server-adapter.js';
+export declare class NodeEcopagesApp extends SharedApplicationAdapter<EcopagesAppOptions, NodeServerInstance, Request> {
+    serverAdapter: NodeServerAdapterResult | undefined;
+    private server;
+    private runtimeOrigin;
+    private readonly runtimeHost;
+    constructor(options: EcopagesAppOptions, dependencies: {
+        runtimeHost: RuntimeHost<NodeServerInstance, {
+            port?: number;
+            hostname?: string;
+        }>;
+    });
+    protected createServerAdapter(params: Parameters<typeof createNodeServerAdapter>[0]): Promise<NodeServerAdapterResult>;
+    stop(force?: boolean): Promise<void>;
+    protected initializeServerAdapter(): Promise<NodeServerAdapterResult>;
+    start(): Promise<NodeServerInstance | void>;
+    fetch(request: Request): Promise<Response>;
+}
+export declare function createNodeApp(options: EcopagesAppOptions): Promise<NodeEcopagesApp>;
+export declare function createApp(options: EcopagesAppOptions): Promise<NodeEcopagesApp>;