@asenajs/asena 0.4.0 → 0.6.0-beta.0

package/dist/lib/server/event/EventEmitter.d.ts

@@ -0,0 +1,67 @@
+import type { ICoreService } from '../../ioc';
+/**
+ * @description Event Emitter - Public API for event-driven architecture
+ *
+ * Architecture:
+ * - EventEmitter (public API) → EventDispatchService (internal logic)
+ * - Similar pattern to: AsenaWebSocketService → AsenaWebSocketServer
+ *
+ * Usage:
+ * ```typescript
+ * // In your code
+ * @Inject(emitter())
+ * private emitter!: EventEmitter;
+ *
+ * // Emit events
+ * this.emitter.emit('user.created', { id: 123, name: 'John' });
+ * ```
+ *
+ * Event handlers are registered via decorators:
+ * ```typescript
+ * @EventService({ prefix: 'user' })
+ * export class UserEventService {
+ *   @On('created')
+ *   handleUserCreated(eventName: string, data: any) {
+ *     // Handle event
+ *   }
+ * }
+ * ```
+ *
+ * Fire-and-Forget Pattern:
+ * - emit() returns immediately (doesn't wait for handlers)
+ * - Async handlers are executed without blocking
+ * - Handler errors are isolated and logged
+ *
+ * @see EventDispatchService for internal implementation details
+ */
+export declare class EventEmitter implements ICoreService {
+    readonly serviceName = "EventEmitter";
+    private dispatcher;
+    /**
+     * Emit an event to all registered handlers
+     *
+     * Fire-and-forget pattern (Spring style):
+     * - Returns immediately without waiting for handlers
+     * - Async handlers execute in background
+     * - Handler errors are caught and logged
+     *
+     * @param eventName - Event name to emit (e.g., 'user.created', 'download.complete')
+     * @param data - Optional data to pass to handlers
+     * @returns true if any handler was called, false if no handlers matched
+     *
+     * @example
+     * // Emit event with data
+     * const success = this.emitter.emit('user.created', { id: 123, name: 'John' });
+     *
+     * @example
+     * // Emit event without data
+     * this.emitter.emit('app.started');
+     *
+     * @example
+     * // Check if event was handled
+     * if (!this.emitter.emit('user.created', data)) {
+     *   console.warn('No handlers registered for user.created event');
+     * }
+     */
+    emit(eventName: string, data?: any): boolean;
+}

package/dist/lib/server/event/EventEmitter.js

@@ -0,0 +1,88 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { CoreService, ICoreServiceNames } from '../../ioc';
+import { Inject } from '../../ioc/component';
+/**
+ * @description Event Emitter - Public API for event-driven architecture
+ *
+ * Architecture:
+ * - EventEmitter (public API) → EventDispatchService (internal logic)
+ * - Similar pattern to: AsenaWebSocketService → AsenaWebSocketServer
+ *
+ * Usage:
+ * ```typescript
+ * // In your code
+ * @Inject(emitter())
+ * private emitter!: EventEmitter;
+ *
+ * // Emit events
+ * this.emitter.emit('user.created', { id: 123, name: 'John' });
+ * ```
+ *
+ * Event handlers are registered via decorators:
+ * ```typescript
+ * @EventService({ prefix: 'user' })
+ * export class UserEventService {
+ *   @On('created')
+ *   handleUserCreated(eventName: string, data: any) {
+ *     // Handle event
+ *   }
+ * }
+ * ```
+ *
+ * Fire-and-Forget Pattern:
+ * - emit() returns immediately (doesn't wait for handlers)
+ * - Async handlers are executed without blocking
+ * - Handler errors are isolated and logged
+ *
+ * @see EventDispatchService for internal implementation details
+ */
+let EventEmitter = class EventEmitter {
+    serviceName = 'EventEmitter';
+    dispatcher;
+    /**
+     * Emit an event to all registered handlers
+     *
+     * Fire-and-forget pattern (Spring style):
+     * - Returns immediately without waiting for handlers
+     * - Async handlers execute in background
+     * - Handler errors are caught and logged
+     *
+     * @param eventName - Event name to emit (e.g., 'user.created', 'download.complete')
+     * @param data - Optional data to pass to handlers
+     * @returns true if any handler was called, false if no handlers matched
+     *
+     * @example
+     * // Emit event with data
+     * const success = this.emitter.emit('user.created', { id: 123, name: 'John' });
+     *
+     * @example
+     * // Emit event without data
+     * this.emitter.emit('app.started');
+     *
+     * @example
+     * // Check if event was handled
+     * if (!this.emitter.emit('user.created', data)) {
+     *   console.warn('No handlers registered for user.created event');
+     * }
+     */
+    emit(eventName, data) {
+        return this.dispatcher.dispatch(eventName, data);
+    }
+};
+__decorate([
+    Inject(ICoreServiceNames.EVENT_DISPATCH_SERVICE),
+    __metadata("design:type", Function)
+], EventEmitter.prototype, "dispatcher", void 0);
+EventEmitter = __decorate([
+    CoreService(ICoreServiceNames.EVENT_EMITTER)
+], EventEmitter);
+export { EventEmitter };
+//# sourceMappingURL=EventEmitter.js.map

package/dist/lib/server/event/EventEmitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventEmitter.js","sourceRoot":"","sources":["../../../../lib/server/event/EventEmitter.ts"],"names":[],"mappings":";;;;;;;;;AACA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEI,IAAM,YAAY,GAAlB,MAAM,YAAY;IACP,WAAW,GAAG,cAAc,CAAC;IAGrC,UAAU,CAAwB;IAE1C;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,IAAI,CAAC,SAAiB,EAAE,IAAU;QACvC,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IACnD,CAAC;CACF,CAAA;AA/BS;IADP,MAAM,CAAC,iBAAiB,CAAC,sBAAsB,CAAC;;gDACP;AAJ/B,YAAY;IADxB,WAAW,CAAC,iBAAiB,CAAC,aAAa,CAAC;GAChC,YAAY,CAmCxB"}

package/dist/lib/server/event/EventService.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A service class for handling Events.
+ */
+export declare class AsenaEventHandler {
+}

package/dist/lib/server/event/EventService.js

@@ -0,0 +1,6 @@
+/**
+ * A service class for handling Events.
+ */
+export class AsenaEventHandler {
+}
+//# sourceMappingURL=EventService.js.map

package/dist/lib/server/event/EventService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventService.js","sourceRoot":"","sources":["../../../../lib/server/event/EventService.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,OAAO,iBAAiB;CAAG"}

package/dist/lib/server/event/decorators/On.d.ts

@@ -0,0 +1,38 @@
+import type { OnParams } from '../types';
+/**
+ * @description On decorator - Marks a method as an event handler
+ *
+ * Methods decorated with @On will be automatically registered when
+ * the event system boots up (via PrepareEventService).
+ *
+ * @param params - Event pattern or configuration object
+ *
+ * @example
+ * @EventService({ prefix: 'user' })
+ * export class UserEventService {
+ *   @On('created')  // Handles 'user.created'
+ *   handleCreated(eventName: string, data: any) {
+ *     console.log('User created:', data);
+ *   }
+ *
+ *   @On('*.updated')  // Handles 'user.*.updated'
+ *   handleUpdated(eventName: string, data: any) { }
+ *
+ *   @On({ event: 'deleted', skip: true })  // Temporarily disabled
+ *   handleDeleted(eventName: string, data: any) { }
+ * }
+ *
+ * @example
+ * // Without prefix (absolute pattern)
+ * @EventService()
+ * export class GlobalEventService {
+ *   @On('*')  // Handles ALL events
+ *   handleAll(eventName: string, data: any) {
+ *     console.log('Event:', eventName);
+ *   }
+ *
+ *   @On('*.error')  // Handles all error events
+ *   handleErrors(eventName: string, data: any) { }
+ * }
+ */
+export declare function On(params: OnParams | string): MethodDecorator;

package/dist/lib/server/event/decorators/On.js

@@ -0,0 +1,56 @@
+import { ComponentConstants } from '../../../ioc';
+import { defineTypedMetadata, getOwnTypedMetadata } from '../../../utils';
+/**
+ * @description On decorator - Marks a method as an event handler
+ *
+ * Methods decorated with @On will be automatically registered when
+ * the event system boots up (via PrepareEventService).
+ *
+ * @param params - Event pattern or configuration object
+ *
+ * @example
+ * @EventService({ prefix: 'user' })
+ * export class UserEventService {
+ *   @On('created')  // Handles 'user.created'
+ *   handleCreated(eventName: string, data: any) {
+ *     console.log('User created:', data);
+ *   }
+ *
+ *   @On('*.updated')  // Handles 'user.*.updated'
+ *   handleUpdated(eventName: string, data: any) { }
+ *
+ *   @On({ event: 'deleted', skip: true })  // Temporarily disabled
+ *   handleDeleted(eventName: string, data: any) { }
+ * }
+ *
+ * @example
+ * // Without prefix (absolute pattern)
+ * @EventService()
+ * export class GlobalEventService {
+ *   @On('*')  // Handles ALL events
+ *   handleAll(eventName: string, data: any) {
+ *     console.log('Event:', eventName);
+ *   }
+ *
+ *   @On('*.error')  // Handles all error events
+ *   handleErrors(eventName: string, data: any) { }
+ * }
+ */
+export function On(params) {
+    // Normalize params - support both object and string
+    const _params = typeof params === 'string' ? { event: params, skip: false } : params;
+    return function (target, propertyKey, descriptor) {
+        // Get existing handlers metadata (other @On methods)
+        const handlers = getOwnTypedMetadata(ComponentConstants.EventHandlersKey, target.constructor) || {};
+        // Add this handler's metadata
+        handlers[propertyKey.toString()] = {
+            pattern: _params.event,
+            methodName: propertyKey.toString(),
+            skip: _params.skip || false,
+        };
+        // Store updated metadata
+        defineTypedMetadata(ComponentConstants.EventHandlersKey, handlers, target.constructor);
+        return descriptor;
+    };
+}
+//# sourceMappingURL=On.js.map

package/dist/lib/server/event/decorators/On.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"On.js","sourceRoot":"","sources":["../../../../../lib/server/event/decorators/On.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAG1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,UAAU,EAAE,CAAC,MAAyB;IAC1C,oDAAoD;IACpD,MAAM,OAAO,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;IAErF,OAAO,UAAU,MAAc,EAAE,WAA4B,EAAE,UAA8B;QAC3F,qDAAqD;QACrD,MAAM,QAAQ,GACZ,mBAAmB,CACjB,kBAAkB,CAAC,gBAAgB,EACnC,MAAM,CAAC,WAAW,CACnB,IAAI,EAAE,CAAC;QAEV,8BAA8B;QAC9B,QAAQ,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,GAAG;YACjC,OAAO,EAAE,OAAO,CAAC,KAAK;YACtB,UAAU,EAAE,WAAW,CAAC,QAAQ,EAAE;YAClC,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,KAAK;SAC5B,CAAC;QAEF,yBAAyB;QACzB,mBAAmB,CAAC,kBAAkB,CAAC,gBAAgB,EAAE,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;QAEvF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC"}

package/dist/lib/server/event/decorators/index.d.ts

@@ -0,0 +1 @@
+export * from './On';

package/dist/lib/server/event/decorators/index.js

@@ -0,0 +1,2 @@
+export * from './On';
+//# sourceMappingURL=index.js.map

package/dist/lib/server/event/decorators/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../lib/server/event/decorators/index.ts"],"names":[],"mappings":"AAAA,cAAc,MAAM,CAAC"}

package/dist/lib/server/event/emitter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @description Utility for injecting EventEmitter
+ *
+ * Returns the EventEmitter service key for use with @Inject decorator.
+ *
+ * @returns The EventEmitter service key
+ *
+ * @example
+ * ```typescript
+ * @Service()
+ * export class UserService {
+ *   @Inject(emitter())
+ *   private emitter!: EventEmitter;
+ *
+ *   createUser(name: string) {
+ *     this.emitter.emit('user.created', { name });
+ *   }
+ * }
+ * ```
+ */
+export declare function emitter(): string;

package/dist/lib/server/event/emitter.js

@@ -0,0 +1,25 @@
+import { ICoreServiceNames } from '../../ioc';
+/**
+ * @description Utility for injecting EventEmitter
+ *
+ * Returns the EventEmitter service key for use with @Inject decorator.
+ *
+ * @returns The EventEmitter service key
+ *
+ * @example
+ * ```typescript
+ * @Service()
+ * export class UserService {
+ *   @Inject(emitter())
+ *   private emitter!: EventEmitter;
+ *
+ *   createUser(name: string) {
+ *     this.emitter.emit('user.created', { name });
+ *   }
+ * }
+ * ```
+ */
+export function emitter() {
+    return ICoreServiceNames.EVENT_EMITTER;
+}
+//# sourceMappingURL=emitter.js.map

package/dist/lib/server/event/emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.js","sourceRoot":"","sources":["../../../../lib/server/event/emitter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,OAAO;IACrB,OAAO,iBAAiB,CAAC,aAAa,CAAC;AACzC,CAAC"}

package/dist/lib/server/event/eventPatternMatcher.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @description Zero-dependency event pattern matcher for Asena event system
+ * Supports dot-notation wildcard patterns for event matching
+ *
+ * Pattern examples:
+ * - `*` matches all events
+ * - `download.*` matches `download.start`, `download.complete`, etc.
+ * - `*.complete` matches any event ending with `.complete`
+ * - `user.*.created` matches `user.admin.created`, `user.guest.created`, etc.
+ *
+ * Algorithm: Iterative backtracking with explicit stack
+ * Time Complexity: O(n * m) where n = event segments, m = pattern segments
+ * Space Complexity: O(n + m) for the stack
+ *
+ * @param eventName - The event name to test (e.g., 'download.complete')
+ * @param pattern - The pattern to match against (e.g., 'download.*', '*.complete')
+ * @returns true if the event name matches the pattern
+ *
+ * @example
+ * matchesEventPattern('download.complete', 'download.*') // => true
+ * matchesEventPattern('user.admin.created', 'user.*.created') // => true
+ * matchesEventPattern('upload.start', 'download.*') // => false
+ */
+export declare function matchesEventPattern(eventName: string, pattern: string): boolean;

package/dist/lib/server/event/eventPatternMatcher.js

@@ -0,0 +1,112 @@
+/**
+ * @description Zero-dependency event pattern matcher for Asena event system
+ * Supports dot-notation wildcard patterns for event matching
+ *
+ * Pattern examples:
+ * - `*` matches all events
+ * - `download.*` matches `download.start`, `download.complete`, etc.
+ * - `*.complete` matches any event ending with `.complete`
+ * - `user.*.created` matches `user.admin.created`, `user.guest.created`, etc.
+ *
+ * Algorithm: Iterative backtracking with explicit stack
+ * Time Complexity: O(n * m) where n = event segments, m = pattern segments
+ * Space Complexity: O(n + m) for the stack
+ *
+ * @param eventName - The event name to test (e.g., 'download.complete')
+ * @param pattern - The pattern to match against (e.g., 'download.*', '*.complete')
+ * @returns true if the event name matches the pattern
+ *
+ * @example
+ * matchesEventPattern('download.complete', 'download.*') // => true
+ * matchesEventPattern('user.admin.created', 'user.*.created') // => true
+ * matchesEventPattern('upload.start', 'download.*') // => false
+ */
+export function matchesEventPattern(eventName, pattern) {
+    // Exact match (fast path)
+    if (eventName === pattern) {
+        return true;
+    }
+    // Universal wildcard matches all events
+    if (pattern === '*') {
+        return true;
+    }
+    // No wildcard in pattern means exact match only (already checked above)
+    if (!pattern.includes('*')) {
+        return false;
+    }
+    // Split both event and pattern by dots
+    const eventSegments = eventName.split('.');
+    const patternSegments = pattern.split('.');
+    // Use iterative backtracking algorithm to avoid recursion
+    return matchSegmentsIterative(eventSegments, patternSegments);
+}
+/**
+ * @description Iteratively matches event segments against pattern segments using backtracking
+ * Uses explicit stack to avoid recursion and prevent stack overflow
+ *
+ * Algorithm explanation:
+ * 1. Maintain a stack of (eventIndex, patternIndex) states to explore
+ * 2. For each state, try to match current segments
+ * 3. On wildcard, push multiple potential states (greedy matching)
+ * 4. On exact match, advance both indices
+ * 5. If we reach end of both arrays, success
+ *
+ * @param eventSegments - Array of event name segments
+ * @param patternSegments - Array of pattern segments
+ * @returns true if segments match
+ */
+function matchSegmentsIterative(eventSegments, patternSegments) {
+    // Stack for backtracking - holds states to explore
+    const stack = [{ eventIndex: 0, patternIndex: 0 }];
+    // Explored states to avoid infinite loops (eventIndex + patternIndex as key)
+    const explored = new Set();
+    while (stack.length > 0) {
+        const state = stack.pop();
+        const { eventIndex, patternIndex } = state;
+        // Create unique key for this state to avoid re-exploring
+        const stateKey = `${eventIndex}:${patternIndex}`;
+        if (explored.has(stateKey)) {
+            continue;
+        }
+        explored.add(stateKey);
+        // Success: consumed both arrays completely
+        if (eventIndex === eventSegments.length && patternIndex === patternSegments.length) {
+            return true;
+        }
+        // Failure: pattern exhausted but event has more segments
+        if (patternIndex === patternSegments.length) {
+            continue;
+        }
+        // Failure: event exhausted but pattern has more segments
+        // (Wildcards require at least one segment to match)
+        if (eventIndex === eventSegments.length) {
+            continue;
+        }
+        const currentPattern = patternSegments[patternIndex];
+        // Case 1: Current pattern is wildcard
+        if (currentPattern === '*') {
+            // If this is the last pattern segment, wildcard must match all remaining event segments
+            if (patternIndex === patternSegments.length - 1) {
+                // Must have at least one event segment remaining
+                if (eventIndex < eventSegments.length) {
+                    return true;
+                }
+                continue;
+            }
+            // Try matching wildcard with 1, 2, 3... event segments (greedy backtracking)
+            // Push states in reverse order so we try shortest match first (better performance)
+            for (let i = eventSegments.length - 1; i >= eventIndex; i--) {
+                stack.push({ eventIndex: i + 1, patternIndex: patternIndex + 1 });
+            }
+            continue;
+        }
+        // Case 2: Current pattern is not wildcard - must match exactly
+        if (eventSegments[eventIndex] === currentPattern) {
+            stack.push({ eventIndex: eventIndex + 1, patternIndex: patternIndex + 1 });
+        }
+        // No match, this path fails (don't push any new state)
+    }
+    // No path led to success
+    return false;
+}
+//# sourceMappingURL=eventPatternMatcher.js.map

package/dist/lib/server/event/eventPatternMatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventPatternMatcher.js","sourceRoot":"","sources":["../../../../lib/server/event/eventPatternMatcher.ts"],"names":[],"mappings":"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"}

package/dist/lib/server/event/index.d.ts

@@ -0,0 +1,6 @@
+export { EventEmitter } from './EventEmitter';
+export { EventDispatchService } from './EventDispatchService';
+export { matchesEventPattern } from './eventPatternMatcher';
+export { emitter } from './emitter';
+export * from './types';
+export * from './decorators';

package/dist/lib/server/event/index.js

@@ -0,0 +1,12 @@
+// Core event system
+export { EventEmitter } from './EventEmitter';
+export { EventDispatchService } from './EventDispatchService';
+// Pattern matcher (utility)
+export { matchesEventPattern } from './eventPatternMatcher';
+// Injection utility
+export { emitter } from './emitter';
+// Types
+export * from './types';
+// Decorators
+export * from './decorators';
+//# sourceMappingURL=index.js.map

package/dist/lib/server/event/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../lib/server/event/index.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D,4BAA4B;AAC5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,oBAAoB;AACpB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,QAAQ;AACR,cAAc,SAAS,CAAC;AAExB,aAAa;AACb,cAAc,cAAc,CAAC"}

package/dist/lib/server/event/types.d.ts

@@ -0,0 +1,70 @@
+import type { ComponentParams } from '../../ioc';
+/**
+ * @description Parameters for @EventService decorator
+ * Defines event service configuration including prefix for pattern matching
+ */
+export interface EventServiceParams extends ComponentParams {
+    /**
+     * Prefix for event patterns (used in pattern matching)
+     * @example 'download' for events like 'download.start', 'download.complete'
+     */
+    prefix?: string;
+}
+/**
+ * @description Parameters for @On method decorator
+ * Defines event handler configuration
+ */
+export interface OnParams {
+    /**
+     * Event pattern to listen for
+     * Supports wildcards: *, download.*, *.complete, user.*.created
+     * @example 'download.complete' or 'download.*'
+     */
+    event: string;
+    /**
+     * Skip this handler (useful for temporarily disabling handlers)
+     * @default false
+     */
+    skip?: boolean;
+}
+/**
+ * @description Metadata stored for each event handler method
+ * Used by PrepareEventService to register handlers
+ */
+export interface EventHandlerMetadata {
+    /**
+     * Event pattern to match
+     */
+    pattern: string;
+    /**
+     * Method name to call when event is emitted
+     */
+    methodName: string;
+    /**
+     * Whether this handler should be skipped
+     */
+    skip: boolean;
+}
+/**
+ * @description Event handler function signature
+ * Handlers receive event name and optional data
+ */
+export type EventHandler<T = any> = (eventName: string, data?: T) => void | Promise<void>;
+/**
+ * @description Event subscription internal structure
+ * Used by EventBus to store and manage subscriptions
+ */
+export interface EventSubscription {
+    /**
+     * Event pattern for matching
+     */
+    pattern: string;
+    /**
+     * Handler function to execute
+     */
+    handler: EventHandler;
+    /**
+     * Whether this is a one-time subscription (once)
+     */
+    once?: boolean;
+}

package/dist/lib/server/event/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/lib/server/event/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../lib/server/event/types.ts"],"names":[],"mappings":""}

package/dist/lib/server/index.d.ts

@@ -1,3 +1,2 @@
 export * from './AsenaServer';
 export * from './AsenaServerFactory';
-export { ICoreServiceNames } from '../ioc';

package/dist/lib/server/index.js

@@ -1,4 +1,3 @@
 export * from './AsenaServer';
 export * from './AsenaServerFactory';
-export { ICoreServiceNames } from '../ioc';
 //# sourceMappingURL=index.js.map

package/dist/lib/server/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../lib/server/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../lib/server/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC"}