@gravito/core 1.2.0 → 1.6.0

package/README.md

@@ -12,15 +12,17 @@
 ## ✨ Features
 
 - 🪐 **PlanetCore** - A centralized Photon-based kernel to manage your application lifecycle.
+- 🏢 **Application Container** - Enterprise-grade container with auto-discovery of providers and convention-over-configuration patterns.
 - 📦 **IoC Container** - A lightweight dependency injection container with binding and singleton support.
 - 🧩 **Service Providers** - Modular service registration and booting lifecycle.
 - 🪝 **Hook System** - WordPress-style async **Filters** and **Actions** for powerful extensibility.
+- 📡 **Event System** - Centralized EventManager for cross-module communication and event-driven architecture.
 - 🛰️ **Orbit Mounting** - Easily mount external Photon applications (Orbits) to specific paths.
 - 📝 **Logger System** - PSR-3 style logger interface with default standard output implementation.
-- ⚙️ **Config Manager** - Unified configuration management supporting environment variables (`Bun.env`) and runtime injection.
+- ⚙️ **Config Manager** - Unified configuration management supporting environment variables, runtime injection, and file-based config loading.
 - 🛡️ **Security Middleware** - Built-in protection including CSRF, CORS, HSTS, and request throttling.
 - 🔌 **Runtime Adapters** - Abstraction layer for underlying runtimes (Bun, Node.js) and HTTP engines.
-- 🛡️ **Error Handling** - Built-in standardized JSON error responses and 404 handling.
+- 🛡️ **Error Handling** - Built-in standardized JSON error responses, 404 handling, and process-level error management.
 - 🚀 **Modern** - Built for **Bun** runtime with native TypeScript support.
 - 🪶 **Lightweight** - Zero external dependencies (except `@gravito/photon`).
 
@@ -32,12 +34,28 @@ bun add @gravito/core
 
 ## 🚀 Quick Start
 
-### 1. Initialize the Core
+### 1. Initialize the Application
+
+For enterprise applications, use the `Application` class which provides auto-discovery and conventions:
+
+```typescript
+import { Application } from '@gravito/core';
+
+const app = new Application({
+  basePath: import.meta.dir,
+  env: process.env.NODE_ENV as 'development' | 'production',
+});
+
+await app.boot();
+
+export default app.core.liftoff();
+```
+
+Or use the lightweight `PlanetCore` directly:
 
 ```typescript
 import { PlanetCore } from '@gravito/core';
 
-// Initialize with options (v0.2.0+)
 const core = new PlanetCore({
   config: {
     PORT: 4000,
@@ -138,7 +156,15 @@ core.hooks.addAction('processError:report', async (ctx) => {
 
 ## 📖 API Reference
 
-### `PlanetCore`
+### `Application` (Enterprise Container)
+
+- **`constructor(options: ApplicationConfig)`**: Create an application instance.
+- **`boot()`**: Orchestrate the boot sequence (config loading, provider discovery).
+- **`make<T>(key)`**: Resolve a service from the shared container.
+- **`getConfig(key, default?)`**: Retrieve configuration.
+- **`path(...segments)`**: Path helper relative to base path.
+
+### `PlanetCore` (Micro-kernel)
 
 - **`constructor(options?)`**: Initialize the core with optional Logger and Config.
 - **`register(provider: ServiceProvider)`**: Register a service provider.
@@ -148,6 +174,7 @@ core.hooks.addAction('processError:report', async (ctx) => {
 - **`container`**: Access the IoC Container.
 - **`app`**: Access the internal Photon instance.
 - **`hooks`**: Access the HookManager.
+- **`events`**: Access the EventManager.
 - **`logger`**: Access the Logger instance.
 - **`config`**: Access the ConfigManager.
 
@@ -155,10 +182,28 @@ core.hooks.addAction('processError:report', async (ctx) => {
 
 - **`bind(key, factory)`**: Register a transient binding.
 - **`singleton(key, factory)`**: Register a shared binding.
-- **`make<T>(key)`**: Resolve a service instance.
+- **`make(key)`**: Resolve a service instance. Supports automatic type inference via `ServiceMap` augmentation.
 - **`instance(key, instance)`**: Register an existing object instance.
 - **`has(key)`**: Check if a service is bound.
 
+#### Type Safety (ServiceMap)
+
+You can extend the `ServiceMap` interface to get automatic type inference for `container.make()`:
+
+```typescript
+// types.d.ts
+import { Logger } from './Logger';
+
+declare module '@gravito/core' {
+  interface ServiceMap {
+    logger: Logger;
+  }
+}
+
+// usage.ts
+const logger = container.make('logger'); // inferred as Logger
+```
+
 ### `HookManager`
 
 - **`addFilter(hook, callback)`**: Register a filter.
@@ -166,6 +211,12 @@ core.hooks.addAction('processError:report', async (ctx) => {
 - **`addAction(hook, callback)`**: Register an action.
 - **`doAction(hook, ...args)`**: Execute actions.
 
+### `EventManager`
+
+- **`emit(event, ...args)`**: Dispatch an event.
+- **`on(event, callback)`**: Listen to an event.
+- **`off(event, callback)`**: Remove a listener.
+
 ### `ConfigManager`
 
 - **`get(key, default?)`**: Retrieve a config value.

package/README.zh-TW.md

@@ -1,24 +1,215 @@
 # @gravito/core
 
-> Galaxy 架構的微核心，基於 Photon 與 Bun 的輕量可擴充框架核心。
+> Galaxy 架構的微核心。輕量、可擴展，基於 Photon 與 Bun 構建。
 
-## 安裝
+[![npm version](https://img.shields.io/npm/v/@gravito/core.svg)](https://www.npmjs.com/package/@gravito/core)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
+[![Bun](https://img.shields.io/badge/Bun-1.0+-black.svg)](https://bun.sh/)
+
+**@gravito/core** 是使用 **Galaxy 架構** 構建模組化後端應用的基礎。它提供了一個強大的 Hook 系統（Filters 與 Actions）和 Orbit 掛載機制，讓您能夠構建低耦合、高擴展性的系統。
+
+## ✨ 特性
+
+- 🪐 **PlanetCore** - 基於 Photon 的中央核心，管理應用程式生命週期。
+- 🏢 **Application Container** - 企業級容器，支援 Provider 自動發現與慣例優於配置（Convention-over-Configuration）模式。
+- 📦 **IoC Container** - 輕量級依賴注入容器，支援綁定（Binding）與單例（Singleton）。
+- 🧩 **Service Providers** - 模組化的服務註冊與啟動生命週期。
+- 🪝 **Hook System** - WordPress 風格的異步 **Filters** 與 **Actions**，提供強大的擴展能力。
+- 📡 **Event System** - 中央 EventManager，支援跨模組通訊與事件驅動架構。
+- 🛰️ **Orbit Mounting** - 輕鬆將外部 Photon 應用程式（Orbits）掛載到特定路徑。
+- 📝 **Logger System** - PSR-3 風格的日誌介面，內建標準輸出實作。
+- ⚙️ **Config Manager** - 統一的配置管理，支援環境變數、運行時注入與基於檔案的配置載入。
+- 🛡️ **Security Middleware** - 內建保護功能，包括 CSRF、CORS、HSTS 與請求限流（Throttling）。
+- 🔌 **Runtime Adapters** - 底層運行時（Bun, Node.js）與 HTTP 引擎的抽象層。
+- 🛡️ **Error Handling** - 內建標準化 JSON 錯誤回應、404 處理與進程級別錯誤管理。
+- 🚀 **Modern** - 專為 **Bun** 運行時設計，原生支援 TypeScript。
+- 🪶 **Lightweight** - 除了 `@gravito/photon` 外零外部依賴。
+
+## 📦 安裝
 
 ```bash
 bun add @gravito/core
 ```
 
-## 快速開始
+## 🚀 快速上手
+
+### 1. 初始化應用程式
+
+對於企業級應用，使用 `Application` 類別，它提供自動發現與開發慣例：
+
+```typescript
+import { Application } from '@gravito/core';
+
+const app = new Application({
+  basePath: import.meta.dir,
+  env: process.env.NODE_ENV as 'development' | 'production',
+});
+
+await app.boot();
+
+export default app.core.liftoff();
+```
+
+或者直接使用輕量級的 `PlanetCore`：
 
 ```typescript
-import { PlanetCore } from '@gravito/core'
+import { PlanetCore } from '@gravito/core';
 
 const core = new PlanetCore({
   config: {
     PORT: 4000,
     DEBUG: true
   }
-})
+});
+```
+
+### 2. 依賴注入
+
+使用 IoC 容器管理應用程式服務：
+
+```typescript
+import { ServiceProvider, Container } from '@gravito/core';
+
+class CacheServiceProvider extends ServiceProvider {
+  register(container: Container) {
+    // 綁定單例服務
+    container.singleton('cache', (c) => {
+      return new RedisCache(process.env.REDIS_URL);
+    });
+  }
+
+  async boot(core: PlanetCore) {
+    // 執行啟動邏輯
+    core.logger.info('Cache provider booted');
+  }
+}
+
+// 註冊 Provider
+core.register(new CacheServiceProvider());
+
+// 啟動應用程式（執行 register() 與 boot()）
+await core.bootstrap();
+
+// 解析服務
+const cache = core.container.make('cache');
+```
+
+### 3. 註冊 Hooks
+
+使用 **Filters** 修改資料：
+
+```typescript
+core.hooks.addFilter('modify_content', async (content: string) => {
+  return content.toUpperCase();
+});
+
+const result = await core.hooks.applyFilters('modify_content', 'hello galaxy');
+// 回傳: "HELLO GALAXY"
+```
+
+使用 **Actions** 觸發副作用：
+
+```typescript
+core.hooks.addAction('user_registered', async (userId: string) => {
+  core.logger.info(`Sending welcome email to ${userId}`);
+});
+
+await core.hooks.doAction('user_registered', 'user_123');
+```
+
+### 4. 掛載 Orbit
+
+Orbits 是標準的 Photon 應用程式，可以插入核心中。
+
+```typescript
+import { Photon } from '@gravito/photon';
+
+const blogOrbit = new Photon();
+blogOrbit.get('/posts', (c) => c.json({ posts: [] }));
+
+// 將 orbit 掛載到 /api/blog
+core.mountOrbit('/api/blog', blogOrbit);
+```
+
+### 5. Liftoff! 🚀
+
+```typescript
+// 為 Bun.serve 導出
+export default core.liftoff(); // 自動使用來自配置或環境變數的 PORT
+```
 
-export default core.liftoff()
+### 6. 進程級別錯誤處理（推薦）
+
+請求級別的錯誤由 `PlanetCore` 自動處理，但背景工作與啟動代碼仍可能在請求生命週期外失敗。
+
+```ts
+// 註冊 `unhandledRejection` / `uncaughtException`
+const unregister = core.registerGlobalErrorHandlers()
+
+// 選配：回報至 Sentry / 自定義回報器
+core.hooks.addAction('processError:report', async (ctx) => {
+  // ctx.kind: 'unhandledRejection' | 'uncaughtException'
+  // ctx.error: unknown
+})
 ```
+
+## 📖 API 參考
+
+### `Application` (企業級容器)
+
+- **`constructor(options: ApplicationConfig)`**: 建立應用程式實例。
+- **`boot()`**: 統籌啟動順序（配置載入、Provider 發現）。
+- **`make<T>(key)`**: 從共享容器中解析服務。
+- **`getConfig(key, default?)`**: 取得配置資訊。
+- **`path(...segments)`**: 相對於基礎路徑的路徑輔助函數。
+
+### `PlanetCore` (微核心)
+
+- **`constructor(options?)`**: 初始化核心，可選配 Logger 與 Config。
+- **`register(provider: ServiceProvider)`**: 註冊服務提供者。
+- **`bootstrap()`**: 啟動所有已註冊的提供者。
+- **`mountOrbit(path: string, app: Photon)`**: 將 Photon 應用掛載到子路徑。
+- **`liftoff(port?: number)`**: 回傳用於 `Bun.serve` 的配置物件。
+- **`container`**: 存取 IoC 容器。
+- **`app`**: 存取內部 Photon 實例。
+- **`hooks`**: 存取 HookManager。
+- **`events`**: 存取 EventManager。
+- **`logger`**: 存取 Logger 實例。
+- **`config`**: 存取 ConfigManager。
+
+### `Container`
+
+- **`bind(key, factory)`**: 註冊瞬時綁定（每次解析皆建立新實例）。
+- **`singleton(key, factory)`**: 註冊共享綁定（單例）。
+- **`make<T>(key)`**: 解析服務實例。
+- **`instance(key, instance)`**: 註冊現有的物件實例。
+- **`has(key)`**: 檢查服務是否已綁定。
+
+### `HookManager`
+
+- **`addFilter(hook, callback)`**: 註冊過濾器。
+- **`applyFilters(hook, initialValue, ...args)`**: 依序執行過濾器。
+- **`addAction(hook, callback)`**: 註冊動作。
+- **`doAction(hook, ...args)`**: 執行動作。
+
+### `EventManager`
+
+- **`emit(event, ...args)`**: 觸發事件。
+- **`on(event, callback)`**: 監聽事件。
+- **`off(event, callback)`**: 移除監聽器。
+
+### `ConfigManager`
+
+- **`get(key, default?)`**: 取得配置值。
+- **`set(key, value)`**: 設定配置值。
+- **`has(key)`**: 檢查配置鍵是否存在。
+
+## 🤝 貢獻
+
+歡迎提交貢獻、問題與功能請求！
+請隨時查看 [Issues 頁面](https://github.com/gravito-framework/gravito/issues)。
+
+## 📝 授權
+
+MIT © [Carl Lee](https://github.com/gravito-framework/gravito)

package/dist/compat-C4Src6NN.d.cts

@@ -0,0 +1,357 @@
+/**
+ * @fileoverview Core HTTP Types for Gravito Framework
+ *
+ * These types provide a unified abstraction layer that decouples the framework
+ * from any specific HTTP engine (Photon, Express, custom, etc.).
+ *
+ * @module @gravito/core/http
+ * @since 2.0.0
+ */
+declare global {
+    interface ExecutionContext {
+        waitUntil(promise: Promise<unknown>): void;
+        passThroughOnException(): void;
+    }
+}
+/**
+ * Standard HTTP methods supported by Gravito
+ */
+type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
+/**
+ * HTTP status codes
+ */
+type StatusCode = number;
+/**
+ * Content-bearing HTTP status codes (excludes 1xx, 204, 304)
+ */
+type ContentfulStatusCode = Exclude<StatusCode, 100 | 101 | 102 | 103 | 204 | 304>;
+/**
+ * Base context variables available in every request
+ * Orbits can extend this interface via module augmentation
+ *
+ * @example
+ * ```typescript
+ * // Extending variables in your orbit:
+ * declare module '@gravito/core' {
+ *   interface GravitoVariables {
+ *     myService: MyService
+ *   }
+ * }
+ * ```
+ */
+interface GravitoVariables {
+    /**
+     * The PlanetCore instance
+     * @remarks Always available in PlanetCore-managed contexts
+     */
+    core?: unknown;
+    /**
+     * Logger instance
+     */
+    logger?: unknown;
+    /**
+     * Configuration manager
+     */
+    config?: unknown;
+    /**
+     * Cookie jar for managing response cookies
+     */
+    cookieJar?: unknown;
+    /**
+     * Middleware scope tracking for Orbit isolation
+     * Tracks which Orbit/scope this request belongs to
+     * Used to prevent cross-Orbit middleware contamination
+     * @since 2.3.0
+     */
+    middlewareScope?: string;
+    /** @deprecated Use ctx.route() instead */
+    route?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * Validated request data targets
+ */
+type ValidationTarget = 'json' | 'query' | 'param' | 'header' | 'form' | 'cookie';
+/**
+ * GravitoRequest - Unified request interface
+ *
+ * Provides a consistent API for accessing request data regardless of
+ * the underlying HTTP engine.
+ *
+ * @example
+ * ```typescript
+ * const userId = ctx.req.param('id')
+ * const search = ctx.req.query('q')
+ * const body = await ctx.req.json<CreateUserDto>()
+ * ```
+ */
+interface GravitoRequest {
+    /** Full request URL */
+    readonly url: string;
+    /** HTTP method (uppercase) */
+    readonly method: string;
+    /** Request path without query string */
+    readonly path: string;
+    /**
+     * Route pattern (e.g., /users/:id) for the matched route
+     *
+     * This provides the parameterized route pattern instead of the concrete path,
+     * which is critical for preventing high cardinality issues in metrics systems.
+     *
+     * @example
+     * ```typescript
+     * // For request: GET /users/123
+     * ctx.req.path          // => "/users/123"
+     * ctx.req.routePattern  // => "/users/:id"
+     * ```
+     */
+    readonly routePattern?: string;
+    /**
+     * Get a route parameter value
+     * @param name - Parameter name (e.g., 'id' for route '/users/:id')
+     */
+    param(name: string): string | undefined;
+    /**
+     * Get all route parameters
+     */
+    params(): Record<string, string>;
+    /**
+     * Get a query string parameter
+     * @param name - Query parameter name
+     */
+    query(name: string): string | undefined;
+    /**
+     * Get all query parameters
+     */
+    queries(): Record<string, string | string[]>;
+    /**
+     * Get a request header value
+     * @param name - Header name (case-insensitive)
+     */
+    header(name: string): string | undefined;
+    /**
+     * Get all request headers
+     */
+    header(): Record<string, string>;
+    /**
+     * Parse request body as JSON
+     * @throws {Error} If body is not valid JSON
+     */
+    json<T = unknown>(): Promise<T>;
+    /**
+     * Parse request body as text
+     */
+    text(): Promise<string>;
+    /**
+     * Parse request body as FormData
+     */
+    formData(): Promise<FormData>;
+    /**
+     * Parse request body as ArrayBuffer
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Parse form data (urlencoded or multipart)
+     */
+    parseBody<T = unknown>(): Promise<T>;
+    /**
+     * Get the raw Request object
+     */
+    readonly raw: Request;
+    /**
+     * Get validated data from a specific source
+     * @param target - The validation target
+     * @throws {Error} If validation was not performed for this target
+     */
+    valid<T = unknown>(target: ValidationTarget): T;
+}
+/**
+ * Options for request forwarding (Proxy)
+ */
+interface ProxyOptions {
+    /** Override or add request headers */
+    headers?: Record<string, string>;
+    /** Whether to keep the original Host header (default: false) */
+    preserveHost?: boolean;
+    /** Whether to add X-Forwarded-* headers (default: true) */
+    addForwardedHeaders?: boolean;
+    /** Path rewriting logic */
+    rewritePath?: (path: string) => string;
+}
+/**
+ * GravitoContext - Unified request context
+ *
+ * This interface encapsulates all HTTP request/response operations,
+ * enabling seamless replacement of the underlying HTTP engine.
+ *
+ * @typeParam V - Context variables type
+ *
+ * @example
+ * ```typescript
+ * // In a controller
+ * async show(ctx: GravitoContext) {
+ *   const id = ctx.req.param('id')
+ *   const user = await User.find(id)
+ *   return ctx.json({ user })
+ * }
+ * ```
+ */
+interface GravitoContext<V extends GravitoVariables = GravitoVariables> {
+    /** The incoming request */
+    readonly req: GravitoRequest;
+    /**
+     * Send a JSON response
+     * @param data - Data to serialize as JSON
+     * @param status - HTTP status code (default: 200)
+     */
+    json<T>(data: T, status?: ContentfulStatusCode): Response;
+    /**
+     * Send a plain text response
+     * @param text - Text content
+     * @param status - HTTP status code (default: 200)
+     */
+    text(text: string, status?: ContentfulStatusCode): Response;
+    /**
+     * Send an HTML response
+     * @param html - HTML content
+     * @param status - HTTP status code (default: 200)
+     */
+    html(html: string, status?: ContentfulStatusCode): Response;
+    /**
+     * Send a redirect response
+     * @param url - Target URL
+     * @param status - Redirect status code (default: 302)
+     */
+    redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): Response;
+    /**
+     * Create a Response with no body
+     * @param status - HTTP status code
+     */
+    body(data: BodyInit | null, status?: StatusCode): Response;
+    /**
+     * Stream a response
+     * @param stream - ReadableStream to send
+     * @param status - HTTP status code (default: 200)
+     */
+    stream(stream: ReadableStream, status?: ContentfulStatusCode): Response;
+    /**
+     * Send a 404 Not Found response
+     */
+    notFound(message?: string): Response;
+    /**
+     * Send a 403 Forbidden response
+     */
+    forbidden(message?: string): Response;
+    /**
+     * Send a 401 Unauthorized response
+     */
+    unauthorized(message?: string): Response;
+    /**
+     * Send a 400 Bad Request response
+     */
+    badRequest(message?: string): Response;
+    /**
+     * Forward the current request to another URL (Reverse Proxy)
+     * @param target - Target URL or base URL to forward to
+     * @param options - Optional proxy options
+     */
+    forward(target: string, options?: ProxyOptions): Promise<Response>;
+    /**
+     * Set a response header
+     * @param name - Header name
+     * @param value - Header value
+     * @param options - Options (append: true to add multiple values)
+     */
+    header(name: string, value: string, options?: {
+        append?: boolean;
+    }): void;
+    /**
+     * Get a request header
+     * @param name - Header name (case-insensitive)
+     */
+    header(name: string): string | undefined;
+    /**
+     * Set the response status code
+     * @param code - HTTP status code
+     */
+    status(code: StatusCode): void;
+    /**
+     * Get a context variable
+     * @param key - Variable key
+     */
+    get<K extends keyof V>(key: K): V[K];
+    /**
+     * Set a context variable
+     * @param key - Variable key
+     * @param value - Variable value
+     */
+    set<K extends keyof V>(key: K, value: V[K]): void;
+    /**
+     * Get the execution context (for Cloudflare Workers, etc.)
+     */
+    readonly executionCtx?: ExecutionContext;
+    /**
+     * Get environment bindings (for Cloudflare Workers, etc.)
+     */
+    readonly env?: Record<string, unknown>;
+    /**
+     * URL generator helper.
+     * Generates a URL for a named route.
+     */
+    route: (name: string, params?: Record<string, any>, query?: Record<string, any>) => string;
+    /**
+     * Access the native context object from the underlying HTTP engine.
+     *
+     * ⚠️ WARNING: Using this ties your code to a specific adapter.
+     * Prefer using the abstraction methods when possible.
+     *
+     * @example
+     * ```typescript
+     * // Only when absolutely necessary
+     * const photonCtx = ctx.native as Context // Photon Context
+     * ```
+     */
+    readonly native: unknown;
+}
+/**
+ * Next function for middleware chain
+ */
+type GravitoNext = () => Promise<Response | undefined>;
+/**
+ * GravitoHandler - Standard route handler type
+ *
+ * @typeParam V - Context variables type
+ *
+ * @example
+ * ```typescript
+ * const handler: GravitoHandler = async (ctx) => {
+ *   return ctx.json({ message: 'Hello, World!' })
+ * }
+ * ```
+ */
+type GravitoHandler<V extends GravitoVariables = GravitoVariables> = (ctx: GravitoContext<V>) => Response | Promise<Response>;
+/**
+ * GravitoMiddleware - Standard middleware type
+ *
+ * @typeParam V - Context variables type
+ *
+ * @example
+ * ```typescript
+ * const logger: GravitoMiddleware = async (ctx, next) => {
+ *   console.log(`${ctx.req.method} ${ctx.req.path}`)
+ *   await next()
+ *   return undefined
+ * }
+ * ```
+ */
+type GravitoMiddleware<V extends GravitoVariables = GravitoVariables> = (ctx: GravitoContext<V>, next: GravitoNext) => Response | undefined | Promise<Response | undefined | undefined>;
+/**
+ * Error handler type
+ */
+type GravitoErrorHandler<V extends GravitoVariables = GravitoVariables> = (error: Error, ctx: GravitoContext<V>) => Response | Promise<Response>;
+/**
+ * Not found handler type
+ */
+type GravitoNotFoundHandler<V extends GravitoVariables = GravitoVariables> = (ctx: GravitoContext<V>) => Response | Promise<Response>;
+
+export type { ContentfulStatusCode as C, GravitoVariables as G, HttpMethod as H, ProxyOptions as P, StatusCode as S, ValidationTarget as V, GravitoHandler as a, GravitoMiddleware as b, GravitoErrorHandler as c, GravitoNotFoundHandler as d, GravitoContext as e, GravitoRequest as f, GravitoNext as g };