@gravito/ripple 4.0.1 → 5.0.0

package/dist/core/src/events/CircuitBreaker.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Event-system CircuitBreaker — standalone copy.
+ *
+ * NOTE: This is intentionally NOT a re-export from @gravito/resilience
+ * to avoid a circular dependency (core <-> resilience):
+ *   @gravito/core -> @gravito/resilience (peerDep of resilience -> core)
+ *
+ * The canonical CB implementation lives in @gravito/resilience.
+ * Keep this file in sync manually if the canonical CB API changes.
+ *
+ * Per D-02 decision recorded in 17-RESEARCH.md.
+ */
 /**
  * Circuit Breaker state enum.
  * @public

package/dist/core/src/events/EventPriorityQueue.d.ts

@@ -1,14 +1,13 @@
 import type { Span } from '@opentelemetry/api';
 import type { ActionCallback } from '../HookManager';
-import { BackpressureManager } from './BackpressureManager';
-import { CircuitBreaker } from './CircuitBreaker';
+import type { BackpressureManager } from './BackpressureManager';
 import type { DeadLetterQueue } from './DeadLetterQueue';
 import type { EventBackend } from './EventBackend';
 import type { EventOptions } from './EventOptions';
 import type { EventMetrics } from './observability/EventMetrics';
 import type { EventTracing } from './observability/EventTracing';
 import type { OTelEventMetrics } from './observability/OTelEventMetrics';
-import { type PriorityStatistics } from './PriorityEscalationManager';
+import type { PriorityStatistics } from './PriorityEscalationManager';
 import type { RetryScheduler } from './RetryScheduler';
 import type { BackpressureStrategy, EventQueueConfig, EventTask, MultiPriorityQueueDepth } from './types';
 import type { WorkerPool } from './WorkerPool';
@@ -23,279 +22,42 @@ export type { EventTask, EventQueueConfig, BackpressureStrategy };
  *
  * Supports automatic priority escalation based on wait time.
  *
+ * Composed of:
+ * - {@link QueueCore}: queue data structures and backpressure logic
+ * - {@link TaskExecutor}: task execution, retry, circuit breaker, DLQ
+ *
  * @internal
  */
 export declare class EventPriorityQueue implements EventBackend {
-    private criticalPriority;
-    private highPriority;
-    private normalPriority;
-    private lowPriority;
+    private queueCore;
+    private taskExecutor;
     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.
-     *
-     * @param dlq - Dead Letter Queue instance
-     */
     setDeadLetterQueue(dlq: DeadLetterQueue): void;
-    /**
-     * Set the persistent DLQ handler for failed events.
-     *
-     * @param handler - Async handler function for persistent DLQ
-     */
     setPersistentDLQHandler(handler: (hook: string, args: unknown, options: EventOptions, error: Error, retryCount: number, firstFailedAt: number) => Promise<void>): void;
-    /**
-     * Set the EventMetrics instance for recording circuit breaker metrics.
-     *
-     * @param metrics - EventMetrics instance
-     * @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.
-     *
-     * @param tracing - EventTracing instance
-     * @internal
-     */
     setEventTracing(tracing: EventTracing): void;
-    /**
-     * Set the current dispatch span for creating child spans.
-     *
-     * @param span - Parent dispatch span
-     * @internal
-     */
     setCurrentDispatchSpan(span: Span | undefined): void;
-    /**
-     * Get the current dispatch span.
-     *
-     * @returns Current dispatch span or undefined
-     * @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.
-     *
-     * @param hook - Event hook name
-     * @param config - Circuit breaker configuration
-     * @returns Circuit breaker instance or undefined if not configured
-     * @internal
-     */
-    private getOrCreateEventCircuitBreaker;
-    /**
-     * Enqueue an event task for processing.
-     *
-     * @param hook - Event hook name
-     * @param args - Event arguments
-     * @param callbacks - Callbacks to execute
-     * @param options - Event options
-     * @returns Task ID
-     */
+    getCircuitBreaker(hook: string): import("@gravito/core").CircuitBreaker | undefined;
+    getCircuitBreakers(): Map<string, import("@gravito/core").CircuitBreaker>;
+    resetCircuitBreaker(hook: string): boolean;
+    setWorkerPool(pool: WorkerPool): void;
+    getWorkerPool(): WorkerPool | undefined;
+    getBackpressureManager(): BackpressureManager | undefined;
     enqueue(task: EventTask): string;
     enqueue(hook: string, args: unknown, callbacks: ActionCallback[], options: EventOptions): string;
-    /**
-     * Handle backpressure when queue is full.
-     * @returns True if space was made, false if event should be dropped
-     */
-    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
-     */
-    private dequeue;
-    /**
-     * Dequeue a task from a priority queue, respecting partition ordering.
-     *
-     * @param queue - Priority queue to dequeue from
-     * @returns Next task to process, or undefined if all tasks are blocked by partition locks
-     * @internal
-     */
-    private dequeueFromPriority;
-    /**
-     * Execute an event task by running all its callbacks.
-     * Implements circuit breaker protection, retry logic with exponential backoff, and DLQ integration.
-     * Also handles partition ordering by acquiring and releasing partition locks.
-     *
-     * @param task - Event task to execute
-     * @internal
-     */
-    private executeTask;
-    /**
-     * Calculate retry delay based on backoff strategy.
-     *
-     * @param retryCount - Current retry attempt number
-     * @param backoff - Backoff strategy
-     * @param initialDelay - Initial delay in ms
-     * @param maxDelay - Maximum delay in ms
-     * @returns Delay in milliseconds
-     * @internal
-     */
-    private calculateRetryDelay;
-    /**
-     * Re-enqueue a task for retry.
-     *
-     * @param task - Task to retry
-     * @internal
-     */
-    private enqueueRetry;
-    /**
-     * Execute a callback with timeout.
-     *
-     * @param callback - Callback to execute
-     * @param args - Arguments to pass to callback
-     * @param timeoutMs - Timeout in milliseconds
-     * @internal
-     */
-    private executeWithTimeout;
-    /**
-     * Get the current depth of the queue.
-     *
-     * @returns Total number of tasks in the queue
-     */
+    enqueueBatch(tasks: EventTask[]): string[];
     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.
-     *
-     * @param pool - WorkerPool instance
-     * @internal
-     */
-    setWorkerPool(pool: WorkerPool): void;
-    /**
-     * Get the WorkerPool instance if set.
-     *
-     * @returns WorkerPool instance or undefined if not set
-     * @internal
-     */
-    getWorkerPool(): WorkerPool | undefined;
-    /**
-     * Clear all tasks from the queue.
-     */
-    clear(): void;
-    /**
-     * Get circuit breaker for an event hook.
-     *
-     * @param hook - Event hook name
-     * @returns Circuit breaker instance or undefined
-     * @internal
-     */
-    getCircuitBreaker(hook: string): CircuitBreaker | undefined;
-    /**
-     * Get all circuit breakers.
-     *
-     * @returns Map of circuit breakers keyed by hook name
-     * @internal
-     */
-    getCircuitBreakers(): Map<string, CircuitBreaker>;
-    /**
-     * Reset a circuit breaker for an event hook.
-     *
-     * @param hook - Event hook name
-     * @returns True if reset, false if circuit breaker not found
-     * @internal
-     */
-    resetCircuitBreaker(hook: string): boolean;
-    /**
-     * Batch enqueue multiple tasks (FS-102).
-     * Supports aggregation layer batch submission.
-     *
-     * @param tasks - Array of tasks to enqueue
-     * @returns Array of task IDs
-     * @internal
-     */
-    enqueueBatch(tasks: EventTask[]): string[];
-    /**
-     * Get queue depth for each priority level (FS-103).
-     * Used by BackpressureManager for multi-priority depth monitoring.
-     *
-     * @returns Queue depth snapshot with depths for each priority
-     * @internal
-     */
     getQueueDepthByPriority(): MultiPriorityQueueDepth;
-    /**
-     * Sync queue depth to BackpressureManager (FS-103).
-     * Called whenever queue depth changes to keep BackpressureManager
-     * synchronized with real-time queue state.
-     *
-     * @private
-     * @internal
-     */
-    private syncBackpressure;
+    clear(): void;
+    dequeue(): EventTask | undefined;
+    private processNext;
 }

package/dist/core/src/events/index.d.ts

@@ -2,24 +2,25 @@
  * Event system exports for async event dispatch.
  * @packageDocumentation
  */
+export * from './EventBackend';
+export type { EventOptions } from './EventOptions';
+export { DEFAULT_EVENT_OPTIONS } from './EventOptions';
+export type { BackpressureStrategy, EventQueueConfig, EventTask } from './types';
 export type { BackpressureConfig, BackpressureDecision, BackpressureMetricsSnapshot, } from './BackpressureManager';
 export { BackpressureManager, BackpressureState } from './BackpressureManager';
-export type { CircuitBreakerOptions } from './CircuitBreaker';
+export type { CircuitBreakerMetrics, CircuitBreakerMetricsRecorder, CircuitBreakerOptions, } from './CircuitBreaker';
 export { CircuitBreaker, CircuitBreakerState } from './CircuitBreaker';
-export type { DLQEntry, DLQFilter } from './DeadLetterQueue';
+export type { DLQEntry, DLQEntryCallback, DLQEntrySource, DLQFilter } from './DeadLetterQueue';
 export { DeadLetterQueue } from './DeadLetterQueue';
-export * from './EventBackend';
-export type { EventOptions } from './EventOptions';
-export { DEFAULT_EVENT_OPTIONS } from './EventOptions';
 export { EventPriorityQueue } from './EventPriorityQueue';
-export type { FlowControlContext, FlowControlStrategy } from './FlowControlStrategy';
-export { CompositeStrategy, createDefaultStrategies, PriorityRebalanceStrategy, QueueDepthStrategy, RateLimitStrategy, StarvationProtectionStrategy, } from './FlowControlStrategy';
-export type { EventStatus, MessageQueueBridgeConfig } from './MessageQueueBridge';
+export * from './FlowControlStrategy';
+export { IdempotencyCache } from './IdempotencyCache';
 export { MessageQueueBridge } from './MessageQueueBridge';
-export * from './observability';
-export type { QueueStats, RetrySchedulerConfig } from './RetryScheduler';
+export type { PriorityStatistics } from './PriorityEscalationManager';
+export { PriorityEscalationManager } from './PriorityEscalationManager';
+export type { RetrySchedulerConfig } from './RetryScheduler';
 export { RetryScheduler } from './RetryScheduler';
-export type { BackpressureStrategy, EventQueueConfig, EventTask } from './types';
+export type { DeadLetterDecision, MultiPriorityQueueDepth, WindowAdjustment } from './types';
 export { WorkerPool } from './WorkerPool';
 export type { WorkerPoolConfig, WorkerPoolStats, WorkerStats } from './WorkerPoolConfig';
 export { WorkerPoolMetrics } from './WorkerPoolMetrics';

package/dist/core/src/events/queue-core.d.ts

@@ -0,0 +1,77 @@
+import { BackpressureManager } from './BackpressureManager';
+import type { DeadLetterQueue } from './DeadLetterQueue';
+import type { OTelEventMetrics } from './observability/OTelEventMetrics';
+import { type PriorityStatistics } from './PriorityEscalationManager';
+import type { BackpressureStrategy, EventQueueConfig, EventTask, MultiPriorityQueueDepth } from './types';
+/**
+ * Result of an enqueue operation.
+ *
+ * - `{ status: 'queued', id }` - Task successfully queued
+ * - `{ status: 'dropped' }` - Task dropped due to backpressure
+ * - `{ status: 'delayed', id, delayMs }` - Task should be re-enqueued after delayMs
+ *
+ * @internal
+ */
+export type EnqueueResult = {
+    status: 'queued';
+    id: string;
+} | {
+    status: 'dropped';
+} | {
+    status: 'delayed';
+    id: string;
+    delayMs: number;
+};
+/**
+ * Priority queue core: manages event task queues and backpressure.
+ *
+ * Handles enqueueing, dequeuing, backpressure logic, and priority escalation.
+ * This class is used internally by EventPriorityQueue as a composition target.
+ *
+ * @internal
+ */
+export declare class QueueCore {
+    criticalPriority: EventTask[];
+    highPriority: EventTask[];
+    normalPriority: EventTask[];
+    lowPriority: EventTask[];
+    processingPartitions: Set<string>;
+    private taskIdCounter;
+    private dlq?;
+    private otelEventMetrics?;
+    private backpressureManager?;
+    private priorityStats?;
+    private config;
+    constructor(config?: EventQueueConfig);
+    setDeadLetterQueue(dlq: DeadLetterQueue): void;
+    setOTelEventMetrics(metrics: OTelEventMetrics): void;
+    setPriorityStatistics(stats: PriorityStatistics): void;
+    getPriorityStatistics(): PriorityStatistics | undefined;
+    getBackpressureManager(): BackpressureManager | undefined;
+    getConfig(): EventQueueConfig;
+    getDLQ(): DeadLetterQueue | undefined;
+    createTaskId(): string;
+    /**
+     * Enqueue a task into the appropriate priority queue.
+     * Applies priority escalation and backpressure logic.
+     */
+    enqueue(task: EventTask): EnqueueResult;
+    /**
+     * Dequeue the next task based on priority and partition ordering.
+     * Priority order: CRITICAL > HIGH > NORMAL > LOW
+     */
+    dequeue(): EventTask | undefined;
+    /**
+     * Re-enqueue a task for retry.
+     */
+    enqueueRetry(task: EventTask): void;
+    getDepth(): number;
+    getDepthByPriority(priority: 'critical' | 'high' | 'normal' | 'low'): number;
+    getQueueDepthByPriority(): MultiPriorityQueueDepth;
+    clear(): void;
+    syncBackpressure(): void;
+    private handleBackpressure;
+    private dropOldest;
+    private dequeueFromPriority;
+}
+export type { BackpressureStrategy, EventQueueConfig, EventTask };

package/dist/core/src/events/task-executor.d.ts

@@ -0,0 +1,51 @@
+import type { Span } from '@opentelemetry/api';
+import { CircuitBreaker } from './CircuitBreaker';
+import type { DeadLetterQueue } from './DeadLetterQueue';
+import type { EventOptions } from './EventOptions';
+import type { EventMetrics } from './observability/EventMetrics';
+import type { EventTracing } from './observability/EventTracing';
+import type { OTelEventMetrics } from './observability/OTelEventMetrics';
+import type { RetryScheduler } from './RetryScheduler';
+import type { EventTask } from './types';
+/**
+ * Executes event tasks with circuit breaker protection, retry logic,
+ * exponential backoff, DLQ integration, and distributed tracing.
+ *
+ * @internal
+ */
+export declare class TaskExecutor {
+    private eventCircuitBreakers;
+    private eventMetrics?;
+    private otelEventMetrics?;
+    private eventTracing?;
+    private currentDispatchSpan?;
+    private retryScheduler?;
+    private dlq?;
+    private persistentDLQHandler?;
+    private enqueueRetryFn?;
+    setDeadLetterQueue(dlq: DeadLetterQueue): void;
+    setPersistentDLQHandler(handler: (hook: string, args: unknown, options: EventOptions, error: Error, retryCount: number, firstFailedAt: number) => Promise<void>): void;
+    setEventMetrics(metrics: EventMetrics): void;
+    setOTelEventMetrics(metrics: OTelEventMetrics): void;
+    setEventTracing(tracing: EventTracing): void;
+    setCurrentDispatchSpan(span: Span | undefined): void;
+    getCurrentDispatchSpan(): Span | undefined;
+    setRetryScheduler(scheduler: RetryScheduler): void;
+    getRetryScheduler(): RetryScheduler | undefined;
+    /**
+     * Set the callback to use when re-enqueueing a task after a retry delay.
+     */
+    setEnqueueRetryFn(fn: (task: EventTask) => void): void;
+    getCircuitBreaker(hook: string): CircuitBreaker | undefined;
+    getCircuitBreakers(): Map<string, CircuitBreaker>;
+    resetCircuitBreaker(hook: string): boolean;
+    /**
+     * Execute an event task by running all its callbacks.
+     * Implements circuit breaker protection, retry logic, and DLQ integration.
+     */
+    executeTask(task: EventTask, processingPartitions: Set<string>): Promise<void>;
+    private sendToDLQ;
+    private getOrCreateEventCircuitBreaker;
+    private calculateRetryDelay;
+    private executeWithTimeout;
+}

package/dist/core/src/exceptions/AuthException.d.ts

@@ -0,0 +1,10 @@
+import { type ExceptionOptions } from './GravitoException';
+import { DomainException } from './DomainException';
+/**
+ * Abstract base class for authentication/authorization-related domain errors.
+ * Used by fortify and sentinel packages.
+ * @public
+ */
+export declare abstract class AuthException extends DomainException {
+    constructor(status: number, code: string, options?: ExceptionOptions);
+}

package/dist/core/src/exceptions/AuthenticationException.d.ts

@@ -1,8 +1,8 @@
-import { GravitoException } from './GravitoException';
+import { DomainException } from './DomainException';
 /**
  * Exception thrown when authentication fails.
  * @public
  */
-export declare class AuthenticationException extends GravitoException {
+export declare class AuthenticationException extends DomainException {
     constructor(message?: string);
 }

package/dist/core/src/exceptions/AuthorizationException.d.ts

@@ -1,8 +1,8 @@
-import { GravitoException } from './GravitoException';
+import { DomainException } from './DomainException';
 /**
  * Exception thrown when user is not authorized to perform an action.
  * @public
  */
-export declare class AuthorizationException extends GravitoException {
+export declare class AuthorizationException extends DomainException {
     constructor(message?: string);
 }

package/dist/core/src/exceptions/CacheException.d.ts

@@ -0,0 +1,9 @@
+import { InfrastructureException, type InfrastructureExceptionOptions } from './InfrastructureException';
+/**
+ * Abstract base class for cache/Redis-related infrastructure errors.
+ * All plasma error classes extend this instead of bare Error.
+ * @public
+ */
+export declare abstract class CacheException extends InfrastructureException {
+    constructor(status: number, code: string, options?: InfrastructureExceptionOptions);
+}

package/dist/core/src/exceptions/CircularDependencyException.d.ts

@@ -1,9 +1,10 @@
 import type { ServiceKey } from '../Container';
+import { SystemException } from './SystemException';
 /**
  * CircularDependencyException - Thrown when the container detects an infinite loop.
  *
  * @module @gravito/core
  */
-export declare class CircularDependencyException extends Error {
+export declare class CircularDependencyException extends SystemException {
     constructor(key: ServiceKey, stack: ServiceKey[]);
 }

package/dist/core/src/exceptions/ConfigurationException.d.ts

@@ -0,0 +1,9 @@
+import { type ExceptionOptions } from './GravitoException';
+import { SystemException } from './SystemException';
+/**
+ * Thrown when the framework encounters an invalid or missing configuration value.
+ * @public
+ */
+export declare class ConfigurationException extends SystemException {
+    constructor(message: string, options?: Omit<ExceptionOptions, 'message'>);
+}

package/dist/core/src/exceptions/DatabaseException.d.ts

@@ -0,0 +1,9 @@
+import { InfrastructureException, type InfrastructureExceptionOptions } from './InfrastructureException';
+/**
+ * Abstract base class for database-related infrastructure errors.
+ * All atlas error classes extend this instead of bare Error.
+ * @public
+ */
+export declare abstract class DatabaseException extends InfrastructureException {
+    constructor(status: number, code: string, options?: InfrastructureExceptionOptions);
+}

package/dist/core/src/exceptions/DomainException.d.ts

@@ -0,0 +1,9 @@
+import { type ExceptionOptions, GravitoException } from './GravitoException';
+/**
+ * Abstract base class for business logic / domain rule violations.
+ * Extend this for exceptions that represent a caller mistake (invalid input, constraint violation, etc.).
+ * @public
+ */
+export declare abstract class DomainException extends GravitoException {
+    constructor(status: number, code: string, options?: ExceptionOptions);
+}

package/dist/core/src/exceptions/InfrastructureException.d.ts

@@ -0,0 +1,17 @@
+import { type ExceptionOptions, GravitoException } from './GravitoException';
+/**
+ * Options for creating an InfrastructureException
+ * @public
+ */
+export interface InfrastructureExceptionOptions extends ExceptionOptions {
+    retryable?: boolean;
+}
+/**
+ * Abstract base class for infrastructure / I/O errors (database, network, filesystem, etc.).
+ * Carries a `retryable` flag that callers can inspect to decide whether the operation should be retried.
+ * @public
+ */
+export declare abstract class InfrastructureException extends GravitoException {
+    readonly retryable: boolean;
+    constructor(status: number, code: string, options?: InfrastructureExceptionOptions);
+}

package/dist/core/src/exceptions/QueueException.d.ts

@@ -0,0 +1,9 @@
+import { InfrastructureException, type InfrastructureExceptionOptions } from './InfrastructureException';
+/**
+ * Abstract base class for message queue infrastructure errors.
+ * Used by quasar and flux packages.
+ * @public
+ */
+export declare abstract class QueueException extends InfrastructureException {
+    constructor(status: number, code: string, options?: InfrastructureExceptionOptions);
+}

package/dist/core/src/exceptions/StorageException.d.ts

@@ -0,0 +1,9 @@
+import { InfrastructureException, type InfrastructureExceptionOptions } from './InfrastructureException';
+/**
+ * Abstract base class for file/object storage infrastructure errors.
+ * Used by constellation, nebula, nebula-s3, freeze, stasis packages.
+ * @public
+ */
+export declare abstract class StorageException extends InfrastructureException {
+    constructor(status: number, code: string, options?: InfrastructureExceptionOptions);
+}

package/dist/core/src/exceptions/StreamException.d.ts

@@ -0,0 +1,9 @@
+import { InfrastructureException, type InfrastructureExceptionOptions } from './InfrastructureException';
+/**
+ * Abstract base class for stream/message processing infrastructure errors.
+ * Used by the stream package (Kafka, RabbitMQ, SQS).
+ * @public
+ */
+export declare abstract class StreamException extends InfrastructureException {
+    constructor(status: number, code: string, options?: InfrastructureExceptionOptions);
+}

package/dist/core/src/exceptions/SystemException.d.ts

@@ -0,0 +1,9 @@
+import { type ExceptionOptions, GravitoException } from './GravitoException';
+/**
+ * Abstract base class for internal framework / system-level errors.
+ * Extend this for exceptions that represent an unexpected or unrecoverable framework state.
+ * @public
+ */
+export declare abstract class SystemException extends GravitoException {
+    constructor(status: number, code: string, options?: ExceptionOptions);
+}

package/dist/core/src/exceptions/ValidationException.d.ts

@@ -1,4 +1,4 @@
-import { GravitoException } from './GravitoException';
+import { DomainException } from './DomainException';
 /**
  * Structure of a validation error
  * @public
@@ -12,7 +12,7 @@ export interface ValidationError {
  * Exception thrown when data validation fails.
  * @public
  */
-export declare class ValidationException extends GravitoException {
+export declare class ValidationException extends DomainException {
     readonly errors: ValidationError[];
     redirectTo?: string;
     input?: unknown;