@ereo/core 0.1.6

package/dist/index.js

@@ -0,0 +1,959 @@
+// @bun
+// src/context.ts
+function createContext(request) {
+  return new RequestContext(request);
+}
+
+class RequestContext {
+  url;
+  env;
+  responseHeaders;
+  store = new Map;
+  cacheOptions;
+  cacheTags = [];
+  constructor(request) {
+    this.url = new URL(request.url);
+    this.env = typeof process !== "undefined" ? process.env : {};
+    this.responseHeaders = new Headers;
+  }
+  cache = {
+    set: (options) => {
+      this.cacheOptions = options;
+      if (options.tags) {
+        this.cacheTags = [...new Set([...this.cacheTags, ...options.tags])];
+      }
+    },
+    get: () => this.cacheOptions,
+    getTags: () => this.cacheTags
+  };
+  get(key) {
+    return this.store.get(key);
+  }
+  set(key, value) {
+    this.store.set(key, value);
+  }
+  has(key) {
+    return this.store.has(key);
+  }
+  delete(key) {
+    return this.store.delete(key);
+  }
+  buildCacheControlHeader() {
+    if (!this.cacheOptions)
+      return null;
+    const parts = [];
+    const { maxAge, staleWhileRevalidate, private: isPrivate } = this.cacheOptions;
+    if (isPrivate) {
+      parts.push("private");
+    } else {
+      parts.push("public");
+    }
+    if (maxAge !== undefined) {
+      parts.push(`max-age=${maxAge}`);
+    }
+    if (staleWhileRevalidate !== undefined) {
+      parts.push(`stale-while-revalidate=${staleWhileRevalidate}`);
+    }
+    return parts.length > 0 ? parts.join(", ") : null;
+  }
+  applyToResponse(response) {
+    const headers = new Headers(response.headers);
+    this.responseHeaders.forEach((value, key) => {
+      headers.set(key, value);
+    });
+    const cacheControl = this.buildCacheControlHeader();
+    if (cacheControl && !headers.has("Cache-Control")) {
+      headers.set("Cache-Control", cacheControl);
+    }
+    if (this.cacheTags.length > 0 && !headers.has("X-Cache-Tags")) {
+      headers.set("X-Cache-Tags", this.cacheTags.join(","));
+    }
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+}
+function isRequestContext(value) {
+  return value instanceof RequestContext;
+}
+var contextSymbol = Symbol.for("ereo.context");
+function attachContext(request, context) {
+  request[contextSymbol] = context;
+}
+function getContext(request) {
+  return request[contextSymbol];
+}
+
+// src/plugin.ts
+class PluginRegistry {
+  plugins = [];
+  context;
+  constructor(config, mode, root) {
+    this.context = { config, mode, root };
+  }
+  async register(plugin) {
+    if (!plugin.name) {
+      throw new Error("Plugin must have a name");
+    }
+    if (this.plugins.some((p) => p.name === plugin.name)) {
+      console.warn(`Plugin "${plugin.name}" is already registered, skipping duplicate`);
+      return;
+    }
+    this.plugins.push(plugin);
+    if (plugin.setup) {
+      await plugin.setup(this.context);
+    }
+  }
+  async registerAll(plugins) {
+    for (const plugin of plugins) {
+      await this.register(plugin);
+    }
+  }
+  getPlugins() {
+    return this.plugins;
+  }
+  getPlugin(name) {
+    return this.plugins.find((p) => p.name === name);
+  }
+  async transform(code, id) {
+    let result = code;
+    for (const plugin of this.plugins) {
+      if (plugin.transform) {
+        const transformed = await plugin.transform(result, id);
+        if (transformed !== null) {
+          result = transformed;
+        }
+      }
+    }
+    return result;
+  }
+  resolveId(id) {
+    for (const plugin of this.plugins) {
+      if (plugin.resolveId) {
+        const resolved = plugin.resolveId(id);
+        if (resolved !== null) {
+          return resolved;
+        }
+      }
+    }
+    return null;
+  }
+  async load(id) {
+    for (const plugin of this.plugins) {
+      if (plugin.load) {
+        const loaded = await plugin.load(id);
+        if (loaded !== null) {
+          return loaded;
+        }
+      }
+    }
+    return null;
+  }
+  async configureServer(server) {
+    for (const plugin of this.plugins) {
+      if (plugin.configureServer) {
+        await plugin.configureServer(server);
+      }
+    }
+  }
+  async buildStart() {
+    for (const plugin of this.plugins) {
+      if (plugin.buildStart) {
+        await plugin.buildStart();
+      }
+    }
+  }
+  async buildEnd() {
+    for (const plugin of this.plugins) {
+      if (plugin.buildEnd) {
+        await plugin.buildEnd();
+      }
+    }
+  }
+}
+function definePlugin(plugin) {
+  return plugin;
+}
+function composePlugins(name, plugins) {
+  return {
+    name,
+    async setup(context) {
+      for (const plugin of plugins) {
+        if (plugin.setup) {
+          await plugin.setup(context);
+        }
+      }
+    },
+    async transform(code, id) {
+      let result = code;
+      for (const plugin of plugins) {
+        if (plugin.transform) {
+          const transformed = await plugin.transform(result, id);
+          if (transformed !== null) {
+            result = transformed;
+          }
+        }
+      }
+      return result !== code ? result : null;
+    },
+    resolveId(id) {
+      for (const plugin of plugins) {
+        if (plugin.resolveId) {
+          const resolved = plugin.resolveId(id);
+          if (resolved !== null) {
+            return resolved;
+          }
+        }
+      }
+      return null;
+    },
+    async load(id) {
+      for (const plugin of plugins) {
+        if (plugin.load) {
+          const loaded = await plugin.load(id);
+          if (loaded !== null) {
+            return loaded;
+          }
+        }
+      }
+      return null;
+    },
+    async configureServer(server) {
+      for (const plugin of plugins) {
+        if (plugin.configureServer) {
+          await plugin.configureServer(server);
+        }
+      }
+    },
+    async buildStart() {
+      for (const plugin of plugins) {
+        if (plugin.buildStart) {
+          await plugin.buildStart();
+        }
+      }
+    },
+    async buildEnd() {
+      for (const plugin of plugins) {
+        if (plugin.buildEnd) {
+          await plugin.buildEnd();
+        }
+      }
+    }
+  };
+}
+var securityHeadersPlugin = definePlugin({
+  name: "ereo:security-headers",
+  setup() {}
+});
+function isPlugin(value) {
+  return typeof value === "object" && value !== null && "name" in value && typeof value.name === "string";
+}
+
+// src/app.ts
+var defaultConfig = {
+  server: {
+    port: 3000,
+    hostname: "localhost",
+    development: true
+  },
+  build: {
+    target: "bun",
+    outDir: ".ereo",
+    minify: true,
+    sourcemap: true
+  },
+  plugins: [],
+  basePath: "",
+  routesDir: "app/routes"
+};
+function createApp(options = {}) {
+  return new EreoApp(options);
+}
+function defineConfig(config) {
+  return config;
+}
+
+class EreoApp {
+  config;
+  routes = [];
+  plugins = [];
+  pluginRegistry;
+  middlewares = [];
+  routeMatcher = null;
+  constructor(options = {}) {
+    this.config = this.mergeConfig(defaultConfig, options.config || {});
+    const mode = this.config.server?.development ? "development" : "production";
+    this.pluginRegistry = new PluginRegistry(this.config, mode, process.cwd());
+    if (options.routes) {
+      this.routes = options.routes;
+    }
+  }
+  mergeConfig(defaults, overrides) {
+    return {
+      server: { ...defaults.server, ...overrides.server },
+      build: { ...defaults.build, ...overrides.build },
+      plugins: [...defaults.plugins || [], ...overrides.plugins || []],
+      basePath: overrides.basePath ?? defaults.basePath,
+      routesDir: overrides.routesDir ?? defaults.routesDir
+    };
+  }
+  use(plugin) {
+    this.plugins.push(plugin);
+    return this;
+  }
+  middleware(handler) {
+    this.middlewares.push(handler);
+    return this;
+  }
+  setRouteMatcher(matcher) {
+    this.routeMatcher = matcher;
+  }
+  setRoutes(routes) {
+    this.routes = routes;
+  }
+  async initializePlugins() {
+    if (this.config.plugins) {
+      await this.pluginRegistry.registerAll(this.config.plugins);
+    }
+    await this.pluginRegistry.registerAll(this.plugins);
+  }
+  async handle(request) {
+    const context = createContext(request);
+    try {
+      const response = await this.runMiddleware(request, context, async () => {
+        return this.handleRoute(request, context);
+      });
+      return context.applyToResponse(response);
+    } catch (error) {
+      return this.handleError(error, context);
+    }
+  }
+  async runMiddleware(request, context, final) {
+    let index = 0;
+    const next = async () => {
+      if (index < this.middlewares.length) {
+        const middleware = this.middlewares[index++];
+        return middleware(request, context, next);
+      }
+      return final();
+    };
+    return next();
+  }
+  async handleRoute(request, context) {
+    const url = new URL(request.url);
+    let pathname = url.pathname;
+    if (this.config.basePath && pathname.startsWith(this.config.basePath)) {
+      pathname = pathname.slice(this.config.basePath.length) || "/";
+    }
+    if (!this.routeMatcher) {
+      return new Response("Router not configured", { status: 500 });
+    }
+    const match = this.routeMatcher(pathname);
+    if (!match) {
+      return new Response("Not Found", { status: 404 });
+    }
+    if (!match.route.module) {
+      return new Response("Route module not loaded", { status: 500 });
+    }
+    const module = match.route.module;
+    if (request.method !== "GET" && request.method !== "HEAD") {
+      if (module.action) {
+        const actionData = await module.action({
+          request,
+          params: match.params,
+          context
+        });
+        if (actionData instanceof Response) {
+          return actionData;
+        }
+        return new Response(JSON.stringify(actionData), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      return new Response("Method Not Allowed", { status: 405 });
+    }
+    let loaderData = null;
+    if (module.loader) {
+      loaderData = await module.loader({
+        request,
+        params: match.params,
+        context
+      });
+      if (loaderData instanceof Response) {
+        return loaderData;
+      }
+    }
+    if (request.headers.get("Accept")?.includes("application/json")) {
+      return new Response(JSON.stringify(loaderData), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    return new Response(JSON.stringify({ loaderData, params: match.params }), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  handleError(error, context) {
+    const isDev = this.config.server?.development;
+    const message = error instanceof Error ? error.message : "Internal Server Error";
+    const stack = error instanceof Error ? error.stack : undefined;
+    console.error("Request error:", error);
+    if (isDev) {
+      return new Response(JSON.stringify({
+        error: message,
+        stack: stack?.split(`
+`)
+      }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    return new Response("Internal Server Error", { status: 500 });
+  }
+  async dev() {
+    await this.initializePlugins();
+    console.log(`Starting dev server on http://${this.config.server?.hostname}:${this.config.server?.port}`);
+  }
+  async build() {
+    await this.initializePlugins();
+    await this.pluginRegistry.buildStart();
+    console.log("Building for production...");
+    console.log(`Target: ${this.config.build?.target}`);
+    console.log(`Output: ${this.config.build?.outDir}`);
+    await this.pluginRegistry.buildEnd();
+  }
+  async start() {
+    await this.initializePlugins();
+    console.log(`Starting production server on http://${this.config.server?.hostname}:${this.config.server?.port}`);
+  }
+  getPluginRegistry() {
+    return this.pluginRegistry;
+  }
+}
+function isEreoApp(value) {
+  return value instanceof EreoApp;
+}
+// src/env.ts
+import { join } from "path";
+function createSchemaBuilder(baseSchema) {
+  const schema = { ...baseSchema };
+  const builder = {
+    required() {
+      schema.required = true;
+      schema.default = undefined;
+      return builder;
+    },
+    default(value) {
+      schema.default = value;
+      schema.required = false;
+      return builder;
+    },
+    description(desc) {
+      schema.description = desc;
+      return builder;
+    },
+    validate(fn) {
+      schema.validate = fn;
+      return builder;
+    },
+    public() {
+      schema.public = true;
+      return builder;
+    },
+    _schema: schema
+  };
+  Object.defineProperty(builder, "_schema", {
+    get: () => schema
+  });
+  return builder;
+}
+var env = {
+  string() {
+    return createSchemaBuilder({
+      type: "string",
+      required: false
+    });
+  },
+  number() {
+    return createSchemaBuilder({
+      type: "number",
+      required: false,
+      transform: (value) => {
+        const num = parseFloat(value);
+        if (isNaN(num)) {
+          throw new Error(`Invalid number: ${value}`);
+        }
+        return num;
+      }
+    });
+  },
+  boolean() {
+    return createSchemaBuilder({
+      type: "boolean",
+      required: false,
+      transform: (value) => {
+        const lower = value.toLowerCase();
+        if (["true", "1", "yes", "on"].includes(lower))
+          return true;
+        if (["false", "0", "no", "off", ""].includes(lower))
+          return false;
+        throw new Error(`Invalid boolean: ${value}`);
+      }
+    });
+  },
+  json() {
+    return createSchemaBuilder({
+      type: "json",
+      required: false,
+      transform: (value) => {
+        try {
+          return JSON.parse(value);
+        } catch {
+          throw new Error(`Invalid JSON: ${value}`);
+        }
+      }
+    });
+  },
+  array() {
+    return createSchemaBuilder({
+      type: "array",
+      required: false,
+      transform: (value) => {
+        if (!value.trim())
+          return [];
+        return value.split(",").map((s) => s.trim());
+      }
+    });
+  },
+  enum(values) {
+    return createSchemaBuilder({
+      type: "string",
+      required: false,
+      validate: (value) => {
+        if (!values.includes(value)) {
+          return `Must be one of: ${values.join(", ")}`;
+        }
+        return true;
+      }
+    });
+  },
+  url() {
+    return createSchemaBuilder({
+      type: "string",
+      required: false,
+      validate: (value) => {
+        try {
+          new URL(value);
+          return true;
+        } catch {
+          return "Invalid URL";
+        }
+      }
+    });
+  },
+  port() {
+    return createSchemaBuilder({
+      type: "number",
+      required: false,
+      transform: (value) => parseInt(value, 10),
+      validate: (value) => {
+        if (!Number.isInteger(value) || value < 1 || value > 65535) {
+          return "Port must be an integer between 1 and 65535";
+        }
+        return true;
+      }
+    });
+  }
+};
+function parseEnvFile(content) {
+  const result = {};
+  const lines = content.split(`
+`);
+  for (let line of lines) {
+    line = line.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const eqIndex = line.indexOf("=");
+    if (eqIndex === -1)
+      continue;
+    const key = line.slice(0, eqIndex).trim();
+    let value = line.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (line.slice(eqIndex + 1).trim().startsWith('"')) {
+      value = value.replace(/\\n/g, `
+`).replace(/\\r/g, "\r").replace(/\\t/g, "\t").replace(/\\\\/g, "\\");
+    }
+    result[key] = value;
+  }
+  return result;
+}
+async function loadEnvFiles(root, mode = "development") {
+  const envFiles = [
+    ".env",
+    `.env.${mode}`,
+    `.env.${mode}.local`,
+    ".env.local"
+  ];
+  const loaded = {};
+  for (const file of envFiles) {
+    const filePath = join(root, file);
+    try {
+      const bunFile = Bun.file(filePath);
+      if (await bunFile.exists()) {
+        const content = await bunFile.text();
+        const parsed = parseEnvFile(content);
+        Object.assign(loaded, parsed);
+      }
+    } catch {}
+  }
+  return loaded;
+}
+function validateEnv(schema, rawEnv) {
+  const errors = [];
+  const warnings = [];
+  const parsed = {};
+  for (const [key, builder] of Object.entries(schema)) {
+    const definition = builder._schema;
+    const rawValue = rawEnv[key];
+    if (rawValue === undefined || rawValue === "") {
+      if (definition.required) {
+        errors.push({
+          key,
+          message: `Missing required environment variable: ${key}`,
+          expected: definition.type
+        });
+        continue;
+      }
+      if (definition.default !== undefined) {
+        parsed[key] = definition.default;
+        continue;
+      }
+      continue;
+    }
+    try {
+      let value;
+      if (definition.transform) {
+        value = definition.transform(rawValue);
+      } else {
+        value = rawValue;
+      }
+      if (definition.validate) {
+        const result = definition.validate(value);
+        if (result !== true) {
+          errors.push({
+            key,
+            message: typeof result === "string" ? result : `Validation failed for ${key}`,
+            expected: definition.description || definition.type,
+            received: String(rawValue)
+          });
+          continue;
+        }
+      }
+      parsed[key] = value;
+    } catch (error) {
+      errors.push({
+        key,
+        message: error instanceof Error ? error.message : `Invalid value for ${key}`,
+        expected: definition.type,
+        received: rawValue
+      });
+    }
+  }
+  for (const key of Object.keys(rawEnv)) {
+    if (key.startsWith("EREO_") && !schema[key]) {
+      warnings.push(`Unknown environment variable with EREO_ prefix: ${key}`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    env: parsed
+  };
+}
+var globalEnv = {};
+var envInitialized = false;
+function initializeEnv(validatedEnv) {
+  globalEnv = { ...validatedEnv };
+  envInitialized = true;
+}
+function getEnv(key) {
+  if (!envInitialized) {
+    return process.env[key];
+  }
+  return globalEnv[key];
+}
+function requireEnv(key) {
+  const value = getEnv(key);
+  if (value === undefined) {
+    throw new Error(`Required environment variable not set: ${key}`);
+  }
+  return value;
+}
+function getAllEnv() {
+  return { ...globalEnv };
+}
+function getPublicEnv(schema) {
+  const publicEnv = {};
+  for (const [key, builder] of Object.entries(schema)) {
+    const definition = builder._schema;
+    if (definition.public && globalEnv[key] !== undefined) {
+      publicEnv[key] = globalEnv[key];
+    }
+  }
+  return publicEnv;
+}
+async function setupEnv(root, schema, mode = "development") {
+  const fileEnv = await loadEnvFiles(root, mode);
+  const combinedEnv = {
+    ...fileEnv,
+    ...process.env
+  };
+  const result = validateEnv(schema, combinedEnv);
+  if (result.valid) {
+    initializeEnv(result.env);
+  }
+  for (const warning of result.warnings) {
+    console.warn(`[env] Warning: ${warning}`);
+  }
+  if (!result.valid) {
+    console.error("[env] Environment validation failed:");
+    for (const error of result.errors) {
+      console.error(`  - ${error.key}: ${error.message}`);
+      if (error.expected)
+        console.error(`    Expected: ${error.expected}`);
+      if (error.received)
+        console.error(`    Received: ${error.received}`);
+    }
+  }
+  return result;
+}
+function generateEnvTypes(schema) {
+  const lines = [
+    "// Auto-generated by @ereo/core",
+    "// Do not edit this file manually",
+    "",
+    "declare module '@ereo/core' {",
+    "  interface EnvTypes {"
+  ];
+  for (const [key, builder] of Object.entries(schema)) {
+    const definition = builder._schema;
+    let tsType;
+    switch (definition.type) {
+      case "number":
+        tsType = "number";
+        break;
+      case "boolean":
+        tsType = "boolean";
+        break;
+      case "json":
+        tsType = "Record<string, unknown>";
+        break;
+      case "array":
+        tsType = "string[]";
+        break;
+      default:
+        tsType = "string";
+    }
+    const optional = !definition.required && definition.default === undefined;
+    lines.push(`    ${key}${optional ? "?" : ""}: ${tsType};`);
+  }
+  lines.push("  }");
+  lines.push("}");
+  lines.push("");
+  lines.push("export {};");
+  return lines.join(`
+`);
+}
+var typedEnv = new Proxy({}, {
+  get(_target, key) {
+    return getEnv(key);
+  }
+});
+// src/cache.ts
+class MemoryCacheAdapter {
+  cache = new Map;
+  tagIndex = new Map;
+  maxSize;
+  defaultTtl;
+  constructor(options = {}) {
+    this.maxSize = options.maxSize ?? Infinity;
+    this.defaultTtl = options.defaultTtl;
+  }
+  async get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return;
+    }
+    if (this.isExpired(entry)) {
+      await this.delete(key);
+      return;
+    }
+    return entry.value;
+  }
+  async set(key, value, options) {
+    if (this.cache.has(key)) {
+      await this.delete(key);
+    }
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        await this.delete(firstKey);
+      }
+    }
+    const tags = options?.tags ?? [];
+    const ttl = options?.ttl ?? this.defaultTtl;
+    const entry = {
+      value,
+      createdAt: Date.now(),
+      ttl,
+      tags
+    };
+    this.cache.set(key, entry);
+    for (const tag of tags) {
+      if (!this.tagIndex.has(tag)) {
+        this.tagIndex.set(tag, new Set);
+      }
+      this.tagIndex.get(tag).add(key);
+    }
+  }
+  async delete(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return false;
+    }
+    for (const tag of entry.tags) {
+      const tagSet = this.tagIndex.get(tag);
+      if (tagSet) {
+        tagSet.delete(key);
+        if (tagSet.size === 0) {
+          this.tagIndex.delete(tag);
+        }
+      }
+    }
+    return this.cache.delete(key);
+  }
+  async has(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return false;
+    }
+    if (this.isExpired(entry)) {
+      await this.delete(key);
+      return false;
+    }
+    return true;
+  }
+  async clear() {
+    this.cache.clear();
+    this.tagIndex.clear();
+  }
+  async invalidateTag(tag) {
+    const keys = this.tagIndex.get(tag);
+    if (!keys) {
+      return;
+    }
+    const keysCopy = [...keys];
+    for (const key of keysCopy) {
+      await this.delete(key);
+    }
+  }
+  async invalidateTags(tags) {
+    for (const tag of tags) {
+      await this.invalidateTag(tag);
+    }
+  }
+  async getByTag(tag) {
+    const keys = this.tagIndex.get(tag);
+    if (!keys) {
+      return [];
+    }
+    const validKeys = [];
+    for (const key of keys) {
+      if (await this.has(key)) {
+        validKeys.push(key);
+      }
+    }
+    return validKeys;
+  }
+  getStats() {
+    return {
+      size: this.cache.size,
+      tags: this.tagIndex.size
+    };
+  }
+  async keys() {
+    return Array.from(this.cache.keys());
+  }
+  isExpired(entry) {
+    if (!entry.ttl) {
+      return false;
+    }
+    const age = Date.now() - entry.createdAt;
+    return age > entry.ttl * 1000;
+  }
+}
+function createCache(options) {
+  return new MemoryCacheAdapter(options);
+}
+function createTaggedCache(options) {
+  return new MemoryCacheAdapter({ ...options, tagged: true });
+}
+function isTaggedCache(cache) {
+  return "invalidateTag" in cache && "invalidateTags" in cache && "getByTag" in cache && typeof cache.invalidateTag === "function" && typeof cache.invalidateTags === "function" && typeof cache.getByTag === "function";
+}
+function wrapCacheAdapter(impl) {
+  return {
+    async get(key) {
+      return impl.get(key);
+    },
+    async set(key, value, options) {
+      await impl.set(key, value, options);
+    },
+    async delete(key) {
+      return impl.delete(key);
+    },
+    async has(key) {
+      return impl.has(key);
+    },
+    async clear() {
+      await impl.clear();
+    }
+  };
+}
+export {
+  wrapCacheAdapter,
+  validateEnv,
+  typedEnv,
+  setupEnv,
+  securityHeadersPlugin,
+  requireEnv,
+  parseEnvFile,
+  loadEnvFiles,
+  isTaggedCache,
+  isRequestContext,
+  isPlugin,
+  isEreoApp,
+  initializeEnv,
+  getPublicEnv,
+  getEnv,
+  getContext,
+  getAllEnv,
+  generateEnvTypes,
+  env,
+  definePlugin,
+  defineConfig,
+  createTaggedCache,
+  createContext,
+  createCache,
+  createApp,
+  composePlugins,
+  attachContext,
+  RequestContext,
+  PluginRegistry,
+  MemoryCacheAdapter,
+  EreoApp
+};