@gravito/core 1.6.0 → 1.6.1

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { G as GravitoVariables, H as HttpMethod, a as GravitoHandler, b as GravitoMiddleware, c as GravitoErrorHandler, d as GravitoNotFoundHandler, e as GravitoContext, C as ContentfulStatusCode, P as ProxyOptions, f as GravitoRequest, S as StatusCode } from './compat-C4Src6NN.js';
-export { g as GravitoNext, V as ValidationTarget } from './compat-C4Src6NN.js';
+import { G as GravitoVariables, H as HttpMethod, a as GravitoHandler, b as GravitoMiddleware, c as GravitoErrorHandler, d as GravitoNotFoundHandler, e as GravitoContext, C as ContentfulStatusCode, P as ProxyOptions, f as GravitoRequest, S as StatusCode } from './compat-CI8hiulX.js';
+export { g as GravitoNext, V as ValidationTarget } from './compat-CI8hiulX.js';
+import { ZodSchema } from 'zod';
 import * as _opentelemetry_api from '@opentelemetry/api';
 import { Histogram, Counter, Span, Context, Meter } from '@opentelemetry/api';
 import { Photon, Context as Context$1 } from '@gravito/photon';
@@ -240,6 +241,12 @@ type AdapterFactory<V extends GravitoVariables = GravitoVariables> = (config?: A
  */
 declare function isHttpAdapter(value: unknown): value is HttpAdapter;
 
+/**
+ * Configuration manager (ConfigManager)
+ *
+ * Unifies environment variables and application configuration access.
+ */
+
 /**
  * ConfigManager - Central configuration store.
  * Supports loading from environment variables and initial objects.
@@ -247,6 +254,7 @@ declare function isHttpAdapter(value: unknown): value is HttpAdapter;
  */
 declare class ConfigManager {
     private config;
+    private schema;
     constructor(initialConfig?: Record<string, unknown>);
     /**
      * Load all environment variables from the active runtime.
@@ -265,6 +273,244 @@ declare class ConfigManager {
      * Check whether a key exists.
      */
     has(key: string): boolean;
+    /**
+     * Define a Zod schema for configuration validation.
+     *
+     * @param schema - Zod schema for validation
+     *
+     * @example
+     * ```typescript
+     * config.defineSchema(z.object({
+     *   DATABASE_URL: z.string().url(),
+     *   PORT: z.number().default(3000),
+     * }))
+     * ```
+     */
+    defineSchema(schema: ZodSchema): void;
+    /**
+     * Validate configuration against the defined schema.
+     *
+     * Should be called during bootstrap to catch configuration errors early.
+     *
+     * @throws Error if validation fails with details about missing/invalid fields
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   config.validate()
+     * } catch (error) {
+     *   console.error('Config validation failed:', error.message)
+     *   process.exit(1)
+     * }
+     * ```
+     */
+    validate(): void;
+}
+
+/**
+ * RequestScopeMetrics - Observability for RequestScope lifecycle
+ *
+ * Tracks cleanup execution time, scope size, and service counts
+ * for performance monitoring and diagnostics.
+ *
+ * @example
+ * ```typescript
+ * const metrics = new RequestScopeMetrics()
+ * metrics.recordCleanupStart()
+ * await scope.cleanup()
+ * metrics.recordCleanupEnd()
+ *
+ * console.log(metrics.toJSON())
+ * // { cleanupDuration: 2.5, scopeSize: 3, servicesCleaned: 3 }
+ * ```
+ */
+declare class RequestScopeMetrics {
+    private cleanupStartTime;
+    private cleanupDuration;
+    private scopeSize;
+    private servicesCleaned;
+    private errorsOccurred;
+    /**
+     * Record start of cleanup operation
+     */
+    recordCleanupStart(): void;
+    /**
+     * Record end of cleanup operation
+     *
+     * @param scopeSize - Number of services in the scope
+     * @param servicesCleaned - Number of services that had cleanup called
+     * @param errorsOccurred - Number of cleanup errors
+     */
+    recordCleanupEnd(scopeSize: number, servicesCleaned: number, errorsOccurred?: number): void;
+    /**
+     * Get cleanup duration in milliseconds
+     *
+     * @returns Duration in ms, or null if cleanup not completed
+     */
+    getCleanupDuration(): number | null;
+    /**
+     * Check if cleanup took longer than threshold (default 2ms)
+     * Useful for detecting slow cleanups
+     *
+     * @param thresholdMs - Threshold in milliseconds
+     * @returns True if cleanup exceeded threshold
+     */
+    isSlowCleanup(thresholdMs?: number): boolean;
+    /**
+     * Export metrics as JSON for logging/monitoring
+     */
+    toJSON(): {
+        cleanupDuration: number | null;
+        scopeSize: number;
+        servicesCleaned: number;
+        errorsOccurred: number;
+        hasErrors: boolean;
+        isSlowCleanup: boolean;
+    };
+    /**
+     * Export metrics as compact string for logging
+     */
+    toString(): string;
+}
+/**
+ * RequestScopeObserver - Hook for monitoring RequestScope lifecycle
+ *
+ * Implement this interface to receive callbacks during scope operations
+ */
+interface RequestScopeObserver {
+    /**
+     * Called when a service is resolved in the scope
+     */
+    onServiceResolved?(key: string | symbol, isFromCache: boolean): void;
+    /**
+     * Called when cleanup starts
+     */
+    onCleanupStart?(): void;
+    /**
+     * Called when cleanup completes
+     */
+    onCleanupEnd?(metrics: RequestScopeMetrics): void;
+    /**
+     * Called when cleanup encounters an error
+     */
+    onCleanupError?(error: Error): void;
+}
+/**
+ * RequestScopeMetricsCollector - Aggregates metrics across multiple scopes
+ *
+ * Used for application-level monitoring and performance tracking
+ *
+ * @example
+ * ```typescript
+ * const collector = new RequestScopeMetricsCollector()
+ *
+ * // Record metrics from multiple requests
+ * collector.record(metrics1)
+ * collector.record(metrics2)
+ * collector.record(metrics3)
+ *
+ * // Get aggregated stats
+ * const stats = collector.getStats()
+ * console.log(stats.averageCleanupTime) // 3.5ms
+ * ```
+ */
+declare class RequestScopeMetricsCollector {
+    private metrics;
+    /**
+     * Record metrics from a request scope
+     */
+    record(metrics: RequestScopeMetrics): void;
+    /**
+     * Get aggregated statistics
+     */
+    getStats(): {
+        count: number;
+        averageCleanupTime: number | null;
+        maxCleanupTime: number | null;
+        minCleanupTime: number | null;
+        totalErrorCount: number;
+        errorRate: number;
+    };
+    /**
+     * Clear collected metrics
+     */
+    clear(): void;
+    /**
+     * Get number of recorded metrics
+     */
+    size(): number;
+    /**
+     * Export metrics as JSON array
+     */
+    toJSON(): {
+        cleanupDuration: number | null;
+        scopeSize: number;
+        servicesCleaned: number;
+        errorsOccurred: number;
+        hasErrors: boolean;
+        isSlowCleanup: boolean;
+    }[];
+}
+
+/**
+ * Manages request-scoped service instances within a single HTTP request.
+ *
+ * Each request gets its own RequestScopeManager instance with isolated state.
+ * Services are cached within the request and automatically cleaned up when
+ * the request ends.
+ *
+ * @example
+ * ```typescript
+ * const scope = new RequestScopeManager()
+ * const cache = scope.resolve('productCache', () => new ProductCache())
+ * // ... use cache ...
+ * await scope.cleanup() // Called automatically by Gravito engine
+ * ```
+ */
+declare class RequestScopeManager {
+    private scoped;
+    private metadata;
+    private metrics;
+    private observer;
+    constructor(observer?: RequestScopeObserver);
+    /**
+     * Set observer for monitoring scope lifecycle
+     */
+    setObserver(observer: RequestScopeObserver): void;
+    /**
+     * Get metrics for this scope
+     */
+    getMetrics(): RequestScopeMetrics;
+    /**
+     * Resolve or retrieve a request-scoped service instance.
+     *
+     * If the service already exists in this scope, returns the cached instance.
+     * Otherwise, calls the factory function to create a new instance and caches it.
+     *
+     * Automatically detects and records services with cleanup methods.
+     *
+     * @template T - The type of the service.
+     * @param key - The service key (for caching).
+     * @param factory - Factory function to create the instance if not cached.
+     * @returns The cached or newly created instance.
+     */
+    resolve<T>(key: ServiceKey, factory: () => T): T;
+    /**
+     * Clean up all request-scoped instances.
+     *
+     * Calls the cleanup() method on each service that has one.
+     * Silently ignores cleanup errors to prevent cascading failures.
+     * Called automatically by the Gravito engine in the request finally block.
+     *
+     * @returns Promise that resolves when all cleanup is complete.
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Get the number of services in this scope (for monitoring).
+     *
+     * @returns The count of cached services.
+     */
+    size(): number;
 }
 
 /**
@@ -300,6 +546,27 @@ declare class Container {
     private bindings;
     private instances;
     private resolutionStack;
+    /**
+     * Run a function within a request scope context.
+     *
+     * All service resolutions within the function will use the provided scope,
+     * enabling request-scoped service instances to be properly isolated.
+     *
+     * @template T - The return type of the function.
+     * @param scope - The RequestScopeManager for this request.
+     * @param fn - The function to execute within the scope.
+     * @returns The result of the function.
+     *
+     * @example
+     * ```typescript
+     * const scope = new RequestScopeManager()
+     * const result = await Container.runWithScope(scope, async () => {
+     *   const service = container.make('requestScoped')
+     *   return service.doSomething()
+     * })
+     * ```
+     */
+    static runWithScope<T>(scope: RequestScopeManager, fn: () => T | Promise<T>): T | Promise<T>;
     /**
      * Bind a service to the container.
      *
@@ -332,6 +599,22 @@ declare class Container {
      * ```
      */
     singleton<T>(key: ServiceKey, factory: Factory$1<T>): void;
+    /**
+     * Bind a request-scoped service to the container.
+     *
+     * A new instance will be created for each request and cached within that request.
+     * The service is automatically cleaned up when the request ends.
+     *
+     * @template T - The type of the service being bound.
+     * @param key - The unique identifier for the service.
+     * @param factory - The factory function that creates the service instance.
+     *
+     * @example
+     * ```typescript
+     * container.scoped('requestCache', (c) => new RequestProductCache());
+     * ```
+     */
+    scoped<T>(key: ServiceKey, factory: Factory$1<T>): void;
     /**
      * Register an existing instance as a shared service.
      *
@@ -339,6 +622,13 @@ declare class Container {
      * @param instance - The instance to register.
      */
     instance<T>(key: ServiceKey, instance: T): void;
+    /**
+     * Check if a service is request-scoped.
+     *
+     * @param key - The service key to check.
+     * @returns True if the service is request-scoped.
+     */
+    isRequestScoped(key: ServiceKey): boolean;
     /**
      * Resolve a service instance from the container.
      *
@@ -977,6 +1267,11 @@ declare class HasPersistence {
      * @returns True if the model has been persisted
      */
     get exists(): boolean;
+    /**
+     * Internal helper to retrieve the correct connection depending on sharding configuration
+     * @internal
+     */
+    protected _getConnection(): ConnectionContract;
     /**
      * Save the model instance to the database (insert or update).
      *
@@ -1580,11 +1875,19 @@ declare abstract class Model$1 {
      * @yields Chunks of model instances.
      */
     static cursor<T extends Model$1>(this: ModelConstructor$1<T> & typeof Model$1, chunkSize?: number): AsyncGenerator<T[], void, unknown>;
+    /**
+     * Initializes a fluent query builder for the model on a specific sharded connection.
+     *
+     * @param key - The shard distribution key
+     * @returns A proxied query builder instance connected to the right shard.
+     */
+    static shard<T extends Model$1>(this: ModelConstructor$1<T> & typeof Model$1, key: string | number): QueryBuilderContract<T>;
     /**
      * Initializes a fluent query builder for the model.
      *
      * Automatically handles model hydration, soft delete filtering, and scope application.
      *
+     * @param connectionContract - Optional specific database connection
      * @returns A proxied query builder instance.
      *
      * @example
@@ -1592,7 +1895,7 @@ declare abstract class Model$1 {
      * const users = await User.query().where('active', true).get();
      * ```
      */
-    static query<T extends Model$1>(this: ModelConstructor$1<T> & typeof Model$1): QueryBuilderContract<T>;
+    static query<T extends Model$1>(this: ModelConstructor$1<T> & typeof Model$1, connectionContract?: ConnectionContract): QueryBuilderContract<T>;
     /**
      * Starts a query with a standard WHERE clause.
      *
@@ -1664,9 +1967,31 @@ interface AtlasMetricsConfig {
 declare class AtlasMetrics {
     private meter;
     private config;
+    private poolCallbacks;
     readonly operationDuration?: Histogram;
     readonly operationErrors?: Counter;
+    readonly poolSize?: any;
+    readonly poolUtilization?: any;
+    readonly poolWaitTime?: Histogram;
+    readonly poolAcquisitionErrors?: Counter;
     constructor(config: AtlasMetricsConfig);
+    /**
+     * Register pool statistics callback for ObservableGauge
+     */
+    registerPoolStatsCallback(connectionName: string, getStats: () => {
+        idle: number;
+        active: number;
+        pending: number;
+        max: number;
+    } | null): void;
+    /**
+     * Record connection wait time
+     */
+    recordConnectionWaitTime(connectionName: string, duration: number): void;
+    /**
+     * Record connection acquisition error
+     */
+    recordConnectionAcquisitionError(connectionName: string, error: string): void;
 }
 
 interface AtlasTracingConfig {
@@ -2156,6 +2481,27 @@ interface PoolStats {
      */
     max: number;
 }
+/**
+ * Connection pool health status
+ */
+interface PoolHealth {
+    /**
+     * Health status: 'healthy' | 'warning' | 'critical' | 'disconnected'
+     */
+    status: 'healthy' | 'warning' | 'critical' | 'disconnected';
+    /**
+     * Human-readable health message
+     */
+    message: string;
+    /**
+     * Pool statistics (when available)
+     */
+    stats?: PoolStats;
+    /**
+     * Last health check timestamp
+     */
+    lastCheck?: Date;
+}
 /**
  * Model base class (forward declaration)
  * Actual implementation in src/orm/model/Model.ts
@@ -2243,6 +2589,18 @@ interface DriverContract {
      * @returns Pool statistics or null if not supported
      */
     getPoolStats?(): PoolStats | null;
+    /**
+     * Get connection pool health status
+     * @optional Only implemented by drivers that support connection pooling
+     * @returns Pool health information
+     */
+    getPoolHealth?(): PoolHealth;
+    /**
+     * Adjust the connection pool size dynamically
+     * @optional Only implemented by drivers that support pool resizing
+     * @param targetSize - Target number of connections
+     */
+    adjustPoolSize?(targetSize: number): Promise<void>;
 }
 /**
  * Connection Contract
@@ -2771,12 +3129,50 @@ interface EventOptions {
     async?: boolean;
     /**
      * Priority level for event processing.
-     * - 'high': Critical events (e.g., order:created, payment:succeeded)
-     * - 'normal': Standard events (e.g., order:confirmed)
-     * - 'low': Non-critical events (e.g., analytics, logging)
+     * - 'critical': Immediate processing, bypass queue (< 1ms)
+     * - 'high': High priority events (< 50ms)
+     * - 'normal': Standard events (< 200ms)
+     * - 'low': Non-critical events (< 500ms)
      * @default 'normal'
      */
-    priority?: 'high' | 'normal' | 'low';
+    priority?: 'critical' | 'high' | 'normal' | 'low';
+    /**
+     * Automatic priority escalation configuration.
+     * Events can be automatically upgraded to higher priority based on wait time.
+     */
+    escalation?: {
+        /**
+         * Whether to enable automatic priority escalation.
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * Escalation thresholds in milliseconds.
+         * Events exceeding these wait times are promoted.
+         */
+        thresholds?: {
+            /**
+             * Wait time before LOW events are promoted to NORMAL.
+             * @default 200
+             */
+            lowToNormal?: number;
+            /**
+             * Wait time before NORMAL events are promoted to HIGH.
+             * @default 100
+             */
+            normalToHigh?: number;
+            /**
+             * Wait time before HIGH events are promoted to CRITICAL.
+             * @default 50
+             */
+            highToCritical?: number;
+        };
+        /**
+         * Maximum wait time before forcing CRITICAL priority.
+         * @default 500
+         */
+        maxWaitTimeMs?: number;
+    };
     /**
      * Execution timeout in milliseconds.
      * If a listener exceeds this timeout, it will be terminated.
@@ -2862,6 +3258,63 @@ interface EventOptions {
          */
         halfOpenRequests?: number;
     };
+    /**
+     * Event aggregation configuration (FS-102).
+     * Enables deduplication and micro-batching for improved throughput.
+     * @default undefined (disabled)
+     */
+    aggregation?: {
+        /**
+         * Enable event aggregation.
+         * @default false
+         */
+        enabled?: boolean;
+        /**
+         * Aggregation window size in milliseconds.
+         * Backpressure-aware adjustment: 50-500ms
+         * @default 200
+         */
+        windowMs?: number;
+        /**
+         * Batch size threshold for auto-flush.
+         * @default 50
+         */
+        batchSize?: number;
+        /**
+         * Deduplication strategy.
+         * @default 'pattern'
+         */
+        deduplication?: 'pattern' | 'idempotencyKey' | 'off';
+        /**
+         * Deduplication pattern (string or function).
+         * String: hook-based pattern
+         * Function: custom pattern from event args
+         */
+        pattern?: string | ((args: unknown) => string);
+        /**
+         * Priority merge strategy.
+         * - 'highest': keep highest priority event
+         * - 'earliest': keep earliest event
+         * - 'latest': keep latest event
+         * @default 'highest'
+         */
+        mergePriority?: 'highest' | 'earliest' | 'latest';
+        /**
+         * Enable automatic cleanup of expired entries.
+         * @default true
+         */
+        enableCleanup?: boolean;
+        /**
+         * Cleanup interval in milliseconds.
+         * @default 300000 (5 minutes)
+         */
+        cleanupIntervalMs?: number;
+        /**
+         * TTL for entries in milliseconds.
+         * @default 600000 (10 minutes)
+         */
+        ttlMs?: number;
+    };
 }
 /**
  * Default event options.
@@ -3400,54 +3853,421 @@ declare class DeadLetterQueueManager {
      * ```
      */
     clear(includeResolved?: boolean): Promise<number>;
+    /**
+     * 通過 Bull Job ID 查找 DLQ 記錄
+     *
+     * 用於 MessageQueueBridge 集成：當 Bull Queue job 失敗時，
+     * 通過 Job ID 查找相應的 DLQ 記錄。
+     *
+     * @param bullJobId - Bull Queue Job ID
+     * @returns DLQ 記錄或 undefined
+     *
+     * @example
+     * ```typescript
+     * const record = await dlqManager.findByBullJobId('job-abc123')
+     * if (record) {
+     *   console.log(`Event ${record.event_name} is in DLQ`)
+     * }
+     * ```
+     */
+    findByBullJobId(bullJobId: string): Promise<DLQRecord | undefined>;
+    /**
+     * 調度延遲重試（整合 Bull Queue delayed jobs）
+     *
+     * 從 DLQ 中提取事件，通過 Bull Queue 的延遲 job 功能進行重試。
+     *
+     * @param dlqId - DLQ 記錄 ID
+     * @param delayMs - 延遲時間（毫秒）
+     * @throws 如果記錄不存在
+     *
+     * @example
+     * ```typescript
+     * // 延遲 1 小時後重試
+     * await dlqManager.scheduleRetry('dlq-uuid-123', 3600000)
+     * ```
+     */
+    scheduleRetry(dlqId: string, delayMs: number): Promise<void>;
 }
 
 /**
- * Circuit Breaker state enum.
- * @public
- */
-declare enum CircuitBreakerState {
-    CLOSED = "CLOSED",
-    OPEN = "OPEN",
-    HALF_OPEN = "HALF_OPEN"
-}
-/**
- * Circuit Breaker metrics snapshot.
- * @public
+ * Event task for priority queue processing.
+ * @internal
  */
-interface CircuitBreakerMetrics {
+interface EventTask {
     /**
-     * Current state of the circuit breaker
+     * Unique identifier for this event task.
      */
-    state: CircuitBreakerState;
+    id: string;
     /**
-     * Number of failures in the current window
+     * Event hook name.
      */
-    failures: number;
+    hook: string;
     /**
-     * Number of successes in the current window
+     * Event payload/arguments.
      */
-    successes: number;
+    args: unknown;
     /**
-     * Timestamp of the last failure
+     * Event options.
      */
-    lastFailureAt?: Date;
+    options: EventOptions;
     /**
-     * Timestamp of the last success
+     * Callbacks to execute for this event.
      */
-    lastSuccessAt?: Date;
+    callbacks: ActionCallback[];
     /**
-     * Timestamp when the circuit was opened
+     * Timestamp when the event was created.
      */
-    openedAt?: Date;
+    createdAt: number;
     /**
-     * Total requests processed
+     * Timestamp when the event was enqueued (added to the queue).
+     * Used for priority escalation calculations.
+     * @internal
      */
-    totalRequests: number;
+    enqueuedAt: number;
     /**
-     * Total failures recorded
+     * Partition key for ordering (if applicable).
      */
-    totalFailures: number;
+    partitionKey?: string;
+    /**
+     * Number of retry attempts made.
+     * @internal
+     */
+    retryCount?: number;
+    /**
+     * Timestamp when the event first failed.
+     * @internal
+     */
+    firstFailedAt?: number;
+    /**
+     * Last error encountered.
+     * @internal
+     */
+    lastError?: Error;
+}
+/**
+ * Strategy for handling backpressure when the queue is full.
+ */
+type BackpressureStrategy = 'reject' | 'drop-oldest' | 'drop-newest' | 'ignore';
+/**
+ * Configuration for the event priority queue.
+ */
+interface EventQueueConfig {
+    /**
+     * Maximum number of pending events in the queue.
+     * If exceeded, the backpressure strategy is applied.
+     * @default undefined (unbounded)
+     */
+    maxSize?: number;
+    /**
+     * Strategy to use when the queue is full.
+     * - 'reject': Throw an error (default)
+     * - 'drop-oldest': Drop the oldest lowest-priority event
+     * - 'drop-newest': Drop the incoming event
+     * - 'ignore': Silently drop the incoming event
+     * @default 'reject'
+     */
+    strategy?: BackpressureStrategy;
+    /**
+     * Advanced backpressure management configuration.
+     * When enabled, provides state-based flow control with multi-strategy support.
+     * If not provided, falls back to simple strategy-based backpressure.
+     * @default undefined (disabled, uses simple strategy)
+     */
+    backpressure?: BackpressureConfig;
+}
+/**
+ * Multi-priority queue depth snapshot (FS-103)
+ * Represents the current queue depth for each priority level.
+ * @internal
+ */
+interface MultiPriorityQueueDepth {
+    /** Queue depth for CRITICAL priority events */
+    critical: number;
+    /** Queue depth for HIGH priority events */
+    high: number;
+    /** Queue depth for NORMAL priority events */
+    normal: number;
+    /** Queue depth for LOW priority events */
+    low: number;
+    /** Total queue depth across all priorities */
+    total: number;
+}
+/**
+ * Dead letter queue routing decision (FS-103)
+ * Determines whether an event should be routed to the DLQ.
+ * @internal
+ */
+interface DeadLetterDecision {
+    /** Whether the event should be routed to DLQ */
+    shouldRoute: boolean;
+    /** Reason for the decision (if applicable) */
+    reason?: string;
+    /** Suggested retry strategy */
+    retryStrategy?: 'immediate' | 'delayed' | 'dlq-only';
+}
+
+/**
+ * @gravito/core - Event System Backpressure Management
+ *
+ * Implements a backpressure management system to prevent high-priority events
+ * from starving low-priority events when the queue is under resource constraints.
+ *
+ * 背壓管理器：在資源受限時進行智慧型流量控制，防止優先級飢餓。
+ *
+ * FS-103 增強：
+ * - 多優先級隊列深度監控
+ * - 背壓反饋迴路支持
+ * - 智能 DLQ 路由決策
+ */
+
+/**
+ * 背壓狀態枚舉。
+ *
+ * 狀態轉換：Normal → Warning → Critical → Overflow
+ * 恢復方向：遲滯設計（需降至觸發閾值的 80%）
+ *
+ * @public
+ */
+declare enum BackpressureState {
+    /** 正常運作，無背壓 */
+    NORMAL = "NORMAL",
+    /** 警告狀態，開始限制低優先級事件 */
+    WARNING = "WARNING",
+    /** 危急狀態，僅允許高優先級事件 */
+    CRITICAL = "CRITICAL",
+    /** 溢位狀態，全部拒絕 */
+    OVERFLOW = "OVERFLOW"
+}
+/**
+ * 背壓配置選項。
+ *
+ * @public
+ */
+interface BackpressureConfig {
+    /** 是否啟用背壓管理器（預設 true） */
+    enabled?: boolean;
+    /** 總隊列深度限制（預設無限） */
+    maxQueueSize?: number;
+    /** 分優先級隊列深度限制 */
+    maxSizeByPriority?: {
+        critical?: number;
+        high?: number;
+        normal?: number;
+        low?: number;
+    };
+    /** 每秒最大入隊速率（events/sec，預設無限） */
+    maxEnqueueRate?: number;
+    /** 速率限制滑動視窗大小（ms，預設 1000） */
+    rateLimitWindowMs?: number;
+    /** 背壓狀態閾值（佔 maxQueueSize 的百分比） */
+    thresholds?: {
+        /** WARNING 觸發百分比（預設 0.6 = 60%） */
+        warning?: number;
+        /** CRITICAL 觸發百分比（預設 0.85 = 85%） */
+        critical?: number;
+        /** OVERFLOW 觸發百分比（預設 1.0 = 100%） */
+        overflow?: number;
+    };
+    /** 被拒絕事件的處理策略（預設 'drop-with-callback'） */
+    rejectionPolicy?: 'throw' | 'drop-silent' | 'drop-with-callback';
+    /** 當 rejectionPolicy 為 'drop-with-callback' 時的回呼 */
+    onRejected?: (eventName: string, priority: string, reason: string) => void;
+    /** 背壓狀態變更回呼 */
+    onStateChange?: (from: BackpressureState, to: BackpressureState) => void;
+    /** 低優先級事件在 WARNING 狀態下的延遲入隊時間（ms，預設 100） */
+    lowPriorityDelayMs?: number;
+    /** 是否啟用優先級反轉防護（預設 true） */
+    enableStarvationProtection?: boolean;
+    /** 低優先級事件最大等待時間，超過則提升優先級（ms，預設 5000） */
+    starvationTimeoutMs?: number;
+    /** 當進入 OVERFLOW 狀態時，是否將被拒絕事件路由到 DLQ（預設 false） */
+    dlqOnOverflow?: boolean;
+    /** OVERFLOW 時的重試策略（預設 'dlq-only'） */
+    overflowRetryStrategy?: 'immediate' | 'delayed' | 'dlq-only';
+    /** OVERFLOW 延遲重試的基礎延遲時間（ms，預設 5000） */
+    overflowRetryDelayMs?: number;
+}
+/**
+ * 背壓決策結果。
+ *
+ * @public
+ */
+interface BackpressureDecision {
+    /** 是否允許入隊 */
+    allowed: boolean;
+    /** 拒絕原因（若不允許） */
+    reason?: string;
+    /** 是否需要延遲入隊 */
+    delayed?: boolean;
+    /** 延遲時間（ms） */
+    delayMs?: number;
+    /** 建議降級後的優先級（若降級） */
+    degradedPriority?: 'high' | 'normal' | 'low';
+    /** 是否是由於 OVERFLOW 狀態被拒絕 */
+    isOverflow?: boolean;
+    /** OVERFLOW 時的重試策略建議（'immediate'、'delayed'、'dlq-only'） */
+    retryStrategy?: 'immediate' | 'delayed' | 'dlq-only';
+}
+/**
+ * 背壓指標快照。
+ *
+ * @public
+ */
+interface BackpressureMetricsSnapshot {
+    state: BackpressureState;
+    totalDepth: number;
+    depthByPriority: {
+        critical: number;
+        high: number;
+        normal: number;
+        low: number;
+    };
+    enqueueRate: number;
+    rejectedCount: number;
+    degradedCount: number;
+    stateTransitions: number;
+    dlqRouteCount?: number;
+    windowAdjustmentCount?: number;
+}
+/**
+ * 背壓管理器。
+ *
+ * 根據隊列深度、速率、優先級等因素，決定是否允許新事件入隊，
+ * 以及是否需要降級優先級或延遲入隊。
+ *
+ * @public
+ */
+declare class BackpressureManager {
+    private enabled;
+    private config;
+    private onRejected?;
+    private onStateChange?;
+    private state;
+    private rejectedCount;
+    private degradedCount;
+    private stateTransitions;
+    private rateCounter;
+    private depthByPriority;
+    private windowAdjustmentHistory;
+    private dlqRouteCount;
+    constructor(config?: BackpressureConfig);
+    /**
+     * 評估是否允許新事件入隊。
+     *
+     * @param eventName 事件名稱
+     * @param priority 事件優先級
+     * @param queueDepth 當前隊列深度
+     * @param depthByPriority 分優先級隊列深度
+     * @returns 背壓決策結果
+     */
+    evaluate(eventName: string, priority: 'critical' | 'high' | 'normal' | 'low', queueDepth: number, depthByPriority: {
+        critical: number;
+        high: number;
+        normal: number;
+        low: number;
+    }): BackpressureDecision;
+    /**
+     * 獲取當前背壓狀態。
+     */
+    getState(): BackpressureState;
+    /**
+     * 獲取背壓指標快照。
+     */
+    getMetrics(): BackpressureMetricsSnapshot;
+    /**
+     * 重置背壓管理器狀態。
+     */
+    reset(): void;
+    /**
+     * 同步隊列深度（由 EventPriorityQueue 調用）。
+     * FS-103：多優先級隊列深度監控
+     */
+    updateQueueDepth(depths: MultiPriorityQueueDepth): void;
+    /**
+     * 獲取各優先級的隊列深度。
+     * FS-103：提供實時隊列深度快照
+     */
+    getQueueDepthByPriority(): MultiPriorityQueueDepth;
+    /**
+     * 獲取總隊列深度。
+     */
+    getTotalQueueDepth(): number;
+    /**
+     * 接收來自 AggregationWindow 的窗口調整通知。
+     * FS-103：背壓反饋迴路
+     */
+    notifyWindowAdjustment(oldWindowMs: number, newWindowMs: number): void;
+    /**
+     * 檢查是否可以從 CRITICAL 或更高級別降級。
+     * FS-103：自動狀態恢復機制
+     */
+    private checkStateRecovery;
+    /**
+     * 決定是否應該將事件路由到死信隊列。
+     * FS-103：智能 DLQ 路由決策
+     */
+    makeDeadLetterDecision(_eventName: string, priority: 'critical' | 'high' | 'normal' | 'low'): DeadLetterDecision;
+    /**
+     * 更新背壓狀態。
+     * 使用遲滯設計（80% 回復比例）避免邊界震盪。
+     */
+    private updateState;
+    /**
+     * 執行狀態轉換。
+     */
+    private transitionTo;
+    /**
+     * 建立決策結果並記錄拒絕。
+     */
+    private createDecision;
+}
+
+/**
+ * Circuit Breaker state enum.
+ * @public
+ */
+declare enum CircuitBreakerState {
+    CLOSED = "CLOSED",
+    OPEN = "OPEN",
+    HALF_OPEN = "HALF_OPEN"
+}
+/**
+ * Circuit Breaker metrics snapshot.
+ * @public
+ */
+interface CircuitBreakerMetrics {
+    /**
+     * Current state of the circuit breaker
+     */
+    state: CircuitBreakerState;
+    /**
+     * Number of failures in the current window
+     */
+    failures: number;
+    /**
+     * Number of successes in the current window
+     */
+    successes: number;
+    /**
+     * Timestamp of the last failure
+     */
+    lastFailureAt?: Date;
+    /**
+     * Timestamp of the last success
+     */
+    lastSuccessAt?: Date;
+    /**
+     * Timestamp when the circuit was opened
+     */
+    openedAt?: Date;
+    /**
+     * Total requests processed
+     */
+    totalRequests: number;
+    /**
+     * Total failures recorded
+     */
+    totalFailures: number;
     /**
      * Total successes recorded
      */
@@ -3625,6 +4445,11 @@ declare class CircuitBreaker {
     private stateToNumber;
 }
 
+/**
+ * Source of DLQ entry - reason why event entered the DLQ.
+ * @public
+ */
+type DLQEntrySource = 'retry_exhausted' | 'circuit_breaker' | 'backpressure_overflow' | 'manual';
 /**
  * Dead Letter Queue entry representing a failed event.
  * @public
@@ -3670,6 +4495,10 @@ interface DLQEntry {
      * Timestamp when the event was last retried (if any).
      */
     lastRetriedAt?: number;
+    /**
+     * Source of the DLQ entry - reason why event entered the DLQ.
+     */
+    source: DLQEntrySource;
 }
 /**
  * Filter options for querying DLQ entries.
@@ -3693,6 +4522,11 @@ interface DLQFilter {
      */
     limit?: number;
 }
+/**
+ * Callback type for DLQ entry events.
+ * @public
+ */
+type DLQEntryCallback = (entry: DLQEntry) => void;
 /**
  * Dead Letter Queue Manager for handling failed events.
  *
@@ -3704,6 +4538,15 @@ interface DLQFilter {
 declare class DeadLetterQueue {
     private entries;
     private entryIdCounter;
+    private maxEntries?;
+    private onEntryAdded?;
+    private onEntryRemoved?;
+    /**
+     * Create a new DeadLetterQueue instance.
+     *
+     * @param maxEntries - Maximum number of entries to keep (optional, no limit if not set)
+     */
+    constructor(maxEntries?: number);
     /**
      * Add a failed event to the Dead Letter Queue.
      *
@@ -3713,9 +4556,10 @@ declare class DeadLetterQueue {
      * @param error - Error that caused the failure
      * @param retryCount - Number of retry attempts made
      * @param firstFailedAt - Timestamp of first failure
+     * @param source - Source of the DLQ entry (default: 'retry_exhausted')
      * @returns DLQ entry ID
      */
-    add(eventName: string, payload: unknown, options: EventOptions, error: Error, retryCount: number, firstFailedAt: number): string;
+    add(eventName: string, payload: unknown, options: EventOptions, error: Error, retryCount: number, firstFailedAt: number, source?: DLQEntrySource): string;
     /**
      * Get a specific DLQ entry by ID.
      *
@@ -3768,80 +4612,56 @@ declare class DeadLetterQueue {
      * @internal
      */
     updateLastRetried(entryId: string): void;
-}
-
-/**
- * Event task for priority queue processing.
- * @internal
- */
-interface EventTask {
-    /**
-     * Unique identifier for this event task.
-     */
-    id: string;
-    /**
-     * Event hook name.
-     */
-    hook: string;
-    /**
-     * Event payload/arguments.
-     */
-    args: unknown;
-    /**
-     * Event options.
-     */
-    options: EventOptions;
     /**
-     * Callbacks to execute for this event.
+     * Evict the oldest entry from the DLQ.
+     * Used when capacity limit is reached.
+     *
+     * @private
      */
-    callbacks: ActionCallback[];
+    private evictOldest;
     /**
-     * Timestamp when the event was created.
+     * Get the oldest entry in the DLQ.
+     *
+     * @returns Oldest DLQ entry or undefined if empty
      */
-    createdAt: number;
+    getOldestEntry(): DLQEntry | undefined;
     /**
-     * Partition key for ordering (if applicable).
+     * Get the newest entry in the DLQ.
+     *
+     * @returns Newest DLQ entry or undefined if empty
      */
-    partitionKey?: string;
+    getNewestEntry(): DLQEntry | undefined;
     /**
-     * Number of retry attempts made.
-     * @internal
+     * Get all entries grouped by source.
+     *
+     * @param source - Source to filter by
+     * @returns Array of entries matching the source
      */
-    retryCount?: number;
+    getEntriesBySource(source: DLQEntrySource): DLQEntry[];
     /**
-     * Timestamp when the event first failed.
-     * @internal
+     * Set callback for when an entry is added to the DLQ.
+     *
+     * @param callback - Callback function or undefined to clear
      */
-    firstFailedAt?: number;
+    setOnEntryAdded(callback?: DLQEntryCallback): void;
     /**
-     * Last error encountered.
-     * @internal
+     * Set callback for when an entry is removed from the DLQ.
+     *
+     * @param callback - Callback function or undefined to clear
      */
-    lastError?: Error;
-}
-/**
- * Strategy for handling backpressure when the queue is full.
- */
-type BackpressureStrategy = 'reject' | 'drop-oldest' | 'drop-newest' | 'ignore';
-/**
- * Configuration for the event priority queue.
- */
-interface EventQueueConfig {
+    setOnEntryRemoved(callback?: DLQEntryCallback): void;
     /**
-     * Maximum number of pending events in the queue.
-     * If exceeded, the backpressure strategy is applied.
-     * @default undefined (unbounded)
+     * Get the maximum number of entries allowed in the DLQ.
+     *
+     * @returns Max entries limit or undefined if no limit
      */
-    maxSize?: number;
+    getMaxEntries(): number | undefined;
     /**
-     * Strategy to use when the queue is full.
-     * - 'reject': Throw an error (default)
-     * - 'drop-oldest': Drop the oldest lowest-priority event
-     * - 'drop-newest': Drop the incoming event
-     * - 'ignore': Silently drop the incoming event
-     * @default 'reject'
+     * Set the maximum number of entries allowed in the DLQ.
+     *
+     * @param maxEntries - Maximum entries or undefined to remove limit
      */
-    strategy?: BackpressureStrategy;
+    setMaxEntries(maxEntries?: number): void;
 }
 
 /**
@@ -3851,8 +4671,9 @@ interface EventBackend {
     /**
      * Enqueue an event for processing.
      * @param task - The event task to process
+     * @returns Task ID or 'dropped' if event was rejected (can be async for some backends)
      */
-    enqueue(task: EventTask): Promise<void> | void;
+    enqueue(task: EventTask): string | Promise<void>;
 }
 
 interface EventMetricGauge {
@@ -4151,28 +4972,770 @@ declare class EventTracing {
 declare function getEventTracing(config?: EventTracingConfig): EventTracing;
 
 /**
- * Priority queue for event processing.
- * Events are processed based on their priority level:
- * - High priority events are processed first
- * - Normal priority events are processed second
- * - Low priority events are processed last
+ * @gravito/core - OpenTelemetry Event Metrics
  *
- * @internal
+ * Provides event system metrics using OpenTelemetry API directly.
+ * This enables Prometheus export without requiring @gravito/monitor dependency.
+ *
+ * Metrics:
+ * - gravito_event_dispatch_duration_seconds (Histogram)
+ * - gravito_event_listener_duration_seconds (Histogram)
+ * - gravito_event_queue_depth (Observable Gauge)
+ *
+ * @packageDocumentation
  */
-declare class EventPriorityQueue implements EventBackend {
-    private highPriority;
-    private normalPriority;
-    private lowPriority;
-    private processing;
-    private taskIdCounter;
+
+/**
+ * Queue depth callback type.
+ * Returns the current queue depths for each priority level.
+ */
+type QueueDepthCallback = () => {
+    critical: number;
+    high: number;
+    normal: number;
+    low: number;
+};
+/**
+ * Circuit breaker state callback type.
+ * Returns the current state of a circuit breaker.
+ */
+type CircuitBreakerStateCallback = () => {
+    eventName: string;
+    listenerIndex: number;
+    state: 0 | 1 | 2;
+};
+/**
+ * OpenTelemetry-based Event Metrics collector.
+ *
+ * Uses OpenTelemetry API directly for metrics collection, enabling
+ * Prometheus export through the OpenTelemetry SDK.
+ *
+ * @example
+ * ```typescript
+ * import { metrics } from '@opentelemetry/api'
+ * import { OTelEventMetrics } from '@gravito/core'
+ *
+ * const meter = metrics.getMeter('@gravito/core', '1.0.0')
+ * const eventMetrics = new OTelEventMetrics(meter)
+ *
+ * // Record dispatch duration
+ * eventMetrics.recordDispatchDuration('order:created', 'high', 0.123)
+ *
+ * // Record listener duration
+ * eventMetrics.recordListenerDuration('order:created', 0, 0.456)
+ *
+ * // Set queue depth callback
+ * eventMetrics.setQueueDepthCallback(() => ({
+ *   high: 10,
+ *   normal: 50,
+ *   low: 100
+ * }))
+ * ```
+ *
+ * @public
+ */
+declare class OTelEventMetrics implements CircuitBreakerMetricsRecorder {
+    private readonly meter;
+    private readonly prefix;
+    private readonly dispatchDurationHistogram;
+    private readonly listenerDurationHistogram;
+    private readonly queueDepthGauge;
+    private readonly cbStateGauge;
+    private readonly cbFailuresCounter;
+    private readonly cbSuccessesCounter;
+    private readonly cbTransitionsCounter;
+    private readonly cbOpenDurationHistogram;
+    private readonly backpressureRejectionsCounter;
+    private readonly backpressureStateGauge;
+    private readonly backpressureDegradationsCounter;
+    private backpressureStateValue;
+    private readonly dlqEntriesCounter;
+    private readonly dlqDepthGauge;
+    private readonly dlqRequeueCounter;
+    private readonly retryAttemptsCounter;
+    private dlqDepthCallback?;
+    private readonly priorityEscalationCounter;
+    private queueDepthCallback?;
+    private circuitBreakerStateCallbacks;
+    private recordedCircuitBreakerStates;
+    /**
+     * Bucket boundaries for dispatch duration histogram.
+     */
+    private readonly dispatchDurationBuckets;
+    /**
+     * Bucket boundaries for listener duration histogram.
+     */
+    private readonly listenerDurationBuckets;
+    /**
+     * Bucket boundaries for circuit breaker open duration histogram.
+     */
+    private readonly cbOpenDurationBuckets;
+    /**
+     * Create a new OTelEventMetrics instance.
+     *
+     * @param meter - OpenTelemetry Meter instance
+     * @param prefix - Metric name prefix (default: 'gravito_event_')
+     */
+    constructor(meter: Meter, prefix?: string);
+    /**
+     * Record event dispatch duration.
+     *
+     * @param eventName - Name of the event
+     * @param priority - Priority level (high, normal, low)
+     * @param durationSeconds - Duration in seconds
+     */
+    recordDispatchDuration(eventName: string, priority: string, durationSeconds: number): void;
+    /**
+     * Record listener execution duration.
+     *
+     * @param eventName - Name of the event
+     * @param listenerIndex - Index of the listener in the callback list
+     * @param durationSeconds - Duration in seconds
+     */
+    recordListenerDuration(eventName: string, listenerIndex: number, durationSeconds: number): void;
+    /**
+     * Set the callback for queue depth observable gauge.
+     *
+     * The callback will be invoked when metrics are collected,
+     * allowing real-time reporting of queue depths.
+     *
+     * @param callback - Function returning current queue depths
+     */
+    setQueueDepthCallback(callback: QueueDepthCallback): void;
+    /**
+     * Register a circuit breaker state callback for monitoring.
+     *
+     * @param key - Unique identifier for the circuit breaker (e.g., "order:created-0")
+     * @param callback - Function returning current circuit breaker state
+     */
+    registerCircuitBreakerStateCallback(key: string, callback: CircuitBreakerStateCallback): void;
+    /**
+     * Unregister a circuit breaker state callback.
+     *
+     * @param key - Unique identifier for the circuit breaker
+     */
+    unregisterCircuitBreakerStateCallback(key: string): void;
+    /**
+     * Record circuit breaker state change.
+     *
+     * @param name - Name of the circuit breaker (usually event name)
+     * @param state - State as number (0=CLOSED, 1=HALF_OPEN, 2=OPEN)
+     */
+    recordState(name: string, state: number): void;
+    /**
+     * Record circuit breaker state transition.
+     *
+     * @param name - Name of the circuit breaker
+     * @param fromState - Previous state
+     * @param toState - New state
+     */
+    recordTransition(name: string, fromState: string, toState: string): void;
+    /**
+     * Record circuit breaker failure.
+     *
+     * @param name - Name of the circuit breaker
+     */
+    recordFailure(name: string): void;
+    /**
+     * Record circuit breaker success.
+     *
+     * @param name - Name of the circuit breaker
+     */
+    recordSuccess(name: string): void;
+    /**
+     * Record circuit breaker open duration.
+     *
+     * @param name - Name of the circuit breaker
+     * @param seconds - Duration in seconds
+     */
+    recordOpenDuration(name: string, seconds: number): void;
+    /**
+     * Record circuit breaker failure.
+     *
+     * @param eventName - Name of the event
+     * @param listenerIndex - Index of the listener
+     */
+    recordCircuitBreakerFailure(eventName: string, listenerIndex: number): void;
+    /**
+     * Record circuit breaker success.
+     *
+     * @param eventName - Name of the event
+     * @param listenerIndex - Index of the listener
+     */
+    recordCircuitBreakerSuccess(eventName: string, listenerIndex: number): void;
+    /**
+     * Record circuit breaker state transition.
+     *
+     * @param eventName - Name of the event
+     * @param listenerIndex - Index of the listener
+     * @param fromState - Previous state (CLOSED, HALF_OPEN, OPEN)
+     * @param toState - New state (CLOSED, HALF_OPEN, OPEN)
+     */
+    recordCircuitBreakerTransition(eventName: string, listenerIndex: number, fromState: string, toState: string): void;
+    /**
+     * Record circuit breaker open duration.
+     *
+     * @param eventName - Name of the event
+     * @param listenerIndex - Index of the listener
+     * @param durationSeconds - Duration in seconds
+     */
+    recordCircuitBreakerOpenDuration(eventName: string, listenerIndex: number, durationSeconds: number): void;
+    /**
+     * Get the bucket boundaries for dispatch duration histogram.
+     *
+     * @returns Array of bucket boundaries in seconds
+     */
+    getDispatchDurationBuckets(): number[];
+    /**
+     * Get the bucket boundaries for listener duration histogram.
+     *
+     * @returns Array of bucket boundaries in seconds
+     */
+    getListenerDurationBuckets(): number[];
+    /**
+     * Get the OpenTelemetry Meter instance.
+     *
+     * @returns Meter instance
+     */
+    getMeter(): Meter;
+    /**
+     * Get the metric name prefix.
+     *
+     * @returns Metric name prefix
+     */
+    getPrefix(): string;
+    /**
+     * Get the bucket boundaries for circuit breaker open duration histogram.
+     *
+     * @returns Array of bucket boundaries in seconds
+     */
+    getCircuitBreakerOpenDurationBuckets(): number[];
+    /**
+     * Get all registered circuit breaker state callback keys.
+     *
+     * @returns Array of registered keys
+     */
+    getRegisteredCircuitBreakers(): string[];
+    /**
+     * Clear all circuit breaker state callbacks.
+     */
+    clearCircuitBreakerCallbacks(): void;
+    /**
+     * Record a backpressure rejection event.
+     *
+     * @param eventName - Event name
+     * @param priority - Event priority
+     * @param reason - Rejection reason
+     */
+    recordBackpressureRejection(eventName: string, priority: string, reason: string): void;
+    /**
+     * Record a backpressure state change event.
+     *
+     * @param state - New backpressure state (NORMAL, WARNING, CRITICAL, OVERFLOW)
+     */
+    recordBackpressureState(state: string): void;
+    /**
+     * Record a backpressure degradation event.
+     *
+     * @param eventName - Event name
+     * @param fromPriority - Original priority
+     * @param toPriority - Degraded priority
+     */
+    recordBackpressureDegradation(eventName: string, fromPriority: string, toPriority: string): void;
+    /**
+     * Record an event added to Dead Letter Queue.
+     *
+     * @param eventName - Event name
+     * @param source - Source of DLQ entry (retry_exhausted, circuit_breaker, backpressure_overflow)
+     */
+    recordDLQEntry(eventName: string, source: string): void;
+    /**
+     * Set the callback for DLQ depth observable gauge.
+     *
+     * @param callback - Function returning current DLQ depth
+     */
+    setDLQDepthCallback(callback: () => number): void;
+    /**
+     * Record a DLQ requeue attempt.
+     *
+     * @param eventName - Event name
+     * @param result - Result of requeue (success or failure)
+     */
+    recordDLQRequeue(eventName: string, result: 'success' | 'failure'): void;
+    /**
+     * Record an event retry attempt.
+     *
+     * @param eventName - Event name
+     * @param attemptNumber - Attempt number
+     */
+    recordRetryAttempt(eventName: string, attemptNumber: number): void;
+    /**
+     * Record a priority escalation event.
+     *
+     * @param eventName - Event name
+     * @param fromPriority - Original priority
+     * @param toPriority - Escalated priority
+     */
+    recordPriorityEscalation(eventName: string, fromPriority: string, toPriority: string): void;
+    /**
+     * Record event deduplication (FS-102).
+     *
+     * @param eventName - Event name
+     * @param deduplicatedCount - Number of events after deduplication
+     * @param totalCount - Total number of events before deduplication
+     */
+    recordDeduplication(eventName: string, deduplicatedCount: number, totalCount: number): void;
+    /**
+     * Record batch submission (FS-102).
+     *
+     * @param eventName - Event name
+     * @param batchSize - Size of submitted batch
+     * @param windowMs - Aggregation window size
+     */
+    recordBatch(eventName: string, batchSize: number, windowMs: number): void;
+    /**
+     * Record window adjustment (FS-102).
+     *
+     * @param oldWindowMs - Previous window size
+     * @param newWindowMs - New window size
+     * @param reason - Adjustment reason
+     */
+    recordWindowAdjustment(oldWindowMs: number, newWindowMs: number, reason: string): void;
+}
+
+/**
+ * 優先級統計器
+ * 追蹤優先級分布和升級事件
+ *
+ * @internal
+ */
+declare class PriorityStatistics {
+    private eventCounts;
+    private escalationCounts;
+    private totalEscalations;
+    /**
+     * 記錄一個優先級的事件
+     */
+    recordEvent(priority: 'critical' | 'high' | 'normal' | 'low'): void;
+    /**
+     * 記錄優先級升級
+     */
+    recordEscalation(fromPriority: 'critical' | 'high' | 'normal' | 'low', toPriority: 'critical' | 'high' | 'normal' | 'low'): void;
+    /**
+     * 獲取優先級分布
+     */
+    getDistribution(): Record<'critical' | 'high' | 'normal' | 'low', string>;
+    /**
+     * 獲取升級統計
+     */
+    getEscalationStats(): {
+        total: number;
+        byTransition: Record<string, number>;
+    };
+    /**
+     * 重置統計信息
+     */
+    reset(): void;
+    /**
+     * 獲取所有統計信息
+     */
+    getStats(): {
+        eventCounts: Record<'critical' | 'high' | 'normal' | 'low', number>;
+        escalationStats: {
+            total: number;
+            byTransition: Record<string, number>;
+        };
+        distribution: Record<'critical' | 'high' | 'normal' | 'low', string>;
+    };
+}
+
+/**
+ * @gravito/core - Retry Scheduler
+ *
+ * 分佈式重試排程器，使用 Bull Queue 進行異步延遲重試。
+ * 支援指數回退、Redis 持久化、重試失敗回呼。
+ *
+ * Distributed retry scheduler using Bull Queue for async delayed retries.
+ * Supports exponential backoff, Redis persistence, and failure callbacks.
+ */
+
+/**
+ * 重試排程器配置介面
+ */
+interface RetrySchedulerConfig {
+    /** 是否啟用 Bull Queue 重試（預設 true） */
+    enabled?: boolean;
+    /** Redis 連接配置（可選，使用全域 Redis） */
+    redisUrl?: string;
+    /** 預設最大重試次數（預設 5） */
+    maxRetries?: number;
+    /** 初始延遲時間（ms，預設 1000） */
+    initialDelayMs?: number;
+    /** 指數回退倍數（預設 2.0） */
+    backoffMultiplier?: number;
+    /** 最大延遲時間（ms，預設 1h） */
+    maxDelayMs?: number;
+    /** 重試失敗回呼 */
+    onRetryFailed?: (eventName: string, error: Error, retryCount: number) => void;
+}
+/**
+ * 隊列統計資訊
+ */
+interface QueueStats {
+    name: string;
+    jobCounts: {
+        waiting: number;
+        active: number;
+        delayed: number;
+        failed: number;
+    };
+    completedCount: number;
+    failedCount: number;
+}
+/**
+ * 重試排程器
+ *
+ * 提供異步分佈式重試機制，利用 Bull Queue 進行延遲重試。
+ * 支援指數回退、Redis 持久化、隊列統計。
+ */
+declare class RetryScheduler {
+    private enabled;
+    private config;
+    private queues;
+    private bullmqModule;
+    private bullmqLoadError;
+    constructor(config?: RetrySchedulerConfig);
+    /**
+     * 動態加載 bullmq 模組
+     */
+    private loadBullmq;
+    /**
+     * 檢查排程器是否啟用
+     */
+    isEnabled(): boolean;
+    /**
+     * 計算指數回退延遲時間
+     *
+     * @param retryCount 當前重試次數（從 0 開始）
+     * @returns 延遲時間（毫秒）
+     */
+    private calculateDelay;
+    /**
+     * 獲取或創建隊列
+     *
+     * @param eventName 事件名稱
+     * @returns Queue 實例
+     */
+    private getOrCreateQueue;
+    /**
+     * 排程重試任務
+     *
+     * @param eventName 事件名稱
+     * @param payload 事件負載
+     * @param options 事件選項
+     * @param error 原始錯誤
+     * @param retryCount 當前重試次數
+     */
+    scheduleRetry(eventName: string, payload: unknown, _options: EventOptions, error: Error, retryCount: number): Promise<void>;
+    /**
+     * 獲取特定事件的隊列
+     *
+     * @param eventName 事件名稱
+     * @returns Queue 實例或 undefined
+     */
+    getQueue(eventName: string): unknown;
+    /**
+     * 取得所有隊列統計
+     */
+    getStats(): Map<string, QueueStats>;
+    /**
+     * 關閉所有隊列並清理資源
+     */
+    shutdown(): Promise<void>;
+}
+
+/**
+ * Worker Pool Configuration and Types
+ *
+ * Defines configuration interfaces and data types for worker pool management.
+ *
+ * @internal
+ */
+
+/**
+ * Task source interface for fetching and acknowledging tasks.
+ * Supports integration with external task systems like Bull Queue.
+ */
+interface TaskSource {
+    /**
+     * Fetch the next task from the source.
+     * Returns null if no tasks available.
+     */
+    fetchTask(): Promise<EventTask | null>;
+    /**
+     * Acknowledge successful task completion.
+     */
+    acknowledgeCompletion(taskId: string): Promise<void>;
+    /**
+     * Acknowledge task failure.
+     */
+    acknowledgeFailure(taskId: string, error: Error): Promise<void>;
+}
+/**
+ * Worker Pool Configuration
+ */
+interface WorkerPoolConfig {
+    /**
+     * Maximum number of concurrent tasks being processed.
+     * @default 4
+     */
+    concurrency?: number;
+    /**
+     * Number of worker threads to maintain.
+     * @default Number of CPU cores
+     */
+    workerThreads?: number;
+    /**
+     * Task execution timeout in milliseconds.
+     * @default 30000
+     */
+    taskTimeout?: number;
+    /**
+     * Maximum number of retries for failed tasks.
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * Enable automatic scaling based on load.
+     * @default true
+     */
+    enableAutoScaling?: boolean;
+    /**
+     * Minimum number of workers for auto-scaling.
+     * @default 1
+     */
+    minWorkers?: number;
+    /**
+     * Maximum number of workers for auto-scaling.
+     * @default 2 * CPU cores
+     */
+    maxWorkers?: number;
+    /**
+     * Worker utilization threshold for scaling up (0-1).
+     * @default 0.8
+     */
+    scaleUpThreshold?: number;
+    /**
+     * Worker utilization threshold for scaling down (0-1).
+     * @default 0.2
+     */
+    scaleDownThreshold?: number;
+    /**
+     * Interval for collecting metrics in milliseconds.
+     * @default 5000
+     */
+    metricsInterval?: number;
+    /**
+     * External task source (e.g., Bull Queue).
+     * When provided, workers fetch tasks from this source.
+     */
+    taskSource?: TaskSource;
+}
+/**
+ * Worker State
+ */
+type WorkerState = 'idle' | 'busy' | 'terminated';
+/**
+ * Worker Statistics
+ */
+interface WorkerStats {
+    /**
+     * Unique worker identifier.
+     */
+    id: string;
+    /**
+     * Current worker state.
+     */
+    state: WorkerState;
+    /**
+     * Total tasks processed by this worker.
+     */
+    tasksProcessed: number;
+    /**
+     * Total successful tasks.
+     */
+    tasksSuccess: number;
+    /**
+     * Total failed tasks.
+     */
+    tasksFailed: number;
+    /**
+     * Average task execution duration in milliseconds.
+     */
+    avgDurationMs: number;
+    /**
+     * Worker uptime in milliseconds.
+     */
+    uptime: number;
+}
+/**
+ * Worker Pool Statistics
+ */
+interface WorkerPoolStats {
+    /**
+     * Total tasks in queue.
+     */
+    queueDepth: number;
+    /**
+     * Worker utilization (0-1).
+     */
+    utilization: number;
+    /**
+     * Current number of active workers.
+     */
+    activeWorkers: number;
+    /**
+     * Total tasks processed.
+     */
+    totalTasksProcessed: number;
+    /**
+     * Total successful tasks.
+     */
+    totalSuccess: number;
+    /**
+     * Total failed tasks.
+     */
+    totalFailures: number;
+}
+
+/**
+ * Worker Pool for concurrent event task processing.
+ *
+ * Manages a pool of workers for executing event tasks concurrently.
+ * Supports auto-scaling, health checks, and OpenTelemetry metrics integration.
+ *
+ * @internal
+ */
+
+/**
+ * Worker Pool for managing concurrent task execution
+ */
+declare class WorkerPool {
+    private workers;
+    private taskQueue;
+    private config;
+    private metrics?;
+    private healthCheckTimer?;
+    private metricsTimer?;
+    private isRunning;
+    private scaleDownCounter;
+    constructor(config?: WorkerPoolConfig, meter?: Meter);
+    /**
+     * Start the worker pool
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the worker pool
+     */
+    stop(): Promise<void>;
+    /**
+     * Submit a task to the worker pool
+     */
+    submitTask(task: EventTask): Promise<void>;
+    /**
+     * Process next task in queue
+     */
+    private processQueue;
+    /**
+     * Execute task on a worker
+     */
+    private executeTask;
+    /**
+     * Execute task callbacks
+     */
+    private executeTaskCallbacks;
+    /**
+     * Create a timeout promise
+     */
+    private createTimeout;
+    /**
+     * Create a new worker
+     */
+    private createWorker;
+    /**
+     * Remove a worker
+     */
+    private removeWorker;
+    /**
+     * Perform health check and cleanup
+     */
+    private performHealthCheck;
+    /**
+     * Perform auto-scaling based on load
+     */
+    private performAutoScaling;
+    /**
+     * Collect metrics
+     */
+    private collectMetrics;
+    /**
+     * Get number of active workers (not terminated)
+     */
+    private getActiveWorkerCount;
+    /**
+     * Get worker utilization (0-1)
+     */
+    private getUtilization;
+    /**
+     * Get queue depth
+     */
+    getQueueDepth(): number;
+    /**
+     * Get worker utilization
+     */
+    getWorkerUtilization(): number;
+    /**
+     * Get worker statistics
+     */
+    getWorkerStats(): WorkerStats[];
+    /**
+     * Get pool statistics
+     */
+    getPoolStats(): WorkerPoolStats;
+}
+
+/**
+ * Priority queue for event processing.
+ * Events are processed based on their priority level:
+ * - Critical priority events are processed first (< 1ms)
+ * - High priority events are processed second (< 50ms)
+ * - Normal priority events are processed third (< 200ms)
+ * - Low priority events are processed last (< 500ms)
+ *
+ * Supports automatic priority escalation based on wait time.
+ *
+ * @internal
+ */
+declare class EventPriorityQueue implements EventBackend {
+    private criticalPriority;
+    private highPriority;
+    private normalPriority;
+    private lowPriority;
+    private processing;
+    private taskIdCounter;
     private dlq?;
     private persistentDLQHandler?;
     private config;
     private processingPartitions;
     private eventCircuitBreakers;
     private eventMetrics?;
+    private otelEventMetrics?;
     private eventTracing?;
     private currentDispatchSpan?;
+    private backpressureManager?;
+    private workerPool?;
+    private retryScheduler?;
+    private priorityStats?;
     constructor(config?: EventQueueConfig);
     /**
      * Set the Dead Letter Queue for failed events.
@@ -4193,6 +5756,27 @@ declare class EventPriorityQueue implements EventBackend {
      * @internal
      */
     setEventMetrics(metrics: EventMetrics): void;
+    /**
+     * Set the OTelEventMetrics instance for recording DLQ and backpressure metrics.
+     *
+     * @param metrics - OTelEventMetrics instance
+     * @internal
+     */
+    setOTelEventMetrics(metrics: OTelEventMetrics): void;
+    /**
+     * Set the PriorityStatistics instance for tracking priority distribution.
+     *
+     * @param stats - PriorityStatistics instance
+     * @internal
+     */
+    setPriorityStatistics(stats: PriorityStatistics): void;
+    /**
+     * Get the PriorityStatistics instance.
+     *
+     * @returns PriorityStatistics instance or undefined
+     * @internal
+     */
+    getPriorityStatistics(): PriorityStatistics | undefined;
     /**
      * Set the EventTracing instance for distributed tracing.
      *
@@ -4214,6 +5798,20 @@ declare class EventPriorityQueue implements EventBackend {
      * @internal
      */
     getCurrentDispatchSpan(): Span | undefined;
+    /**
+     * Set the RetryScheduler for async distributed retries.
+     *
+     * @param scheduler - RetryScheduler instance
+     * @internal
+     */
+    setRetryScheduler(scheduler: RetryScheduler): void;
+    /**
+     * Get the RetryScheduler instance.
+     *
+     * @returns RetryScheduler instance or undefined
+     * @internal
+     */
+    getRetryScheduler(): RetryScheduler | undefined;
     /**
      * Get or create a circuit breaker for an event hook.
      *
@@ -4232,7 +5830,7 @@ declare class EventPriorityQueue implements EventBackend {
      * @param options - Event options
      * @returns Task ID
      */
-    enqueue(task: EventTask): void;
+    enqueue(task: EventTask): string;
     enqueue(hook: string, args: unknown, callbacks: ActionCallback[], options: EventOptions): string;
     /**
      * Handle backpressure when queue is full.
@@ -4241,17 +5839,20 @@ declare class EventPriorityQueue implements EventBackend {
     private handleBackpressure;
     /**
      * Drop the oldest event from the queue, prioritizing low priority events.
+     * Drops in order: LOW → NORMAL → HIGH → CRITICAL
      */
     private dropOldest;
     /**
      * Process the next task in the queue.
      * Tasks are processed in priority order: high > normal > low
+     * If WorkerPool is configured, tasks are submitted to the pool for concurrent execution.
      *
      * @internal
      */
     private processNext;
     /**
      * Dequeue the next task based on priority and partition ordering.
+     * Priority order: CRITICAL > HIGH > NORMAL > LOW
      *
      * @returns Next task to process, or undefined if queue is empty
      * @internal
@@ -4302,18 +5903,39 @@ declare class EventPriorityQueue implements EventBackend {
      */
     private executeWithTimeout;
     /**
-     * Get the current depth of the queue.
+     * Get the current depth of the queue.
+     *
+     * @returns Total number of tasks in the queue
+     */
+    getDepth(): number;
+    /**
+     * Get the depth of a specific priority queue.
+     *
+     * @param priority - Priority level
+     * @returns Number of tasks in the specified priority queue
+     */
+    getDepthByPriority(priority: 'critical' | 'high' | 'normal' | 'low'): number;
+    /**
+     * Get the BackpressureManager instance if enabled.
+     *
+     * @returns BackpressureManager instance or undefined if not enabled
+     * @internal
+     */
+    getBackpressureManager(): BackpressureManager | undefined;
+    /**
+     * Set the WorkerPool for concurrent task execution.
      *
-     * @returns Total number of tasks in the queue
+     * @param pool - WorkerPool instance
+     * @internal
      */
-    getDepth(): number;
+    setWorkerPool(pool: WorkerPool): void;
     /**
-     * Get the depth of a specific priority queue.
+     * Get the WorkerPool instance if set.
      *
-     * @param priority - Priority level
-     * @returns Number of tasks in the specified priority queue
+     * @returns WorkerPool instance or undefined if not set
+     * @internal
      */
-    getDepthByPriority(priority: 'high' | 'normal' | 'low'): number;
+    getWorkerPool(): WorkerPool | undefined;
     /**
      * Clear all tasks from the queue.
      */
@@ -4341,420 +5963,387 @@ declare class EventPriorityQueue implements EventBackend {
      * @internal
      */
     resetCircuitBreaker(hook: string): boolean;
-}
-
-/**
- * @gravito/core - Event System Tracer
- *
- * Manages OpenTelemetry distributed tracing for event dispatch.
- */
-
-/**
- * Event tracer for distributed tracing support.
- *
- * Integrates with OpenTelemetry to provide:
- * - Event dispatch tracing
- * - Listener execution tracing
- * - Error recording
- * - Span hierarchy
- *
- * @public
- */
-declare class EventTracer {
-    private tracer;
-    /**
-     * Create a new EventTracer instance.
-     *
-     * @param tracerName - Name of the tracer (default: '@gravito/core')
-     */
-    constructor(tracerName?: string);
-    /**
-     * Start a span for event dispatch.
-     *
-     * @param eventName - Name of the event
-     * @param callbackCount - Number of callbacks registered for this event
-     * @param priority - Priority level (high, normal, low)
-     * @returns Span for the event dispatch
-     */
-    startDispatchSpan(eventName: string, callbackCount: number, priority: string): Span;
-    /**
-     * Start a span for listener execution.
-     *
-     * @param _parentSpan - Parent span for this listener
-     * @param eventName - Name of the event
-     * @param listenerIndex - Index of the listener in the callback list
-     * @returns Child span for the listener execution
-     */
-    startListenerSpan(_parentSpan: Span, eventName: string, listenerIndex: number): Span;
     /**
-     * Record an error in the span.
+     * Batch enqueue multiple tasks (FS-102).
+     * Supports aggregation layer batch submission.
      *
-     * @param span - Span to record error in
-     * @param error - Error that occurred
+     * @param tasks - Array of tasks to enqueue
+     * @returns Array of task IDs
+     * @internal
      */
-    recordError(span: Span, error: Error): void;
+    enqueueBatch(tasks: EventTask[]): string[];
     /**
-     * End a span with a specific status.
+     * Get queue depth for each priority level (FS-103).
+     * Used by BackpressureManager for multi-priority depth monitoring.
      *
-     * @param span - Span to end
-     * @param status - Status ('ok' or 'error')
+     * @returns Queue depth snapshot with depths for each priority
+     * @internal
      */
-    endSpan(span: Span, status?: 'ok' | 'error'): void;
+    getQueueDepthByPriority(): MultiPriorityQueueDepth;
     /**
-     * Create a timer span for measuring duration.
+     * Sync queue depth to BackpressureManager (FS-103).
+     * Called whenever queue depth changes to keep BackpressureManager
+     * synchronized with real-time queue state.
      *
-     * @param eventName - Name of the event
-     * @returns Object with span and duration recording function
+     * @private
+     * @internal
      */
-    startTimer(eventName: string): {
-        span: Span;
-        endTimer: (status?: 'ok' | 'error') => void;
-    };
+    private syncBackpressure;
 }
 
 /**
- * @gravito/core - Observable Hook Manager
+ * @gravito/core - Message Queue Bridge
  *
- * Wraps HookManager with observability support (metrics and tracing).
+ * 橋接層，連接 HookManager 與 Bull Queue (via StreamEventBackend)
+ * 支持分佈式事件流：HookManager → Bull Queue → Worker → 完成/DLQ
  */
 
 /**
- * Configuration for observability features.
- * @public
+ * 事件執行狀態
  */
-interface ObservabilityConfig {
+interface EventStatus {
+    eventId: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed' | 'in_dlq';
+    attempts: number;
+    lastError?: string;
+    createdAt: number;
+    processedAt?: number;
+}
+/**
+ * MessageQueueBridge 配置
+ */
+interface MessageQueueBridgeConfig {
     /**
-     * Enable observability features.
-     * @default false
+     * HookManager 實例
      */
-    enabled?: boolean;
+    hookManager: HookManager;
     /**
-     * MetricsRegistry instance from @gravito/monitor.
-     * Required if metrics collection is enabled.
+     * Worker 線程池（可選）
      */
-    metrics?: any;
+    workerPool?: WorkerPool;
     /**
-     * Enable OpenTelemetry distributed tracing.
-     * @default false
+     * 分佈式事件後端（Bull Queue）
      */
-    tracing?: boolean;
+    eventBackend: EventBackend;
     /**
-     * Prefix for metric names.
-     * @default 'gravito_event_'
+     * Dead Letter Queue 管理器
      */
-    metricsPrefix?: string;
+    dlqManager: DeadLetterQueueManager;
+    /**
+     * 是否啟用 CircuitBreaker 檢查
+     * @default false
+     */
+    enableCircuitBreaker?: boolean;
 }
 /**
- * Observable Hook Manager - extends HookManager with observability.
+ * MessageQueueBridge - 連接 HookManager 與 Bull Queue 的橋接層
  *
- * Provides metrics and distributed tracing for event dispatch and listener execution.
- * Maintains 100% backward compatibility with HookManager.
+ * 功能：
+ * 1. 通過 Bull Queue 分發事件（dispatchWithQueue）
+ * 2. Worker 中處理隊列事件（processQueuedEvent）
+ * 3. 失敗任務轉移至 DLQ（handleJobFailure）
+ * 4. 查詢事件執行狀態（getEventStatus）
  *
- * @public
+ * @example
+ * ```typescript
+ * const bridge = new MessageQueueBridge({
+ *   hookManager,
+ *   eventBackend: streamEventBackend,
+ *   dlqManager,
+ *   enableCircuitBreaker: true
+ * })
+ *
+ * // 分發事件至 Bull Queue
+ * const jobId = await bridge.dispatchWithQueue('order:created', { orderId: 123 })
+ *
+ * // Worker 處理事件
+ * await bridge.processQueuedEvent(jobId, task)
+ * ```
  */
-declare class ObservableHookManager extends HookManager {
-    private eventMetrics?;
-    private eventTracer?;
-    private eventTracing?;
-    private obsConfig;
+declare class MessageQueueBridge {
+    private config;
+    constructor(config: MessageQueueBridgeConfig);
     /**
-     * Create a new ObservableHookManager instance.
+     * 通過 Bull Queue 分發事件（分佈式異步處理）
      *
-     * @param config - HookManager configuration
-     * @param obsConfig - Observability configuration
-     */
-    constructor(config?: HookManagerConfig, obsConfig?: ObservabilityConfig);
-    /**
-     * Run all registered actions asynchronously via priority queue with observability.
+     * 流程：
+     * 1. 驗證事件 listeners 存在
+     * 2. 檢查 CircuitBreaker 狀態（如果啟用）
+     * 3. 構建 EventTask
+     * 4. 入隊到 eventBackend (Bull Queue)
      *
-     * This override adds metrics and tracing to the base implementation.
+     * @param eventName - 事件名稱
+     * @param args - 事件參數
+     * @param options - 事件選項（可選）
+     * @returns Job ID
+     * @throws 如果沒有 listeners 或 CircuitBreaker 打開
      *
-     * @template TArgs - The type of arguments passed to the action.
-     * @param hook - The name of the hook.
-     * @param args - The arguments to pass to the callbacks.
-     * @param options - Event options for async dispatch.
+     * @example
+     * ```typescript
+     * const jobId = await bridge.dispatchWithQueue('order:created', {
+     *   orderId: 'ORD-123',
+     *   amount: 999.99
+     * })
+     * ```
      */
-    doActionAsync<TArgs = unknown>(hook: string, args: TArgs, options?: EventOptions): Promise<void>;
+    dispatchWithQueue<TArgs = unknown>(eventName: string, args: TArgs, options?: any): Promise<string>;
     /**
-     * Run all registered actions synchronously with observability.
+     * 處理隊列事件（由 Bull Queue Worker 調用）
      *
-     * This override adds metrics and tracing to the base implementation.
+     * 重要：使用 doActionSync() 避免遞迴
+     * - 不能使用 doActionAsync()（會導致事件再次入隊）
+     * - Worker 中直接同步執行 callbacks
      *
-     * @template TArgs - The type of arguments passed to the action.
-     * @param hook - The name of the hook.
-     * @param args - The arguments to pass to the callbacks.
+     * 流程：
+     * 1. 直接執行 callbacks（不使用 doActionSync，避免吞掉錯誤）
+     * 2. 記錄成功或失敗
+     * 3. 拋出錯誤讓 Bull Queue 處理重試
+     *
+     * @param jobId - Bull Queue Job ID
+     * @param task - 事件任務
+     * @throws 如果 callback 執行失敗，讓 Bull Queue 處理重試
+     *
+     * @example
+     * ```typescript
+     * // 在 Bull Queue Worker 中：
+     * await bridge.processQueuedEvent(jobId, task)
+     * ```
      */
-    doActionSync<TArgs = unknown>(hook: string, args: TArgs): Promise<void>;
+    processQueuedEvent(jobId: string, task: EventTask): Promise<void>;
     /**
-     * Get the EventMetrics instance.
+     * 處理 Bull Queue 任務失敗（由 onFailed callback 調用）
      *
-     * @returns EventMetrics instance if observability is enabled, undefined otherwise
+     * 流程：
+     * 1. 記錄警告日誌
+     * 2. 移至 persistent DLQ（DeadLetterQueueManager）
+     * 3. 持久化到 event_dlq 表，支持延遲重試
+     *
+     * @param jobId - Bull Queue Job ID
+     * @param task - 事件任務
+     * @param error - 導致失敗的錯誤
+     * @param retryCount - 已重試次數（可選）
+     *
+     * @example
+     * ```typescript
+     * // 在 Bull Queue onFailed callback 中：
+     * await bridge.handleJobFailure(jobId, task, error, 3)
+     * ```
      */
-    getMetrics(): EventMetrics | undefined;
+    handleJobFailure(jobId: string, task: EventTask, error: Error, retryCount?: number): Promise<void>;
     /**
-     * Get the EventTracer instance.
+     * 查詢事件執行狀態
      *
-     * @returns EventTracer instance if tracing is enabled, undefined otherwise
+     * 支持查詢：
+     * 1. 待處理事件
+     * 2. 正在處理的事件
+     * 3. 已完成事件
+     * 4. 失敗事件（在 DLQ 中）
+     *
+     * @param eventId - 事件 ID（task.id 或 jobId）
+     * @returns 事件狀態
+     *
+     * @example
+     * ```typescript
+     * const status = await bridge.getEventStatus('queue-1707000000000-abc123')
+     * console.log(status) // { eventId, status, attempts, ... }
+     * ```
      */
-    getTracer(): EventTracer | undefined;
+    getEventStatus(eventId: string): Promise<EventStatus>;
     /**
-     * Update observability configuration at runtime.
+     * 獲取 EventBackend 實例（用於高級操作）
      *
-     * @param config - New observability configuration
+     * @returns EventBackend 實例
+     * @internal
      */
-    setObservabilityConfig(config: Partial<ObservabilityConfig>): void;
+    getEventBackend(): EventBackend;
     /**
-     * Get the EventTracing instance.
+     * 獲取 DLQ 管理器實例（用於高級操作）
      *
-     * @returns EventTracing instance if tracing is enabled, undefined otherwise
+     * @returns DeadLetterQueueManager 實例
+     * @internal
      */
-    getEventTracing(): EventTracing | undefined;
+    getDLQManager(): DeadLetterQueueManager;
     /**
-     * Get current observability configuration.
+     * 獲取 HookManager 實例（用於高級操作）
      *
-     * @returns Current observability configuration
+     * @returns HookManager 實例
+     * @internal
      */
-    getObservabilityConfig(): ObservabilityConfig;
+    getHookManager(): HookManager;
 }
 
 /**
- * @gravito/core - OpenTelemetry Event Metrics
- *
- * Provides event system metrics using OpenTelemetry API directly.
- * This enables Prometheus export without requiring @gravito/monitor dependency.
- *
- * Metrics:
- * - gravito_event_dispatch_duration_seconds (Histogram)
- * - gravito_event_listener_duration_seconds (Histogram)
- * - gravito_event_queue_depth (Observable Gauge)
+ * @gravito/core - Event System Tracer
  *
- * @packageDocumentation
+ * Manages OpenTelemetry distributed tracing for event dispatch.
  */
 
 /**
- * Queue depth callback type.
- * Returns the current queue depths for each priority level.
- */
-type QueueDepthCallback = () => {
-    high: number;
-    normal: number;
-    low: number;
-};
-/**
- * Circuit breaker state callback type.
- * Returns the current state of a circuit breaker.
- */
-type CircuitBreakerStateCallback = () => {
-    eventName: string;
-    listenerIndex: number;
-    state: 0 | 1 | 2;
-};
-/**
- * OpenTelemetry-based Event Metrics collector.
- *
- * Uses OpenTelemetry API directly for metrics collection, enabling
- * Prometheus export through the OpenTelemetry SDK.
- *
- * @example
- * ```typescript
- * import { metrics } from '@opentelemetry/api'
- * import { OTelEventMetrics } from '@gravito/core'
- *
- * const meter = metrics.getMeter('@gravito/core', '1.0.0')
- * const eventMetrics = new OTelEventMetrics(meter)
- *
- * // Record dispatch duration
- * eventMetrics.recordDispatchDuration('order:created', 'high', 0.123)
- *
- * // Record listener duration
- * eventMetrics.recordListenerDuration('order:created', 0, 0.456)
- *
- * // Set queue depth callback
- * eventMetrics.setQueueDepthCallback(() => ({
- *   high: 10,
- *   normal: 50,
- *   low: 100
- * }))
- * ```
+ * Event tracer for distributed tracing support.
  *
- * @public
- */
-declare class OTelEventMetrics implements CircuitBreakerMetricsRecorder {
-    private readonly meter;
-    private readonly prefix;
-    private readonly dispatchDurationHistogram;
-    private readonly listenerDurationHistogram;
-    private readonly queueDepthGauge;
-    private readonly cbStateGauge;
-    private readonly cbFailuresCounter;
-    private readonly cbSuccessesCounter;
-    private readonly cbTransitionsCounter;
-    private readonly cbOpenDurationHistogram;
-    private queueDepthCallback?;
-    private circuitBreakerStateCallbacks;
-    private recordedCircuitBreakerStates;
-    /**
-     * Bucket boundaries for dispatch duration histogram.
-     */
-    private readonly dispatchDurationBuckets;
-    /**
-     * Bucket boundaries for listener duration histogram.
-     */
-    private readonly listenerDurationBuckets;
-    /**
-     * Bucket boundaries for circuit breaker open duration histogram.
-     */
-    private readonly cbOpenDurationBuckets;
+ * Integrates with OpenTelemetry to provide:
+ * - Event dispatch tracing
+ * - Listener execution tracing
+ * - Error recording
+ * - Span hierarchy
+ *
+ * @public
+ */
+declare class EventTracer {
+    private tracer;
     /**
-     * Create a new OTelEventMetrics instance.
+     * Create a new EventTracer instance.
      *
-     * @param meter - OpenTelemetry Meter instance
-     * @param prefix - Metric name prefix (default: 'gravito_event_')
+     * @param tracerName - Name of the tracer (default: '@gravito/core')
      */
-    constructor(meter: Meter, prefix?: string);
+    constructor(tracerName?: string);
     /**
-     * Record event dispatch duration.
+     * Start a span for event dispatch.
      *
      * @param eventName - Name of the event
+     * @param callbackCount - Number of callbacks registered for this event
      * @param priority - Priority level (high, normal, low)
-     * @param durationSeconds - Duration in seconds
+     * @returns Span for the event dispatch
      */
-    recordDispatchDuration(eventName: string, priority: string, durationSeconds: number): void;
+    startDispatchSpan(eventName: string, callbackCount: number, priority: string): Span;
     /**
-     * Record listener execution duration.
+     * Start a span for listener execution.
      *
+     * @param _parentSpan - Parent span for this listener
      * @param eventName - Name of the event
      * @param listenerIndex - Index of the listener in the callback list
-     * @param durationSeconds - Duration in seconds
-     */
-    recordListenerDuration(eventName: string, listenerIndex: number, durationSeconds: number): void;
-    /**
-     * Set the callback for queue depth observable gauge.
-     *
-     * The callback will be invoked when metrics are collected,
-     * allowing real-time reporting of queue depths.
-     *
-     * @param callback - Function returning current queue depths
+     * @returns Child span for the listener execution
      */
-    setQueueDepthCallback(callback: QueueDepthCallback): void;
+    startListenerSpan(_parentSpan: Span, eventName: string, listenerIndex: number): Span;
     /**
-     * Register a circuit breaker state callback for monitoring.
+     * Record an error in the span.
      *
-     * @param key - Unique identifier for the circuit breaker (e.g., "order:created-0")
-     * @param callback - Function returning current circuit breaker state
+     * @param span - Span to record error in
+     * @param error - Error that occurred
      */
-    registerCircuitBreakerStateCallback(key: string, callback: CircuitBreakerStateCallback): void;
+    recordError(span: Span, error: Error): void;
     /**
-     * Unregister a circuit breaker state callback.
+     * End a span with a specific status.
      *
-     * @param key - Unique identifier for the circuit breaker
+     * @param span - Span to end
+     * @param status - Status ('ok' or 'error')
      */
-    unregisterCircuitBreakerStateCallback(key: string): void;
+    endSpan(span: Span, status?: 'ok' | 'error'): void;
     /**
-     * Record circuit breaker state change.
+     * Create a timer span for measuring duration.
      *
-     * @param name - Name of the circuit breaker (usually event name)
-     * @param state - State as number (0=CLOSED, 1=HALF_OPEN, 2=OPEN)
+     * @param eventName - Name of the event
+     * @returns Object with span and duration recording function
      */
-    recordState(name: string, state: number): void;
+    startTimer(eventName: string): {
+        span: Span;
+        endTimer: (status?: 'ok' | 'error') => void;
+    };
+}
+
+/**
+ * @gravito/core - Observable Hook Manager
+ *
+ * Wraps HookManager with observability support (metrics and tracing).
+ */
+
+/**
+ * Configuration for observability features.
+ * @public
+ */
+interface ObservabilityConfig {
     /**
-     * Record circuit breaker state transition.
-     *
-     * @param name - Name of the circuit breaker
-     * @param fromState - Previous state
-     * @param toState - New state
+     * Enable observability features.
+     * @default false
      */
-    recordTransition(name: string, fromState: string, toState: string): void;
+    enabled?: boolean;
     /**
-     * Record circuit breaker failure.
-     *
-     * @param name - Name of the circuit breaker
+     * MetricsRegistry instance from @gravito/monitor.
+     * Required if metrics collection is enabled.
      */
-    recordFailure(name: string): void;
+    metrics?: any;
     /**
-     * Record circuit breaker success.
-     *
-     * @param name - Name of the circuit breaker
+     * Enable OpenTelemetry distributed tracing.
+     * @default false
      */
-    recordSuccess(name: string): void;
+    tracing?: boolean;
     /**
-     * Record circuit breaker open duration.
-     *
-     * @param name - Name of the circuit breaker
-     * @param seconds - Duration in seconds
+     * Prefix for metric names.
+     * @default 'gravito_event_'
      */
-    recordOpenDuration(name: string, seconds: number): void;
+    metricsPrefix?: string;
+}
+/**
+ * Observable Hook Manager - extends HookManager with observability.
+ *
+ * Provides metrics and distributed tracing for event dispatch and listener execution.
+ * Maintains 100% backward compatibility with HookManager.
+ *
+ * @public
+ */
+declare class ObservableHookManager extends HookManager {
+    private eventMetrics?;
+    private eventTracer?;
+    private eventTracing?;
+    private obsConfig;
     /**
-     * Record circuit breaker failure.
+     * Create a new ObservableHookManager instance.
      *
-     * @param eventName - Name of the event
-     * @param listenerIndex - Index of the listener
+     * @param config - HookManager configuration
+     * @param obsConfig - Observability configuration
      */
-    recordCircuitBreakerFailure(eventName: string, listenerIndex: number): void;
+    constructor(config?: HookManagerConfig, obsConfig?: ObservabilityConfig);
     /**
-     * Record circuit breaker success.
+     * Run all registered actions asynchronously via priority queue with observability.
      *
-     * @param eventName - Name of the event
-     * @param listenerIndex - Index of the listener
-     */
-    recordCircuitBreakerSuccess(eventName: string, listenerIndex: number): void;
-    /**
-     * Record circuit breaker state transition.
+     * This override adds metrics and tracing to the base implementation.
      *
-     * @param eventName - Name of the event
-     * @param listenerIndex - Index of the listener
-     * @param fromState - Previous state (CLOSED, HALF_OPEN, OPEN)
-     * @param toState - New state (CLOSED, HALF_OPEN, OPEN)
+     * @template TArgs - The type of arguments passed to the action.
+     * @param hook - The name of the hook.
+     * @param args - The arguments to pass to the callbacks.
+     * @param options - Event options for async dispatch.
      */
-    recordCircuitBreakerTransition(eventName: string, listenerIndex: number, fromState: string, toState: string): void;
+    doActionAsync<TArgs = unknown>(hook: string, args: TArgs, options?: EventOptions): Promise<void>;
     /**
-     * Record circuit breaker open duration.
+     * Run all registered actions synchronously with observability.
      *
-     * @param eventName - Name of the event
-     * @param listenerIndex - Index of the listener
-     * @param durationSeconds - Duration in seconds
-     */
-    recordCircuitBreakerOpenDuration(eventName: string, listenerIndex: number, durationSeconds: number): void;
-    /**
-     * Get the bucket boundaries for dispatch duration histogram.
+     * This override adds metrics and tracing to the base implementation.
      *
-     * @returns Array of bucket boundaries in seconds
+     * @template TArgs - The type of arguments passed to the action.
+     * @param hook - The name of the hook.
+     * @param args - The arguments to pass to the callbacks.
      */
-    getDispatchDurationBuckets(): number[];
+    doActionSync<TArgs = unknown>(hook: string, args: TArgs): Promise<void>;
     /**
-     * Get the bucket boundaries for listener duration histogram.
+     * Get the EventMetrics instance.
      *
-     * @returns Array of bucket boundaries in seconds
+     * @returns EventMetrics instance if observability is enabled, undefined otherwise
      */
-    getListenerDurationBuckets(): number[];
+    getMetrics(): EventMetrics | undefined;
     /**
-     * Get the OpenTelemetry Meter instance.
+     * Get the EventTracer instance.
      *
-     * @returns Meter instance
+     * @returns EventTracer instance if tracing is enabled, undefined otherwise
      */
-    getMeter(): Meter;
+    getTracer(): EventTracer | undefined;
     /**
-     * Get the metric name prefix.
+     * Update observability configuration at runtime.
      *
-     * @returns Metric name prefix
+     * @param config - New observability configuration
      */
-    getPrefix(): string;
+    setObservabilityConfig(config: Partial<ObservabilityConfig>): void;
     /**
-     * Get the bucket boundaries for circuit breaker open duration histogram.
+     * Get the EventTracing instance.
      *
-     * @returns Array of bucket boundaries in seconds
+     * @returns EventTracing instance if tracing is enabled, undefined otherwise
      */
-    getCircuitBreakerOpenDurationBuckets(): number[];
+    getEventTracing(): EventTracing | undefined;
     /**
-     * Get all registered circuit breaker state callback keys.
+     * Get current observability configuration.
      *
-     * @returns Array of registered keys
-     */
-    getRegisteredCircuitBreakers(): string[];
-    /**
-     * Clear all circuit breaker state callbacks.
+     * @returns Current observability configuration
      */
-    clearCircuitBreakerCallbacks(): void;
+    getObservabilityConfig(): ObservabilityConfig;
 }
 
 /**
@@ -4850,6 +6439,16 @@ interface HookManagerConfig {
      * @default false
      */
     enablePersistentDLQ?: boolean;
+    /**
+     * Message Queue Bridge for distributed event processing via Bull Queue.
+     * When provided, enables dispatchQueued() method for routing events to Redis-backed queue.
+     */
+    messageQueueBridge?: any;
+    /**
+     * Event aggregation configuration (FS-102).
+     * Enables deduplication and micro-batching for improved throughput.
+     */
+    aggregation?: any;
 }
 declare class HookManager {
     private filters;
@@ -4858,9 +6457,11 @@ declare class HookManager {
     private backend;
     private dlq?;
     private persistentDlqManager?;
+    private messageQueueBridge?;
     private idempotencyCache;
     private config;
     private migrationWarner;
+    private aggregationManager?;
     /**
      * Cache for async detection results (WeakMap for automatic garbage collection).
      * @internal
@@ -5194,6 +6795,18 @@ declare class HookManager {
      * @returns True if reset, false if circuit breaker not found
      */
     resetCircuitBreaker(eventName: string): boolean;
+    /**
+     * Get the current backpressure state.
+     *
+     * @returns Backpressure state ('NORMAL', 'WARNING', 'CRITICAL', 'OVERFLOW') or undefined if not enabled
+     */
+    getBackpressureState(): string | undefined;
+    /**
+     * Get backpressure metrics snapshot.
+     *
+     * @returns Backpressure metrics snapshot or undefined if not enabled
+     */
+    getBackpressureMetrics(): object | undefined;
     /**
      * Remove all listeners for a specific action hook.
      *
@@ -5238,6 +6851,77 @@ declare class HookManager {
         succeeded: number;
         failed: number;
     }>;
+    /**
+     * Dispatch an event through Bull Queue (分佈式異步處理).
+     *
+     * 與 doActionAsync() 不同：
+     * - doActionAsync() 使用 EventPriorityQueue (Memory-based)
+     * - dispatchQueued() 使用 Bull Queue (Redis-backed, 分佈式)
+     *
+     * 適用於需要持久化和跨進程處理的事件。
+     *
+     * @template TArgs - 事件參數類型
+     * @param event - 事件名稱
+     * @param args - 事件參數
+     * @param options - 事件選項（可選）
+     * @returns Job ID
+     * @throws 如果未配置 MessageQueueBridge 或沒有 listeners
+     *
+     * @example
+     * ```typescript
+     * const jobId = await hookManager.dispatchQueued('order:created', {
+     *   orderId: 'ORD-123',
+     *   amount: 999.99
+     * })
+     * ```
+     *
+     * @public
+     */
+    dispatchQueued<TArgs = unknown>(event: string, args: TArgs, options?: any): Promise<string>;
+    /**
+     * Dispatch an event through Bull Queue with delay (延遲隊列分發).
+     *
+     * 通過 Bull Queue 的 delayed jobs 功能實現延遲處理。
+     *
+     * @template TArgs - 事件參數類型
+     * @param event - 事件名稱
+     * @param args - 事件參數
+     * @param delay - 延遲時間（毫秒）
+     * @param options - 事件選項（可選）
+     * @returns Job ID
+     * @throws 如果未配置 MessageQueueBridge
+     *
+     * @example
+     * ```typescript
+     * // 延遲 5 秒後處理
+     * const jobId = await hookManager.dispatchDeferredQueued(
+     *   'reminder:send',
+     *   { userId: '123' },
+     *   5000
+     * )
+     * ```
+     *
+     * @public
+     */
+    dispatchDeferredQueued<TArgs = unknown>(event: string, args: TArgs, delay: number, options?: any): Promise<string>;
+    /**
+     * Get the execution status of an event.
+     *
+     * 查詢事件執行狀態，支持查詢 Bull Queue 和 DLQ 中的事件。
+     *
+     * @param eventId - 事件 ID (task.id 或 jobId)
+     * @returns 事件狀態信息
+     * @throws 如果未配置 MessageQueueBridge
+     *
+     * @example
+     * ```typescript
+     * const status = await hookManager.getEventStatus('queue-1707000000000-abc123')
+     * console.log(status) // { eventId, status, attempts, createdAt, ... }
+     * ```
+     *
+     * @public
+     */
+    getEventStatus(eventId: string): Promise<any>;
     /**
      * Get persistent DLQ statistics.
      *
@@ -5351,16 +7035,38 @@ declare abstract class ServiceProvider {
      *
      * @param container - The IoC container instance
      */
-    abstract register(container: Container): void | Promise<void>;
+    abstract register(container: Container): void | Promise<void>;
+    /**
+     * Bootstrap any application services.
+     *
+     * This method is called after ALL providers have registered.
+     * You can safely resolve services from the container here.
+     *
+     * @param core - The PlanetCore application instance
+     */
+    boot?(core: PlanetCore): void | Promise<void>;
+    /**
+     * Called when the application is ready to accept requests.
+     *
+     * This method is called after ALL providers have booted.
+     * Use this for final initialization before the server starts accepting traffic.
+     *
+     * @param core - The PlanetCore application instance
+     * @since 2.2.0
+     */
+    onReady?(core: PlanetCore): void | Promise<void>;
     /**
-     * Bootstrap any application services.
+     * Called when the application is shutting down.
      *
-     * This method is called after ALL providers have registered.
-     * You can safely resolve services from the container here.
+     * This method is called during graceful shutdown.
+     * Use this to clean up resources, close connections, etc.
+     *
+     * Providers are called in reverse order (LIFO).
      *
      * @param core - The PlanetCore application instance
+     * @since 2.2.0
      */
-    boot?(core: PlanetCore): void | Promise<void>;
+    onShutdown?(core: PlanetCore): void | Promise<void>;
     /**
      * Set the core instance reference.
      * Called internally by the application during registration.
@@ -5898,6 +7604,47 @@ type GravitoConfig = {
      * @since 2.0.0
      */
     container?: Container;
+    /**
+     * Observability configuration for event system.
+     * @since 2.1.0
+     */
+    observability?: {
+        /**
+         * Enable event system observability (metrics, tracing).
+         * @default false
+         */
+        enabled?: boolean;
+        /**
+         * Enable OpenTelemetry distributed tracing.
+         * @default false
+         */
+        tracing?: boolean;
+        /**
+         * Prefix for metric names.
+         * @default 'gravito_event_'
+         */
+        metricsPrefix?: string;
+        /**
+         * Prometheus metrics configuration.
+         */
+        prometheus?: {
+            /**
+             * Enable Prometheus metrics endpoint.
+             * @default true
+             */
+            enabled?: boolean;
+            /**
+             * Port for Prometheus metrics endpoint.
+             * @default 9090
+             */
+            port?: number;
+            /**
+             * Endpoint path for metrics.
+             * @default '/metrics'
+             */
+            endpoint?: string;
+        };
+    };
 };
 
 /**
@@ -5936,6 +7683,20 @@ declare class PlanetCore {
     private providers;
     private deferredProviders;
     private bootedProviders;
+    private isShuttingDown;
+    /**
+     * Initialize observability asynchronously (metrics, tracing, Prometheus).
+     * This is called from constructor but doesn't block initialization.
+     *
+     * @internal
+     */
+    private initializeObservabilityAsync;
+    /**
+     * Initialize Prometheus metrics asynchronously.
+     *
+     * @internal
+     */
+    private initializePrometheusAsync;
     /**
      * Register a service provider to the core.
      *
@@ -5969,6 +7730,34 @@ declare class PlanetCore {
      * ```
      */
     bootstrap(): Promise<void>;
+    /**
+     * Called when the application is ready to accept requests.
+     *
+     * Invokes the `onReady()` lifecycle hook on all providers.
+     * Called automatically at the end of `bootstrap()`.
+     *
+     * @returns Promise that resolves when all providers are ready.
+     *
+     * @example
+     * ```typescript
+     * await core.ready();
+     * ```
+     */
+    ready(): Promise<void>;
+    /**
+     * Gracefully shutdown the application.
+     *
+     * Invokes the `onShutdown()` lifecycle hook on all providers in reverse order (LIFO).
+     * Should be called when the application receives a termination signal.
+     *
+     * @returns Promise that resolves when all providers have shut down.
+     *
+     * @example
+     * ```typescript
+     * process.on('SIGTERM', () => core.shutdown());
+     * ```
+     */
+    shutdown(): Promise<void>;
     /**
      * Setup deferred provider resolution.
      * Wraps container.make to auto-register deferred providers on first request.
@@ -5994,6 +7783,12 @@ declare class PlanetCore {
         adapter?: HttpAdapter;
         container?: Container;
     });
+    /**
+     * Setup process signal handlers for graceful shutdown
+     *
+     * @internal
+     */
+    private setupSignalHandlers;
     /**
      * Programmatically register an infrastructure module (Orbit).
      * @since 2.0.0
@@ -6136,6 +7931,9 @@ interface FastContext$1 {
     /** Context Variables */
     get<T>(key: string): T;
     set(key: string, value: any): void;
+    /** Request Scope Management */
+    requestScope(): any;
+    scoped<T>(key: string | symbol, factory: () => T): T;
     /** Lifecycle helpers */
     route: (name: string, params?: any, query?: any) => string;
     readonly native: any;
@@ -6264,7 +8062,6 @@ declare class Gravito {
     staticRoutes: Map<string, RouteMetadata>;
     private isPureStaticApp;
     private compiledDynamicRoutes;
-    private middlewareVersion;
     /**
      * Create a new Gravito instance
      *
@@ -6450,6 +8247,7 @@ declare class PhotonRequestWrapper implements GravitoRequest {
 declare class PhotonContextWrapper<V extends GravitoVariables = GravitoVariables> implements GravitoContext<V> {
     private _req;
     private photonCtx;
+    private _requestScope;
     route: (name: string, params?: Record<string, any>, query?: Record<string, any>) => string;
     /**
      * Reset the wrapper for pooling
@@ -6490,6 +8288,8 @@ declare class PhotonContextWrapper<V extends GravitoVariables = GravitoVariables
     get env(): Record<string, unknown> | undefined;
     get native(): Context$1;
     forward(target: string, options?: ProxyOptions): Promise<Response>;
+    requestScope(): RequestScopeManager;
+    scoped<T>(key: string | symbol, factory: () => T): T;
 }
 /**
  * Default HTTP adapter using the optimized Gravito Core Engine.
@@ -6806,6 +8606,143 @@ declare class CommandKernel {
     handle(argv: string[]): Promise<void>;
 }
 
+/**
+ * Configuration for QueueDashboard
+ * All subsystem references are optional to support progressive integration
+ */
+interface QueueDashboardConfig {
+    eventQueue?: EventPriorityQueue;
+    workerPool?: WorkerPool;
+    hookManager?: HookManager;
+    dlq?: DeadLetterQueue;
+    messageQueueBridge?: MessageQueueBridge;
+}
+/**
+ * Queue depth and backpressure metrics
+ */
+interface QueueMetrics {
+    depth: {
+        total: number;
+        high: number;
+        normal: number;
+        low: number;
+    };
+    backpressure: {
+        state: string;
+        rejectedCount: number;
+        degradedCount: number;
+        enqueueRate: number;
+    };
+    processing: boolean;
+}
+/**
+ * Worker pool and thread statistics
+ */
+interface WorkerMetrics {
+    poolSize: number;
+    activeWorkers: number;
+    utilization: number;
+    queueDepth: number;
+    totalProcessed: number;
+    totalSuccess: number;
+    totalFailures: number;
+    successRate: number;
+    workers: Array<{
+        id: string;
+        state: string;
+        tasksProcessed: number;
+        tasksSucceeded: number;
+        tasksFailed: number;
+        avgDurationMs: number;
+        currentLoad: number;
+    }>;
+}
+/**
+ * Timeline event for job processing history
+ */
+interface JobEvent {
+    id: string;
+    hook: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed' | 'in_dlq';
+    priority: string;
+    createdAt: number;
+    error?: string;
+    retryCount: number;
+}
+/**
+ * Error statistics and circuit breaker status
+ */
+interface ErrorStats {
+    totalErrors: number;
+    byEvent: Record<string, number>;
+    circuitBreakers: Array<{
+        eventName: string;
+        state: string;
+        failures: number;
+        successes: number;
+    }>;
+    dlqCount: number;
+}
+/**
+ * Complete dashboard snapshot at a point in time
+ */
+interface DashboardSnapshot {
+    timestamp: number;
+    queue: QueueMetrics;
+    workers: WorkerMetrics;
+    timeline: JobEvent[];
+    errors: ErrorStats;
+}
+/**
+ * QueueDashboard aggregates metrics from all event processing subsystems
+ * Uses Facade pattern to read-only aggregate data without modifying subsystems
+ */
+declare class QueueDashboard {
+    private readonly config;
+    constructor(config: QueueDashboardConfig);
+    /**
+     * Get current queue metrics (depth, backpressure state, enqueue rate)
+     */
+    getQueueMetrics(): QueueMetrics;
+    /**
+     * Get current worker pool metrics (size, utilization, success rate)
+     */
+    getWorkerMetrics(): WorkerMetrics;
+    /**
+     * Get job event timeline from DLQ entries (recent failures)
+     * @param limit Maximum number of entries to return (default: 50)
+     */
+    getJobTimeline(limit?: number): JobEvent[];
+    /**
+     * Get error statistics including circuit breaker status and DLQ counts
+     */
+    getErrorBreakdown(): ErrorStats;
+    /**
+     * Export metrics in JSON or Prometheus format
+     * @param format Export format: 'json' or 'prometheus'
+     */
+    exportMetrics(format: 'json' | 'prometheus'): string;
+    /**
+     * Get complete snapshot of all metrics at a point in time
+     */
+    getSnapshot(options?: {
+        timelineLimit?: number;
+    }): DashboardSnapshot;
+    /**
+     * Format metrics in Prometheus/OpenMetrics text format
+     */
+    private formatPrometheus;
+    /**
+     * Escape special characters in Prometheus labels
+     */
+    private escapePrometheusLabel;
+}
+
+/**
+ * Register queue management commands with CommandKernel
+ */
+declare function registerQueueCommands(kernel: CommandKernel, dashboard: QueueDashboard): void;
+
 /**
  * @fileoverview ErrorHandler - Centralized Error Handling for Gravito Framework
  *
@@ -6848,6 +8785,9 @@ declare class ErrorHandler {
     constructor(deps: ErrorHandlerDeps);
     /**
      * Handle application errors
+     *
+     * Integrates RequestScope cleanup to ensure proper resource management
+     * even when errors occur during request processing.
      */
     handleError(err: unknown, c: GravitoContext): Promise<Response>;
     /**
@@ -6868,6 +8808,131 @@ declare class ErrorHandler {
     private renderErrorResponse;
 }
 
+/**
+ * RequestScope-Aware Error Handling
+ *
+ * Integrates RequestScope lifecycle with error handling to provide:
+ * - Error context with request-scoped resources
+ * - Automatic cleanup of scoped services on error
+ * - Request tracing and diagnostics
+ * - Resource leak detection
+ */
+
+/**
+ * Extended error context with RequestScope information
+ *
+ * Provides error handlers access to request-scoped resources
+ * for proper resource cleanup and error diagnostics.
+ */
+interface RequestScopeErrorContext {
+    /**
+     * The original error that was thrown
+     */
+    error: unknown;
+    /**
+     * HTTP context where error occurred
+     */
+    context: GravitoContext;
+    /**
+     * RequestScope manager for this request
+     * Allows error handlers to access or clean up scoped resources
+     */
+    scope?: RequestScopeManager;
+    /**
+     * Metrics about the request scope state
+     * Useful for diagnostics and understanding resource usage
+     */
+    scopeMetrics?: RequestScopeMetrics;
+    /**
+     * Number of scoped services at time of error
+     * High numbers might indicate resource leaks
+     */
+    scopeSize?: number;
+    /**
+     * Request processing time in milliseconds
+     * Useful for timeout errors
+     */
+    duration?: number;
+    /**
+     * Additional diagnostic information
+     */
+    diagnostics?: {
+        servicesCleanedUp?: string[];
+        cleanupErrors?: Array<{
+            service: string;
+            error: unknown;
+        }>;
+        peakMemoryMb?: number;
+    };
+}
+/**
+ * Error that occurred during RequestScope cleanup
+ *
+ * Wraps original error with cleanup context for proper error reporting
+ */
+declare class RequestScopeCleanupError extends Error {
+    originalError: unknown;
+    cleanupErrors: Array<{
+        service: string;
+        error: unknown;
+    }>;
+    constructor(message: string, originalError: unknown, cleanupErrors: Array<{
+        service: string;
+        error: unknown;
+    }>);
+}
+/**
+ * Helper to extract RequestScope context from GravitoContext
+ *
+ * @param ctx - Gravito context
+ * @returns RequestScope error context with available information
+ */
+declare function extractRequestScopeErrorContext(ctx: GravitoContext, error: unknown): RequestScopeErrorContext;
+/**
+ * Cleanup scoped services safely during error handling
+ *
+ * Ensures all scoped services are cleaned up even if some fail,
+ * and collects cleanup errors for diagnostics.
+ *
+ * @param scope - RequestScope manager
+ * @returns Array of cleanup errors if any occurred
+ */
+declare function cleanupRequestScopeOnError(scope?: RequestScopeManager): Promise<Array<{
+    service: string;
+    error: unknown;
+}>>;
+/**
+ * Safe error handler wrapper that manages RequestScope cleanup
+ *
+ * Ensures scoped services are properly cleaned up before returning error response.
+ * Use this to wrap error handlers to make them RequestScope-aware.
+ *
+ * @example
+ * ```typescript
+ * const errorHandler = withRequestScopeCleanup(async (ctx, error) => {
+ *   // Handle error...
+ *   return ctx.json({ error: error.message }, 500)
+ * })
+ *
+ * // In your app:
+ * try {
+ *   // Handle request...
+ * } catch (error) {
+ *   return errorHandler(ctx, error)
+ * }
+ * ```
+ */
+declare function withRequestScopeCleanup<T extends (ctx: GravitoContext, error: unknown) => Promise<Response>>(handler: T): T;
+/**
+ * Detect potential resource leaks in RequestScope
+ *
+ * Returns diagnostic information about suspicious resource usage patterns
+ */
+declare function detectRequestScopeLeaks(context: RequestScopeErrorContext): {
+    potentialLeaks: boolean;
+    warnings: string[];
+};
+
 /**
  * Options for creating a GravitoException
  * @public
@@ -6984,6 +9049,71 @@ declare class GravitoServer {
     static create(manifest: GravitoManifest, resolvers: Record<string, ModuleResolver>, baseOrbits?: any[]): Promise<PlanetCore>;
 }
 
+/**
+ * @fileoverview HealthProvider - Cloud-native health checks
+ *
+ * Provides liveness and readiness probes for Kubernetes and cloud deployments
+ *
+ * @module @gravito/core/health
+ * @since 2.2.0
+ */
+
+/**
+ * Health check result
+ * @public
+ */
+interface HealthCheckResult {
+    /** Health status */
+    status: 'healthy' | 'unhealthy';
+    /** Optional message */
+    message?: string;
+}
+/**
+ * Health check function interface
+ * @public
+ */
+interface HealthCheck {
+    /** Unique name for this check */
+    name: string;
+    /** Check function that returns health status */
+    check(): Promise<HealthCheckResult>;
+}
+/**
+ * HealthProvider - Provides /health/liveness and /health/readiness endpoints
+ *
+ * - Liveness: Always returns 200 OK (just checks if server is running)
+ * - Readiness: Returns 200 if all checks are healthy, 503 otherwise
+ *
+ * @public
+ */
+declare class HealthProvider extends ServiceProvider {
+    private checks;
+    register(container: Container): void;
+    /**
+     * Register a health check
+     *
+     * @param check - The health check to register
+     *
+     * @example
+     * ```typescript
+     * const health = core.container.make<HealthProvider>('health')
+     * health.registerCheck({
+     *   name: 'database',
+     *   check: async () => {
+     *     try {
+     *       await db.ping()
+     *       return { status: 'healthy' }
+     *     } catch {
+     *       return { status: 'unhealthy', message: 'DB unreachable' }
+     *     }
+     *   }
+     * })
+     * ```
+     */
+    registerCheck(check: HealthCheck): void;
+    boot(core: PlanetCore): void;
+}
+
 /**
  * Path segment (key) in a data structure.
  * @public
@@ -8015,6 +10145,103 @@ declare namespace index$1 {
   export { index$1_DEFAULT_CONFIG as DEFAULT_CONFIG, type index$1_MetricsConfig as MetricsConfig, type index$1_MetricsExporter as MetricsExporter, index$1_OTEL_ENV_VARS as OTEL_ENV_VARS, type index$1_OpenTelemetryConfig as OpenTelemetryConfig, type index$1_OpenTelemetrySDK as OpenTelemetrySDK, type index$1_TracingConfig as TracingConfig, type index$1_TracingExporter as TracingExporter, index$1_getMeter as getMeter, index$1_getOpenTelemetrySDK as getOpenTelemetrySDK, index$1_getTracer as getTracer, index$1_isOpenTelemetryInitialized as isOpenTelemetryInitialized, index$1_resetOpenTelemetry as resetOpenTelemetry, index$1_setupOpenTelemetry as setupOpenTelemetry, index$1_shutdownOpenTelemetry as shutdownOpenTelemetry };
 }
 
+/**
+ * @fileoverview RequestContext - AsyncLocalStorage-based request context management
+ *
+ * Allows deep service layers to access request-scoped data (requestId, userId, etc.)
+ * without passing parameters through the call stack.
+ *
+ * @module @gravito/core/RequestContext
+ * @since 2.2.0
+ */
+/**
+ * 請求上下文資料介面
+ * 包含請求相關的唯一識別碼和上下文資訊
+ * @public
+ */
+interface RequestContextData {
+    /** 唯一的請求識別碼 */
+    requestId: string;
+    /** 使用者 ID（可選） */
+    userId?: string;
+    /** 租戶 ID（可選） */
+    tenantId?: string;
+    /** 追蹤 ID（可選） */
+    traceId?: string;
+    /** 自訂欄位 */
+    [key: string]: unknown;
+}
+/**
+ * RequestContext 物件 - 管理請求上下文的 API
+ *
+ * 提供在非同步鏈中存取和設定請求上下文的方法
+ * @public
+ */
+declare const RequestContext: {
+    /**
+     * 在給定的上下文中執行函式
+     *
+     * 確保函式及其所有非同步呼叫都在同一個上下文中執行
+     *
+     * @param data - 請求上下文資料
+     * @param fn - 要執行的函式（可以是非同步的或同步的）
+     * @returns 如果函式是非同步的，返回 Promise；如果是同步的，直接返回值
+     *
+     * @example
+     * ```typescript
+     * await RequestContext.run({ requestId: 'req-123' }, async () => {
+     *   const userId = RequestContext.get()?.userId;
+     * });
+     *
+     * const result = RequestContext.run({ requestId: 'req-123' }, () => {
+     *   return 'sync-result';
+     * });
+     * ```
+     */
+    run<T>(data: RequestContextData, fn: () => T | Promise<T>): T | Promise<T>;
+    /**
+     * 獲取當前請求的上下文資料
+     *
+     * @returns 請求上下文資料，如果不在請求上下文中則返回 undefined
+     *
+     * @example
+     * ```typescript
+     * const context = RequestContext.get();
+     * if (context) {
+     *   console.log(context.requestId);
+     * }
+     * ```
+     */
+    get(): RequestContextData | undefined;
+    /**
+     * 獲取當前請求的上下文資料，如果不存在則拋出錯誤
+     *
+     * @returns 請求上下文資料
+     * @throws Error 如果不在請求上下文中
+     *
+     * @example
+     * ```typescript
+     * const context = RequestContext.getOrThrow();
+     * console.log(context.requestId); // 保證不為 undefined
+     * ```
+     */
+    getOrThrow(): RequestContextData;
+    /**
+     * 在當前上下文中設定或修改值
+     *
+     * @param key - 要設定的欄位名稱
+     * @param value - 要設定的值
+     * @throws Error 如果不在請求上下文中
+     *
+     * @example
+     * ```typescript
+     * RequestContext.set('userId', 'user-456');
+     * const userId = RequestContext.get()?.userId; // 'user-456'
+     * ```
+     */
+    set(key: string, value: unknown): void;
+};
+
 /**
  * TestResponse wraps a standard Fetch Response and provides fluent assertion methods
  * inspired by Laravel's TestResponse.
@@ -8290,7 +10517,12 @@ declare class AOTRouter {
     private dynamicRoutePatterns;
     private middlewareCache;
     private cacheMaxSize;
-    private version;
+    private _version;
+    /**
+     * Get the current version for cache invalidation
+     * Incremented whenever middleware or routes are modified
+     */
+    get version(): number;
     /**
      * Register a route
      *
@@ -8400,6 +10632,11 @@ declare class FastRequestImpl implements FastRequest {
     private _headers;
     private _cachedJson;
     private _jsonParsed;
+    private _cachedText;
+    private _textParsed;
+    private _cachedFormData;
+    private _formDataParsed;
+    private _cachedQueries;
     private _ctx;
     constructor(ctx: FastContext);
     /**
@@ -8437,6 +10674,7 @@ declare class FastContext implements FastContext$1 {
     readonly req: FastRequestImpl;
     private _headers;
     _isReleased: boolean;
+    private _requestScope;
     /**
      * Initialize context for a new request
      *
@@ -8471,6 +10709,22 @@ declare class FastContext implements FastContext$1 {
     private _store;
     get<T>(key: string): T;
     set(key: string, value: any): void;
+    /**
+     * Get the request-scoped service manager for this request.
+     *
+     * @returns The RequestScopeManager for this request.
+     * @throws Error if called before init() or after reset().
+     */
+    requestScope(): RequestScopeManager;
+    /**
+     * Resolve a request-scoped service (convenience method).
+     *
+     * @template T - The service type.
+     * @param key - The service key for caching.
+     * @param factory - Factory function to create the service.
+     * @returns The cached or newly created service instance.
+     */
+    scoped<T>(key: string | symbol, factory: () => T): T;
     route: (name: string, params?: any, query?: any) => string;
     get native(): this;
 }
@@ -8498,6 +10752,10 @@ declare class MinimalRequest implements FastRequest {
     private readonly _path;
     private readonly _routePattern?;
     private _searchParams;
+    private _cachedQueries;
+    private _cachedJsonPromise;
+    private _cachedTextPromise;
+    private _cachedFormDataPromise;
     constructor(_request: Request, _params: Record<string, string>, _path: string, _routePattern?: string | undefined);
     get url(): string;
     get method(): string;
@@ -8530,6 +10788,7 @@ declare class MinimalRequest implements FastRequest {
 declare class MinimalContext implements FastContext$1 {
     readonly req: MinimalRequest;
     private _resHeaders;
+    private _requestScope;
     constructor(request: Request, params: Record<string, string>, path: string, routePattern?: string);
     private getHeaders;
     json<T>(data: T, status?: number): Response;
@@ -8548,6 +10807,21 @@ declare class MinimalContext implements FastContext$1 {
     forward(target: string, _options?: any): Promise<Response>;
     get<T>(_key: string): T;
     set(_key: string, _value: any): void;
+    /**
+     * Get the request-scoped service manager for this request.
+     *
+     * @returns The RequestScopeManager for this request.
+     */
+    requestScope(): RequestScopeManager;
+    /**
+     * Resolve a request-scoped service (convenience method).
+     *
+     * @template T - The service type.
+     * @param key - The service key for caching.
+     * @param factory - Factory function to create the service.
+     * @returns The cached or newly created service instance.
+     */
+    scoped<T>(key: string | symbol, factory: () => T): T;
     route: (name: string, params?: any, query?: any) => string;
     get native(): this;
     init(_request: Request, _params?: Record<string, string>, _path?: string): this;
@@ -8731,4 +11005,4 @@ declare const VERSION: string;
  */
 declare function defineConfig(config: GravitoConfig): GravitoConfig;
 
-export { type ActionCallback, type AdapterConfig, type AdapterFactory, type ApiFailure, type ApiSuccess, Application, type ApplicationConfig, Arr, AuthenticationException, AuthorizationException, type BodySizeLimitOptions, type CacheService, type Channel, CircuitBreaker, type CircuitBreakerOptions, CircuitBreakerState, CircularDependencyException, type CommandHandler, CommandKernel, ConfigManager, ConsoleLogger, Container, ContentfulStatusCode, type ControllerClass, CookieJar, type CookieOptions, type CorsOptions, type CorsOrigin, type CsrfOptions, DEFAULT_EVENT_OPTIONS, type DLQEntry, type DLQFilter, type DLQManagerFilter, type DLQRecord, type DLQStats, type DataPath, DeadLetterQueue, DeadLetterQueueManager, DumpDieError, type DumpOptions, Encrypter, type EncrypterOptions, type ErrorBag, ErrorHandler, type ErrorHandlerContext, type ErrorHandlerDeps, Event, type EventBackend, EventManager, EventMetrics, type EventOptions, EventPriorityQueue, type EventTask, EventTracer, EventTracing, type EventTracingConfig, type ExceptionOptions, FORM_REQUEST_SYMBOL, type Factory$1 as Factory, type FilterCallback, type FormRequestClass, type FormRequestLike, type GlobalErrorHandlersMode, type GlobalProcessErrorHandlerContext, type GlobalProcessErrorKind, GravitoAdapter, type GravitoConfig, GravitoContext, GravitoEngineAdapter, GravitoErrorHandler, GravitoException, GravitoHandler, type GravitoManifest, GravitoMiddleware, GravitoNotFoundHandler, type GravitoOrbit, GravitoRequest, GravitoServer, GravitoVariables, type HeaderTokenGateOptions, HookManager, type HookManagerConfig, type HstsOptions, type HttpAdapter, HttpException, HttpMethod, HttpTester, type Listener, type ListenerInfo, type ListenerOptions, type Logger, type MetricsExporter, ModelNotFoundException, DEFAULT_CONFIG as OTEL_DEFAULT_CONFIG, OTEL_ENV_VARS, OTelEventMetrics, type ObservabilityConfig, ObservableHookManager, type OpenTelemetryConfig, type OpenTelemetrySDK, type MetricsConfig as OtelMetricsConfig, type TracingConfig as OtelTracingConfig, type PathSegment, PhotonAdapter, PhotonContextWrapper, PhotonRequestWrapper, PlanetCore, type QueueDepthCallback, type RegisterGlobalErrorHandlersOptions, type RequireHeaderTokenOptions, RetryEngine, type RetryPolicy, Route, type RouteDefinition$1 as RouteDefinition, RouteGroup, type RouteHandler, type RouteOptions, Router, type RuntimeAdapter, type RuntimeFileStat, type RuntimeKind, type RuntimePasswordAdapter, type RuntimeProcess, type RuntimeServeConfig, type RuntimeServer, type RuntimeSpawnOptions, type RuntimeSqliteDatabase, type RuntimeSqliteStatement, type SecurityHeadersOptions, type ServiceKey, type ServiceMap, ServiceProvider, type ShouldBroadcast, type ShouldQueue, StatusCode, Str, TestResponse, ThrottleRequests, type TracingExporter, VERSION, type ValidationError, ValidationException, type ViewService, abort, abortIf, abortUnless, app, blank, bodySizeLimit, codeFromStatus, config, cors, createErrorBag, createGravitoAdapter, createHeaderGate, createHttpTester, createPhotonAdapter, createSqliteDatabase, csrfProtection, dataGet, dataHas, dataSet, dd, defineConfig, deleteCookie, dump, index as engine, env, errors, fail, filled, getCookie, getCsrfToken, getDefaultRetryPolicy, getEventTracing, getMeter, getOpenTelemetrySDK, getTracer as getOtelTracer, getPasswordAdapter, getPresetRetryPolicy, getRuntimeAdapter, getRuntimeEnv, hasApp, index$1 as instrumentation, isHttpAdapter, isOpenTelemetryInitialized, jsonFail, jsonSuccess, logger, messageFromStatus, ok, old, registerGlobalErrorHandlers, requireHeaderToken, resetOpenTelemetry, router, securityHeaders, setApp, setCookie, setupOpenTelemetry, shutdownOpenTelemetry, tap, throwIf, throwUnless, value };
+export { type ActionCallback, type AdapterConfig, type AdapterFactory, type ApiFailure, type ApiSuccess, Application, type ApplicationConfig, Arr, AuthenticationException, AuthorizationException, type BodySizeLimitOptions, type CacheService, type Channel, CircuitBreaker, type CircuitBreakerOptions, CircuitBreakerState, CircularDependencyException, type CommandHandler, CommandKernel, ConfigManager, ConsoleLogger, Container, ContentfulStatusCode, type ControllerClass, CookieJar, type CookieOptions, type CorsOptions, type CorsOrigin, type CsrfOptions, DEFAULT_EVENT_OPTIONS, type DLQEntry, type DLQFilter, type DLQManagerFilter, type DLQRecord, type DLQStats, type DashboardSnapshot, type DataPath, DeadLetterQueue, DeadLetterQueueManager, DumpDieError, type DumpOptions, Encrypter, type EncrypterOptions, type ErrorBag, ErrorHandler, type ErrorHandlerContext, type ErrorHandlerDeps, type ErrorStats, Event, type EventBackend, EventManager, EventMetrics, type EventOptions, EventPriorityQueue, type EventTask, EventTracer, EventTracing, type EventTracingConfig, type ExceptionOptions, FORM_REQUEST_SYMBOL, type Factory$1 as Factory, type FilterCallback, type FormRequestClass, type FormRequestLike, type GlobalErrorHandlersMode, type GlobalProcessErrorHandlerContext, type GlobalProcessErrorKind, GravitoAdapter, type GravitoConfig, GravitoContext, GravitoEngineAdapter, GravitoErrorHandler, GravitoException, GravitoHandler, type GravitoManifest, GravitoMiddleware, GravitoNotFoundHandler, type GravitoOrbit, GravitoRequest, GravitoServer, GravitoVariables, type HeaderTokenGateOptions, type HealthCheck, type HealthCheckResult, HealthProvider, HookManager, type HookManagerConfig, type HstsOptions, type HttpAdapter, HttpException, HttpMethod, HttpTester, type JobEvent, type Listener, type ListenerInfo, type ListenerOptions, type Logger, type MetricsExporter, ModelNotFoundException, DEFAULT_CONFIG as OTEL_DEFAULT_CONFIG, OTEL_ENV_VARS, OTelEventMetrics, type ObservabilityConfig, ObservableHookManager, type OpenTelemetryConfig, type OpenTelemetrySDK, type MetricsConfig as OtelMetricsConfig, type TracingConfig as OtelTracingConfig, type PathSegment, PhotonAdapter, PhotonContextWrapper, PhotonRequestWrapper, PlanetCore, QueueDashboard, type QueueDashboardConfig, type QueueDepthCallback, type QueueMetrics, type WorkerMetrics as QueueWorkerMetrics, type RegisterGlobalErrorHandlersOptions, RequestContext, type RequestContextData, RequestScopeCleanupError, type RequestScopeErrorContext, RequestScopeManager, RequestScopeMetrics, RequestScopeMetricsCollector, type RequestScopeObserver, type RequireHeaderTokenOptions, RetryEngine, type RetryPolicy, Route, type RouteDefinition$1 as RouteDefinition, RouteGroup, type RouteHandler, type RouteOptions, Router, type RuntimeAdapter, type RuntimeFileStat, type RuntimeKind, type RuntimePasswordAdapter, type RuntimeProcess, type RuntimeServeConfig, type RuntimeServer, type RuntimeSpawnOptions, type RuntimeSqliteDatabase, type RuntimeSqliteStatement, type SecurityHeadersOptions, type ServiceKey, type ServiceMap, ServiceProvider, type ShouldBroadcast, type ShouldQueue, StatusCode, Str, TestResponse, ThrottleRequests, type TracingExporter, VERSION, type ValidationError, ValidationException, type ViewService, abort, abortIf, abortUnless, app, blank, bodySizeLimit, cleanupRequestScopeOnError, codeFromStatus, config, cors, createErrorBag, createGravitoAdapter, createHeaderGate, createHttpTester, createPhotonAdapter, createSqliteDatabase, csrfProtection, dataGet, dataHas, dataSet, dd, defineConfig, deleteCookie, detectRequestScopeLeaks, dump, index as engine, env, errors, extractRequestScopeErrorContext, fail, filled, getCookie, getCsrfToken, getDefaultRetryPolicy, getEventTracing, getMeter, getOpenTelemetrySDK, getTracer as getOtelTracer, getPasswordAdapter, getPresetRetryPolicy, getRuntimeAdapter, getRuntimeEnv, hasApp, index$1 as instrumentation, isHttpAdapter, isOpenTelemetryInitialized, jsonFail, jsonSuccess, logger, messageFromStatus, ok, old, registerGlobalErrorHandlers, registerQueueCommands, requireHeaderToken, resetOpenTelemetry, router, securityHeaders, setApp, setCookie, setupOpenTelemetry, shutdownOpenTelemetry, tap, throwIf, throwUnless, value, withRequestScopeCleanup };