@ecopages/core 0.2.0-alpha.6 → 0.2.0-alpha.8

package/src/config/config-builder.js

@@ -0,0 +1,565 @@
+import path from "node:path";
+import {
+  DEFAULT_ECOPAGES_DIST_DIR,
+  DEFAULT_ECOPAGES_HOSTNAME,
+  DEFAULT_ECOPAGES_PORT,
+  DEFAULT_ECOPAGES_WORK_DIR
+} from "../constants.js";
+import {
+  collectConfiguredAppBuildManifestContributions,
+  createBuildAdapter,
+  getAppServerBuildPlugins,
+  setAppBuildAdapter,
+  setAppBuildExecutor,
+  updateAppBuildManifest
+} from "../build/build-adapter.js";
+import { createAppBuildExecutor } from "../build/dev-build-coordinator.js";
+import { GHTML_PLUGIN_NAME, ghtmlPlugin } from "../integrations/ghtml/ghtml.plugin.js";
+import { createEcoComponentMetaPlugin } from "../plugins/eco-component-meta-plugin.js";
+import {
+  NoopEntrypointDependencyGraph,
+  setAppEntrypointDependencyGraph
+} from "../services/runtime-state/entrypoint-dependency-graph.service.js";
+import {
+  createNodeRuntimeManifest,
+  setAppNodeRuntimeManifest
+} from "../services/runtime-manifest/node-runtime-manifest.service.js";
+import {
+  InMemoryRuntimeSpecifierRegistry,
+  setAppRuntimeSpecifierRegistry
+} from "../services/runtime-state/runtime-specifier-registry.service.js";
+import {
+  CounterServerInvalidationState,
+  setAppServerInvalidationState
+} from "../services/runtime-state/server-invalidation-state.service.js";
+import { invariant } from "../utils/invariant.js";
+import { appLogger } from "../global/app-logger.js";
+import { fileSystem } from "@ecopages/file-system";
+const CONFIG_BUILDER_ERRORS = {
+  DUPLICATE_INTEGRATION_NAMES: "Integrations names must be unique",
+  DUPLICATE_INTEGRATION_EXTENSIONS: "Integrations extensions must be unique",
+  MIXED_JSX_ENGINES: "Both kitajs and react integrations are enabled. Use per-file JSX import source/pragma consistently (e.g. `/** @jsxImportSource react */` for React files and `/** @jsxImportSource @kitajs/html */` for Kita files).",
+  duplicateProcessorName: (name) => `Processor with name "${name}" already exists`,
+  duplicateLoaderName: (name) => `Loader with name "${name}" already exists`,
+  duplicateSemanticTemplate: (kind, matches) => `Multiple ${kind} templates found: ${matches.join(", ")}`,
+  incompatibleRuntimeCapability: (kind, name, runtime, reason) => `Cannot enable ${kind} "${name}" on ${runtime}: ${reason}`,
+  unsupportedRuntimeVersion: (kind, name, runtime, current, min) => `Cannot enable ${kind} "${name}" on ${runtime} ${current}: requires runtime version ${min} or newer`,
+  invalidRuntimeVersion: (kind, name, version) => `Cannot validate ${kind} "${name}" runtimeCapability.minRuntimeVersion "${version}" because it is not a dot-separated numeric version`
+};
+class ConfigBuilder {
+  config = {
+    baseUrl: "",
+    rootDir: ".",
+    srcDir: "src",
+    pagesDir: "pages",
+    includesDir: "includes",
+    componentsDir: "components",
+    layoutsDir: "layouts",
+    publicDir: "public",
+    robotsTxt: {
+      preferences: {
+        "*": []
+      }
+    },
+    integrations: [],
+    integrationsDependencies: [],
+    distDir: DEFAULT_ECOPAGES_DIST_DIR,
+    defaultMetadata: {
+      title: "Ecopages",
+      description: "This is a static site generated with Ecopages"
+    },
+    additionalWatchPaths: [],
+    templatesExt: [],
+    absolutePaths: {
+      config: "",
+      componentsDir: "",
+      distDir: "",
+      workDir: "",
+      includesDir: "",
+      layoutsDir: "",
+      pagesDir: "",
+      projectDir: "",
+      publicDir: "",
+      srcDir: "",
+      htmlTemplatePath: "",
+      error404TemplatePath: ""
+    },
+    processors: /* @__PURE__ */ new Map(),
+    loaders: /* @__PURE__ */ new Map(),
+    workDir: DEFAULT_ECOPAGES_WORK_DIR
+  };
+  /**
+   * Sets the base URL for the application.
+   * This URL is used as the root URL for all pages and assets.
+   *
+   * @param baseUrl - The base URL for the application (e.g., 'https://example.com')
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setBaseUrl(baseUrl) {
+    this.config.baseUrl = baseUrl;
+    return this;
+  }
+  /**
+   * Sets the root directory of the project.
+   * This is the base directory from which all other paths are resolved.
+   *
+   * @param rootDir - The root directory path
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setRootDir(rootDir) {
+    this.config.rootDir = rootDir;
+    return this;
+  }
+  /**
+   * Sets the source directory relative to the root directory.
+   * This directory contains all the source files for the application.
+   *
+   * @param srcDir - The source directory name (default: 'src')
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setSrcDir(srcDir) {
+    this.config.srcDir = srcDir;
+    return this;
+  }
+  /**
+   * Sets the pages directory relative to the source directory.
+   * This directory contains all the page files for the application.
+   *
+   * @param pagesDir - The pages directory name (default: 'pages')
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setPagesDir(pagesDir) {
+    this.config.pagesDir = pagesDir;
+    return this;
+  }
+  /**
+   * Sets the includes directory relative to the source directory.
+   * This directory contains template includes and partials.
+   *
+   * @param includesDir - The includes directory name (default: 'includes')
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setIncludesDir(includesDir) {
+    this.config.includesDir = includesDir;
+    return this;
+  }
+  /**
+   * Sets the components directory relative to the source directory.
+   * This directory contains reusable components.
+   *
+   * @param componentsDir - The components directory name (default: 'components')
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setComponentsDir(componentsDir) {
+    this.config.componentsDir = componentsDir;
+    return this;
+  }
+  /**
+   * Sets the layouts directory relative to the source directory.
+   * This directory contains layout templates.
+   *
+   * @param layoutsDir - The layouts directory name (default: 'layouts')
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setLayoutsDir(layoutsDir) {
+    this.config.layoutsDir = layoutsDir;
+    return this;
+  }
+  /**
+   * Sets the public directory relative to the source directory.
+   * This directory contains static assets that should be served as-is.
+   *
+   * @param publicDir - The public directory name (default: 'public')
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setPublicDir(publicDir) {
+    this.config.publicDir = publicDir;
+    return this;
+  }
+  /**
+   * Sets the robots.txt configuration.
+   * This determines which paths are allowed/disallowed for search engines.
+   *
+   * @param robotsTxt - The robots.txt configuration object
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setRobotsTxt(robotsTxt) {
+    this.config.robotsTxt = robotsTxt;
+    return this;
+  }
+  /**
+   * Sets the integration plugins to use.
+   * These plugins provide additional functionality to the application.
+   *
+   * @param integrations - An array of integration plugins
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setIntegrations(integrations) {
+    this.config.integrations = integrations;
+    return this;
+  }
+  /**
+   * Sets the output directory for the built application.
+   *
+   * @param distDir - The distribution directory name (default: 'dist')
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setDistDir(distDir) {
+    this.config.distDir = distDir;
+    return this;
+  }
+  /**
+   * Sets the internal work directory for runtime-only artifacts.
+   *
+   * @remarks
+   * Use this when deployable output should stay clean while Ecopages still
+   * needs a separate workspace for server transpilation caches, runtime
+   * manifests, and other internal build products.
+   *
+   * @param workDir - The internal work directory name
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setWorkDir(workDir) {
+    this.config.workDir = workDir;
+    return this;
+  }
+  /**
+   * Sets the default metadata for pages.
+   * This is used when a page doesn't specify its own metadata.
+   *
+   * @param defaultMetadata - The default metadata object
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setDefaultMetadata(defaultMetadata) {
+    this.config.defaultMetadata = {
+      ...this.config.defaultMetadata,
+      ...defaultMetadata
+    };
+    return this;
+  }
+  /**
+   * Sets additional paths to watch for changes during development.
+   *
+   * @param additionalWatchPaths - An array of additional paths to watch
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setAdditionalWatchPaths(additionalWatchPaths) {
+    this.config.additionalWatchPaths = additionalWatchPaths;
+    return this;
+  }
+  /**
+   * Sets the processors to use for the application.
+   * This replaces any existing processors.
+   *
+   * @param processors - An array of processors
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setProcessors(processors) {
+    this.config.processors.clear();
+    for (const processor of processors) {
+      this.addProcessor(processor);
+    }
+    return this;
+  }
+  /**
+   * Adds a processor to the application.
+   *
+   * @param processor - The processor to add
+   * @returns The ConfigBuilder instance for method chaining
+   * @throws Error if a processor with the same name already exists
+   */
+  addProcessor(processor) {
+    if (this.config.processors.has(processor.name)) {
+      throw new Error(CONFIG_BUILDER_ERRORS.duplicateProcessorName(processor.name));
+    }
+    this.config.processors.set(processor.name, processor);
+    return this;
+  }
+  /**
+   * Sets the loaders to use for the application.
+   * This replaces any existing loaders.
+   *
+   * @param loaders - An array of build plugins to use as loaders
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setLoaders(loaders) {
+    this.config.loaders.clear();
+    for (const loader of loaders) {
+      this.addLoader(loader.name, loader);
+    }
+    return this;
+  }
+  /**
+   * Adds a loader to the application.
+   *
+   * @param name - The name of the loader
+   * @param loader - The build plugin to use as a loader
+   * @returns The ConfigBuilder instance for method chaining
+   * @throws Error if a loader with the same name already exists
+   */
+  addLoader(name, loader) {
+    if (this.config.loaders.has(name)) {
+      throw new Error(CONFIG_BUILDER_ERRORS.duplicateLoaderName(name));
+    }
+    this.config.loaders.set(name, loader);
+    return this;
+  }
+  /**
+   * Sets the cache configuration for ISR and page caching.
+   *
+   * @param cacheConfig - The cache configuration object
+   * @returns The ConfigBuilder instance for method chaining
+   */
+  setCacheConfig(cacheConfig) {
+    this.config.cache = cacheConfig;
+    return this;
+  }
+  setExperimental(experimental) {
+    this.config.experimental = experimental;
+    return this;
+  }
+  createAbsolutePaths(config) {
+    const { srcDir, componentsDir, includesDir, layoutsDir, pagesDir, publicDir, distDir, workDir } = config;
+    const projectDir = config.rootDir;
+    const absoluteSrcDir = path.resolve(projectDir, srcDir);
+    const absoluteDistDir = path.resolve(projectDir, distDir);
+    const absoluteWorkDir = path.resolve(projectDir, workDir);
+    const absoluteIncludesDir = path.join(absoluteSrcDir, includesDir);
+    const absolutePagesDir = path.join(absoluteSrcDir, pagesDir);
+    this.config.absolutePaths = {
+      config: path.join(projectDir, "eco.config.ts"),
+      projectDir,
+      srcDir: absoluteSrcDir,
+      distDir: absoluteDistDir,
+      workDir: absoluteWorkDir,
+      componentsDir: path.join(absoluteSrcDir, componentsDir),
+      includesDir: absoluteIncludesDir,
+      layoutsDir: path.join(absoluteSrcDir, layoutsDir),
+      pagesDir: absolutePagesDir,
+      publicDir: path.join(absoluteSrcDir, publicDir),
+      htmlTemplatePath: this.resolveSemanticTemplatePath({
+        dirPath: absoluteIncludesDir,
+        basename: "html"
+      }),
+      error404TemplatePath: this.resolveSemanticTemplatePath({
+        dirPath: absolutePagesDir,
+        basename: "404"
+      })
+    };
+    return this;
+  }
+  resolveSemanticTemplatePath({ dirPath, basename }) {
+    const extensions = this.config.templatesExt.length > 0 ? this.config.templatesExt : [".ghtml.ts"];
+    const matches = extensions.map((extension) => path.join(dirPath, `${basename}${extension}`)).filter((candidate) => fileSystem.exists(candidate));
+    invariant(matches.length <= 1, CONFIG_BUILDER_ERRORS.duplicateSemanticTemplate(basename, matches));
+    if (matches.length === 1) {
+      return matches[0];
+    }
+    return path.join(dirPath, `${basename}${extensions[0]}`);
+  }
+  createIntegrationTemplatesExt(integrations) {
+    const integrationName = integrations.map((integration) => integration.name);
+    const uniqueName = new Set(integrationName);
+    invariant(integrationName.length === uniqueName.size, CONFIG_BUILDER_ERRORS.DUPLICATE_INTEGRATION_NAMES);
+    const hasKitaJs = uniqueName.has("kitajs");
+    const hasReact = uniqueName.has("react");
+    if (hasKitaJs && hasReact) {
+      appLogger.warn(CONFIG_BUILDER_ERRORS.MIXED_JSX_ENGINES);
+    }
+    const integrationsExtensions = integrations.flatMap((integration) => integration.extensions);
+    const uniqueExtensions = new Set(integrationsExtensions);
+    invariant(
+      integrationsExtensions.length === uniqueExtensions.size,
+      CONFIG_BUILDER_ERRORS.DUPLICATE_INTEGRATION_EXTENSIONS
+    );
+    this.config.templatesExt = integrationsExtensions;
+  }
+  initializeProcessors() {
+    for (const processor of this.config.processors.values()) {
+      processor.setContext(this.config);
+    }
+  }
+  validateRuntimeCapabilities() {
+    const runtimeEnvironment = this.detectRuntimeEnvironment();
+    const contributors = [
+      ...this.config.integrations.map((integration) => ({
+        kind: "integration",
+        name: integration.name,
+        runtimeCapability: integration.runtimeCapability
+      })),
+      ...Array.from(this.config.processors.values(), (processor) => ({
+        kind: "processor",
+        name: processor.name,
+        runtimeCapability: processor.runtimeCapability
+      }))
+    ];
+    for (const contributor of contributors) {
+      this.validateRuntimeCapability(contributor, runtimeEnvironment);
+    }
+  }
+  validateRuntimeCapability(contributor, environment) {
+    const declaration = contributor.runtimeCapability;
+    if (!declaration) {
+      return;
+    }
+    for (const tag of declaration.tags) {
+      if (environment.supportedTags.has(tag)) {
+        continue;
+      }
+      throw new Error(
+        CONFIG_BUILDER_ERRORS.incompatibleRuntimeCapability(
+          contributor.kind,
+          contributor.name,
+          environment.runtime,
+          this.describeUnsupportedRuntimeTag(tag)
+        )
+      );
+    }
+    if (!declaration.minRuntimeVersion) {
+      return;
+    }
+    const minVersion = this.parseVersion(declaration.minRuntimeVersion);
+    if (!minVersion) {
+      throw new Error(
+        CONFIG_BUILDER_ERRORS.invalidRuntimeVersion(
+          contributor.kind,
+          contributor.name,
+          declaration.minRuntimeVersion
+        )
+      );
+    }
+    const currentVersion = this.parseVersion(environment.version);
+    if (!currentVersion) {
+      return;
+    }
+    if (this.compareVersions(currentVersion, minVersion) >= 0) {
+      return;
+    }
+    throw new Error(
+      CONFIG_BUILDER_ERRORS.unsupportedRuntimeVersion(
+        contributor.kind,
+        contributor.name,
+        environment.runtime,
+        environment.version,
+        declaration.minRuntimeVersion
+      )
+    );
+  }
+  detectRuntimeEnvironment() {
+    const bunVersion = this.getBunVersion();
+    if (bunVersion) {
+      return {
+        runtime: "bun",
+        version: bunVersion,
+        supportedTags: /* @__PURE__ */ new Set([
+          "bun-only",
+          "node-compatible",
+          "requires-native-bun-api",
+          "requires-node-builtins"
+        ])
+      };
+    }
+    return {
+      runtime: "node",
+      version: process.versions.node,
+      supportedTags: /* @__PURE__ */ new Set(["node-compatible", "requires-node-builtins"])
+    };
+  }
+  getBunVersion() {
+    const bun = globalThis;
+    return typeof bun.Bun?.version === "string" ? bun.Bun.version : void 0;
+  }
+  describeUnsupportedRuntimeTag(tag) {
+    switch (tag) {
+      case "bun-only":
+        return "it is Bun-only";
+      case "requires-native-bun-api":
+        return "it requires the native Bun API";
+      case "requires-node-builtins":
+        return "it requires Node builtins";
+      case "node-compatible":
+        return "it requires a Node-compatible runtime";
+    }
+  }
+  parseVersion(version) {
+    const normalized = version.trim().replace(/^v/i, "");
+    if (!/^\d+(?:\.\d+)*$/.test(normalized)) {
+      return void 0;
+    }
+    return normalized.split(".").map((segment) => Number(segment));
+  }
+  compareVersions(left, right) {
+    const maxLength = Math.max(left.length, right.length);
+    for (let index = 0; index < maxLength; index += 1) {
+      const leftValue = left[index] ?? 0;
+      const rightValue = right[index] ?? 0;
+      if (leftValue > rightValue) {
+        return 1;
+      }
+      if (leftValue < rightValue) {
+        return -1;
+      }
+    }
+    return 0;
+  }
+  /**
+   * Initializes default loaders that are required for EcoPages to function.
+   * This includes the eco-component-meta-plugin which auto-injects __eco metadata into component configs.
+   */
+  async initializeDefaultLoaders() {
+    const componentMetaPlugin = createEcoComponentMetaPlugin({ config: this.config });
+    if (!this.config.loaders.has(componentMetaPlugin.name)) {
+      this.config.loaders.set(componentMetaPlugin.name, componentMetaPlugin);
+    }
+  }
+  reviewBaseUrl(baseUrl) {
+    if (baseUrl) {
+      this.config.baseUrl = baseUrl;
+      return;
+    }
+    const envBaseUrl = process.env.ECOPAGES_BASE_URL;
+    if (envBaseUrl) {
+      this.config.baseUrl = envBaseUrl;
+    } else if (!this.config.baseUrl) {
+      this.config.baseUrl = `http://${DEFAULT_ECOPAGES_HOSTNAME}:${DEFAULT_ECOPAGES_PORT}`;
+    }
+  }
+  /**
+   * Builds and returns the final configuration object.
+   * This performs validation and initialization of the configuration.
+   *
+   * @returns A promise that resolves to the final EcoPagesAppConfig
+   * @throws Error if required configuration is missing (e.g., baseUrl)
+   */
+  async build() {
+    this.reviewBaseUrl(this.config.baseUrl);
+    if (!this.config.integrations.some((integration) => integration.name === GHTML_PLUGIN_NAME)) {
+      this.config.integrations.push(ghtmlPlugin());
+    }
+    this.createIntegrationTemplatesExt(this.config.integrations);
+    this.createAbsolutePaths(this.config);
+    await this.initializeDefaultLoaders();
+    this.initializeProcessors();
+    this.validateRuntimeCapabilities();
+    const buildAdapter = createBuildAdapter();
+    setAppBuildAdapter(this.config, buildAdapter);
+    updateAppBuildManifest(this.config, await collectConfiguredAppBuildManifestContributions(this.config));
+    setAppServerInvalidationState(this.config, new CounterServerInvalidationState());
+    setAppEntrypointDependencyGraph(this.config, new NoopEntrypointDependencyGraph());
+    setAppRuntimeSpecifierRegistry(this.config, new InMemoryRuntimeSpecifierRegistry());
+    setAppBuildExecutor(
+      this.config,
+      createAppBuildExecutor({
+        development: false,
+        adapter: buildAdapter,
+        getPlugins: () => getAppServerBuildPlugins(this.config)
+      })
+    );
+    setAppNodeRuntimeManifest(this.config, createNodeRuntimeManifest(this.config));
+    return this.config;
+  }
+}
+export {
+  CONFIG_BUILDER_ERRORS,
+  ConfigBuilder
+};

package/src/constants.d.ts

@@ -0,0 +1,45 @@
+/**
+ * This file contains constants used throughout the project.
+ * @module constants
+ **/
+/**
+ * Collection of status messages used in the application.
+ */
+export declare const STATUS_MESSAGE: {
+    404: string;
+};
+/**
+ *Variables used to determine if the app is running on Bun
+ */
+export declare const IS_BUN: boolean;
+/**
+ * Directory used for storing assets.
+ */
+export declare const RESOLVED_ASSETS_DIR = "assets";
+/**
+ * Directory used for storing vendor assets.
+ * This is a subdirectory of the assets directory.
+ */
+export declare const RESOLVED_ASSETS_VENDORS_DIR: string;
+/**
+ * Base paths for generated project files.
+ */
+export declare const GENERATED_BASE_PATHS: {
+    readonly types: "node_modules/@types";
+    readonly cache: "cache";
+};
+export declare const DEFAULT_ECOPAGES_PORT = 3000;
+export declare const DEFAULT_ECOPAGES_HOSTNAME = "localhost";
+/**
+ * Default directory used for deployable output.
+ */
+export declare const DEFAULT_ECOPAGES_DIST_DIR = "dist";
+/**
+ * Default internal working directory used for runtime-only artifacts.
+ *
+ * @remarks
+ * This directory is a local tool workspace and is not intended for deployment.
+ * It owns transpiled server modules, runtime manifests, and processor caches
+ * so the export directory can remain a clean deployable tree.
+ */
+export declare const DEFAULT_ECOPAGES_WORK_DIR = ".eco";

package/src/constants.js

@@ -0,0 +1,25 @@
+const STATUS_MESSAGE = {
+  404: "404 Not Found"
+};
+const IS_BUN = typeof Bun !== "undefined";
+const RESOLVED_ASSETS_DIR = "assets";
+const RESOLVED_ASSETS_VENDORS_DIR = `${RESOLVED_ASSETS_DIR}/vendors`;
+const GENERATED_BASE_PATHS = {
+  types: "node_modules/@types",
+  cache: "cache"
+};
+const DEFAULT_ECOPAGES_PORT = 3e3;
+const DEFAULT_ECOPAGES_HOSTNAME = "localhost";
+const DEFAULT_ECOPAGES_DIST_DIR = "dist";
+const DEFAULT_ECOPAGES_WORK_DIR = ".eco";
+export {
+  DEFAULT_ECOPAGES_DIST_DIR,
+  DEFAULT_ECOPAGES_HOSTNAME,
+  DEFAULT_ECOPAGES_PORT,
+  DEFAULT_ECOPAGES_WORK_DIR,
+  GENERATED_BASE_PATHS,
+  IS_BUN,
+  RESOLVED_ASSETS_DIR,
+  RESOLVED_ASSETS_VENDORS_DIR,
+  STATUS_MESSAGE
+};

package/src/create-app.d.ts

@@ -0,0 +1,17 @@
+import type { EcopagesAppOptions as BunOptions } from './adapters/bun/create-app.js';
+import type { EcopagesAppOptions as NodeOptions } from './adapters/node/create-app.js';
+import { AbstractApplicationAdapter } from './adapters/abstract/application-adapter.js';
+import { SharedApplicationAdapter } from './adapters/shared/application-adapter.js';
+export type EcopagesAppOptions = BunOptions | NodeOptions;
+export type UniversalEcopagesApp = AbstractApplicationAdapter<EcopagesAppOptions, any, 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>;
+}