@context-action/core 0.0.4 → 0.0.5

package/dist/index.js

@@ -1,5 +1,3 @@
-import { createLogger, getDebugFromEnv, getLoggerNameFromEnv } from "@context-action/logger";
-
 //#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -29,111 +27,87 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#region src/execution-modes.ts
 /**
 * Execute handlers in sequential mode (one after another)
-* @implements execution-modes
-* @implements sequential-execution
-* @memberof core-concepts
-* @internal
-* @since 1.0.0
-* 
-* Executes action handlers sequentially in priority order, supporting flow control,
-* conditional execution, and priority jumping within the pipeline.
-* 
-* @template T - The type of the payload being processed
-* @param context - Pipeline execution context with handlers and state
-* @param createController - Factory function for creating pipeline controllers
-* @param logger - Logger instance for tracing execution
-* @returns Promise that resolves when all handlers complete or pipeline aborts
-* 
-* Features:
-* - Priority-based execution order (higher priority first)
-* - Support for priority jumping within execution
-* - Conditional handler execution (condition/validation checks)
-* - Blocking/non-blocking handler support
-* - Comprehensive error handling and recovery
 */
-async function executeSequential(context, createController, logger) {
-	logger.trace("Executing in sequential mode", { handlerCount: context.handlers.length });
-	for (let i = 0; i < context.handlers.length; i++) {
-		if (context.aborted) {
-			logger.trace("Sequential execution aborted", {
-				atIndex: i,
-				reason: context.abortReason
-			});
-			break;
-		}
-		if (context.jumpToPriority !== void 0) {
-			const jumpIndex = context.handlers.findIndex((handler) => handler.config.priority === context.jumpToPriority);
-			if (jumpIndex !== -1 && jumpIndex !== i) {
-				logger.trace("Jumping to priority", {
-					fromIndex: i,
-					toIndex: jumpIndex,
-					priority: context.jumpToPriority
-				});
-				i = jumpIndex - 1;
-				context.jumpToPriority = void 0;
-				continue;
-			}
-			context.jumpToPriority = void 0;
-		}
+async function executeSequential(context, createController) {
+	let i = 0;
+	while (i < context.handlers.length) {
+		if (context.aborted || context.terminated) break;
 		const registration = context.handlers[i];
 		context.currentIndex = i;
+		/** Check condition if provided */
 		if (registration.config.condition && !registration.config.condition()) {
-			logger.debug(`Skipping handler '${registration.id}' - condition not met`);
+			i++;
 			continue;
 		}
+		/** Check validation if provided */
 		if (registration.config.validation && !registration.config.validation(context.payload)) {
-			logger.debug(`Skipping handler '${registration.id}' - validation failed`);
+			i++;
 			continue;
 		}
 		const controller = createController(registration, i);
 		try {
-			logger.trace(`Executing handler ${i + 1}/${context.handlers.length}`, {
-				handlerId: registration.id,
-				priority: registration.config.priority
-			});
+			if (context.aborted) break;
 			const result = registration.handler(context.payload, controller);
+			/** Wait for async handlers if they're blocking */
 			if (registration.config.blocking && result instanceof Promise) {
-				logger.trace(`Waiting for blocking handler '${registration.id}'`);
-				await result;
-			}
-			logger.trace(`Handler '${registration.id}' completed`);
+				const handlerResult = await result;
+				/** Collect result if handler returned something and wasn't terminated */
+				if (handlerResult !== void 0 && !context.terminated) context.results.push(handlerResult);
+			} else if (result !== void 0 && !context.terminated)
+ /** Collect synchronous result */
+			if (result instanceof Promise) result.then((asyncResult) => {
+				if (asyncResult !== void 0 && !context.terminated) context.results.push(asyncResult);
+			}).catch(() => {});
+			else context.results.push(result);
+			/** Check if pipeline was terminated by controller.return() */
+			if (context.terminated) break;
+			/** Handle jump to priority AFTER handler execution */
+			if (context.jumpToPriority !== void 0) {
+				const jumpIndex = context.handlers.findIndex((handler) => handler.config.priority === context.jumpToPriority);
+				if (jumpIndex !== -1) {
+					i = jumpIndex;
+					context.jumpToPriority = void 0;
+					continue;
+				} else {
+					context.jumpToPriority = void 0;
+					i++;
+				}
+			} else i++;
 		} catch (error) {
-			logger.error(`Handler '${registration.id}' threw an error`, error);
 			if (registration.config.blocking) throw error;
+			i++;
 		}
 	}
 }
 /**
 * Execute handlers in parallel mode (all at once)
-* @internal
 */
-async function executeParallel(context, createController, logger) {
-	logger.trace("Executing in parallel mode", { handlerCount: context.handlers.length });
+async function executeParallel(context, createController) {
+	/** Filter handlers that should run */
 	const runnableHandlers = context.handlers.filter((registration, _index) => {
-		if (registration.config.condition && !registration.config.condition()) {
-			logger.debug(`Skipping handler '${registration.id}' - condition not met`);
-			return false;
-		}
-		if (registration.config.validation && !registration.config.validation(context.payload)) {
-			logger.debug(`Skipping handler '${registration.id}' - validation failed`);
-			return false;
-		}
+		/** Check condition */
+		if (registration.config.condition && !registration.config.condition()) return false;
+		/** Check validation */
+		if (registration.config.validation && !registration.config.validation(context.payload)) return false;
 		return true;
 	});
-	logger.trace(`Running ${runnableHandlers.length} handlers in parallel`);
+	/** Create promises for all handlers */
 	const handlerPromises = runnableHandlers.map(async (registration, _index) => {
 		const controller = createController(registration, _index);
 		try {
-			logger.trace(`Starting parallel handler '${registration.id}'`);
 			const result = registration.handler(context.payload, controller);
-			if (result instanceof Promise) await result;
-			logger.trace(`Parallel handler '${registration.id}' completed`);
+			let handlerResult;
+			if (result instanceof Promise) handlerResult = await result;
+			else handlerResult = result;
+			/** Collect result if handler returned something and pipeline wasn't terminated */
+			if (handlerResult !== void 0 && !context.terminated) context.results.push(handlerResult);
 			return {
 				success: true,
-				handlerId: registration.id
+				handlerId: registration.id,
+				result: handlerResult,
+				terminated: context.terminated
 			};
 		} catch (error) {
-			logger.error(`Parallel handler '${registration.id}' failed`, error);
 			if (registration.config.blocking) throw error;
 			return {
 				success: false,
@@ -142,7 +116,9 @@ async function executeParallel(context, createController, logger) {
 			};
 		}
 	});
+	/** Wait for all handlers to complete */
 	const results = await Promise.allSettled(handlerPromises);
+	/** Check for any rejected blocking handlers */
 	const failures = results.filter((result, index) => {
 		if (result.status === "rejected") {
 			const registration = runnableHandlers[index];
@@ -154,47 +130,43 @@ async function executeParallel(context, createController, logger) {
 		const firstFailure = failures[0];
 		throw firstFailure.reason;
 	}
-	logger.trace("Parallel execution completed", {
-		successful: results.filter((r) => r.status === "fulfilled").length,
-		failed: results.filter((r) => r.status === "rejected").length
-	});
+	/** Check if any handler terminated the pipeline */
+	const terminatedResults = results.filter((result) => result.status === "fulfilled" && result.value.terminated);
+	if (terminatedResults.length > 0) {
+		context.terminated = true;
+		const firstTerminated = terminatedResults[0];
+		context.terminationResult = firstTerminated.value.result;
+	}
 }
 /**
 * Execute handlers in race mode (first to complete wins)
-* @internal
 */
-async function executeRace(context, createController, logger) {
-	logger.trace("Executing in race mode", { handlerCount: context.handlers.length });
+async function executeRace(context, createController) {
+	/** Filter handlers that should run */
 	const runnableHandlers = context.handlers.filter((registration, _index) => {
-		if (registration.config.condition && !registration.config.condition()) {
-			logger.debug(`Skipping handler '${registration.id}' - condition not met`);
-			return false;
-		}
-		if (registration.config.validation && !registration.config.validation(context.payload)) {
-			logger.debug(`Skipping handler '${registration.id}' - validation failed`);
-			return false;
-		}
+		/** Check condition */
+		if (registration.config.condition && !registration.config.condition()) return false;
+		/** Check validation */
+		if (registration.config.validation && !registration.config.validation(context.payload)) return false;
 		return true;
 	});
-	if (runnableHandlers.length === 0) {
-		logger.trace("No runnable handlers for race mode");
-		return;
-	}
-	logger.trace(`Racing ${runnableHandlers.length} handlers`);
+	if (runnableHandlers.length === 0) return;
+	/** Create promises for all handlers */
 	const handlerPromises = runnableHandlers.map(async (registration, _index) => {
 		const controller = createController(registration, _index);
 		try {
-			logger.trace(`Starting race handler '${registration.id}'`);
 			const result = registration.handler(context.payload, controller);
-			if (result instanceof Promise) await result;
-			logger.trace(`Race handler '${registration.id}' completed`);
+			let handlerResult;
+			if (result instanceof Promise) handlerResult = await result;
+			else handlerResult = result;
 			return {
 				success: true,
 				handlerId: registration.id,
-				registration
+				registration,
+				result: handlerResult,
+				terminated: context.terminated
 			};
 		} catch (error) {
-			logger.error(`Race handler '${registration.id}' failed`, error);
 			return {
 				success: false,
 				handlerId: registration.id,
@@ -203,16 +175,16 @@ async function executeRace(context, createController, logger) {
 			};
 		}
 	});
-	try {
-		const winner = await Promise.race(handlerPromises);
-		logger.debug("Race completed", {
-			winner: winner.handlerId,
-			success: winner.success
-		});
-		if (!winner.success && winner.registration?.config.blocking) throw winner.error;
-	} catch (error) {
-		logger.error("Race execution failed", error);
-		throw error;
+	/** Race all handlers */
+	const winner = await Promise.race(handlerPromises);
+	/** If the winner failed and was blocking, throw the error */
+	if (!winner.success && winner.registration?.config.blocking) throw winner.error;
+	/** Collect result from the winning handler */
+	if (winner.success && winner.result !== void 0) context.results.push(winner.result);
+	/** Check if the winning handler terminated the pipeline */
+	if (winner.success && winner.terminated) {
+		context.terminated = true;
+		context.terminationResult = winner.result;
 	}
 }
 
@@ -282,19 +254,13 @@ var import_defineProperty$1 = __toESM(require_defineProperty(), 1);
 * @implements action-guard
 * @implements performance-optimization  
 * @implements user-experience-optimization
+* @implements class-naming
 * @memberof core-concepts
 * @internal
 * @since 1.0.0
 * 
-* Provides debouncing, throttling, and blocking mechanisms for action execution
-* to optimize performance and enhance user experience. Manages timing state
-* per action to prevent unnecessary or excessive action invocations.
-* 
-* Key Features:
-* - Debouncing: Delay execution until activity stops
-* - Throttling: Limit execution frequency to intervals
-* - Per-action state management with automatic cleanup
-* - Memory leak prevention through proper timer management
+* Manages action execution timing through debouncing and throttling
+* @implements performance-optimization
 * 
 * @example
 * ```typescript
@@ -312,10 +278,8 @@ var import_defineProperty$1 = __toESM(require_defineProperty(), 1);
 * ```
 */
 var ActionGuard = class {
-	constructor(logger) {
+	constructor() {
 		(0, import_defineProperty$1.default)(this, "guards", /* @__PURE__ */ new Map());
-		(0, import_defineProperty$1.default)(this, "logger", void 0);
-		this.logger = logger;
 	}
 	/**
 	* Check if action should be debounced
@@ -324,27 +288,29 @@ var ActionGuard = class {
 	* @returns Promise that resolves when debounce period is complete
 	*/
 	async debounce(actionKey, debounceMs) {
-		this.logger.trace(`Checking debounce for '${actionKey}'`, { debounceMs });
+		/** Get or create guard state for this action */
 		let state = this.guards.get(actionKey);
 		if (!state) {
+			/** Initialize new guard state with default values */
 			state = {
 				lastExecuted: 0,
 				isThrottled: false
 			};
 			this.guards.set(actionKey, state);
 		}
-		if (state.debounceTimer) {
-			clearTimeout(state.debounceTimer);
-			this.logger.trace(`Cleared existing debounce timer for '${actionKey}'`);
-		}
+		/** Clear any existing debounce timer to restart the delay period */
+		/** This implements the "debounce" behavior where rapid calls reset the timer */
+		if (state.debounceTimer) clearTimeout(state.debounceTimer);
+		/** Create new debounce promise that resolves after the delay period */
+		/** The promise will only resolve if no new debounce requests arrive */
 		return new Promise((resolve) => {
 			state.debounceTimer = setTimeout(() => {
-				this.logger.trace(`Debounce completed for '${actionKey}'`);
+				/** Clean up timer reference to prevent memory leaks */
 				state.debounceTimer = void 0;
+				/** Update last execution timestamp for throttling calculations */
 				state.lastExecuted = Date.now();
 				resolve(true);
 			}, debounceMs);
-			this.logger.trace(`Set debounce timer for '${actionKey}'`, { delay: debounceMs });
 		});
 	}
 	/**
@@ -354,9 +320,10 @@ var ActionGuard = class {
 	* @returns True if action should proceed, false if throttled
 	*/
 	throttle(actionKey, throttleMs) {
-		this.logger.trace(`Checking throttle for '${actionKey}'`, { throttleMs });
+		/** Get or create guard state for this action */
 		let state = this.guards.get(actionKey);
 		if (!state) {
+			/** Initialize new guard state with default values */
 			state = {
 				lastExecuted: 0,
 				isThrottled: false
@@ -365,30 +332,27 @@ var ActionGuard = class {
 		}
 		const now = Date.now();
 		const timeSinceLastExecution = now - state.lastExecuted;
+		/** Check if enough time has passed since last execution */
+		/** If throttle period has elapsed, allow immediate execution */
 		if (timeSinceLastExecution >= throttleMs) {
+			/** Update execution timestamp and clear throttled state */
 			state.lastExecuted = now;
 			state.isThrottled = false;
-			this.logger.trace(`Throttle passed for '${actionKey}'`, {
-				timeSinceLastExecution,
-				throttleMs
-			});
 			return true;
 		}
-		if (state.isThrottled) {
-			this.logger.trace(`Action '${actionKey}' is already throttled`);
-			return false;
-		}
+		/** If already in throttled state, don't create duplicate timers */
+		/** This prevents timer accumulation and unnecessary processing */
+		if (state.isThrottled) return false;
+		/** Set throttle timer to automatically clear the throttled state */
+		/** Calculate remaining time until throttle period expires */
 		state.isThrottled = true;
 		const remainingTime = throttleMs - timeSinceLastExecution;
+		/** Create timer to reset throttled state when period expires */
 		state.throttleTimer = setTimeout(() => {
+			/** Clear throttled state and timer reference */
 			state.isThrottled = false;
 			state.throttleTimer = void 0;
-			this.logger.trace(`Throttle period ended for '${actionKey}'`);
 		}, remainingTime);
-		this.logger.trace(`Action '${actionKey}' throttled`, {
-			timeSinceLastExecution,
-			remainingTime
-		});
 		return false;
 	}
 	/**
@@ -396,26 +360,30 @@ var ActionGuard = class {
 	* @param actionKey - Action key to clear
 	*/
 	clearGuards(actionKey) {
-		this.logger.trace(`Clearing guards for '${actionKey}'`);
 		const state = this.guards.get(actionKey);
 		if (state) {
+			/** Clear debounce timer if active to prevent memory leaks */
 			if (state.debounceTimer) clearTimeout(state.debounceTimer);
+			/** Clear throttle timer if active to prevent memory leaks */
 			if (state.throttleTimer) clearTimeout(state.throttleTimer);
+			/** Remove guard state from memory */
 			this.guards.delete(actionKey);
-			this.logger.debug(`Cleared guards for '${actionKey}'`);
 		}
 	}
 	/**
 	* Clear all guards
 	*/
 	clearAll() {
-		this.logger.trace("Clearing all action guards");
+		/** Iterate through all guard states and clear their timers */
+		/** This prevents memory leaks when clearing the entire guard system */
 		for (const [, state] of this.guards) {
+			/** Clear any active debounce timers */
 			if (state.debounceTimer) clearTimeout(state.debounceTimer);
+			/** Clear any active throttle timers */
 			if (state.throttleTimer) clearTimeout(state.throttleTimer);
 		}
+		/** Remove all guard states from memory */
 		this.guards.clear();
-		this.logger.debug("Cleared all action guards");
 	}
 	/**
 	* Get current guard state for debugging
@@ -436,220 +404,56 @@ var ActionGuard = class {
 //#region src/ActionRegister.ts
 var import_defineProperty = __toESM(require_defineProperty(), 1);
 /**
-* Simple event emitter implementation for ActionRegister events
-* @internal
-*/
-var SimpleEventEmitter = class {
-	constructor() {
-		(0, import_defineProperty.default)(this, "listeners", /* @__PURE__ */ new Map());
-	}
-	on(event, handler) {
-		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
-		this.listeners.get(event).add(handler);
-		return () => this.off(event, handler);
-	}
-	emit(event, data) {
-		const eventListeners = this.listeners.get(event);
-		if (eventListeners) eventListeners.forEach((handler) => {
-			try {
-				handler(data);
-			} catch (error) {
-				console.error(`Error in event handler for ${String(event)}:`, error);
-			}
-		});
-	}
-	off(event, handler) {
-		const eventListeners = this.listeners.get(event);
-		if (eventListeners) {
-			eventListeners.delete(handler);
-			if (eventListeners.size === 0) this.listeners.delete(event);
-		}
-	}
-	removeAllListeners(event) {
-		if (event) this.listeners.delete(event);
-		else this.listeners.clear();
-	}
-};
-/**
-* Central action registration and dispatch system
-* @implements action-pipeline-system
-* @implements actionregister  
-* @memberof core-concepts
+* 중앙화된 액션 등록 및 디스패치 시스템으로, 타입 안전한 액션 파이프라인 관리를 제공하는 핵심 클래스입니다.
 * 
-* Core action pipeline management system with type-safe action dispatch
-* @template T - Action payload map defining available actions and their payload types
+* @implements {ActionRegister}
+* @implements {Action Pipeline System}
+* @memberof core-concepts
 * 
 * @example
 * ```typescript
 * interface AppActions extends ActionPayloadMap {
-*   increment: void;
-*   setCount: number;
 *   updateUser: { id: string; name: string };
+*   calculateTotal: void;
 * }
-*
-* const actionRegister = new ActionRegister<AppActions>();
-*
-* // Register handlers with priority and configuration
-* actionRegister.register('increment', (_, controller) => {
-*   console.log('Incremented');
+* 
+* const register = new ActionRegister<AppActions>({
+*   name: 'AppRegister',
+*   logLevel: LogLevel.DEBUG
+* });
+* 
+* // 핸들러 등록
+* register.register('updateUser', ({ id, name }, controller) => {
+*   userStore.setValue({ id, name });
 *   controller.next();
 * }, { priority: 10 });
-*
-* actionRegister.register('setCount', (count, controller) => {
-*   console.log(`Count: ${count}`);
-*   controller.next();
-* });
-*
-* // Dispatch actions with type safety
-* await actionRegister.dispatch('increment');
-* await actionRegister.dispatch('setCount', 42);
+* 
+* // 액션 디스패치
+* await register.dispatch('updateUser', { id: '1', name: 'John' });
 * ```
 */
 var ActionRegister = class {
 	constructor(config = {}) {
 		(0, import_defineProperty.default)(this, "pipelines", /* @__PURE__ */ new Map());
 		(0, import_defineProperty.default)(this, "handlerCounter", 0);
-		(0, import_defineProperty.default)(this, "logger", void 0);
-		(0, import_defineProperty.default)(this, "events", new SimpleEventEmitter());
-		(0, import_defineProperty.default)(this, "config", void 0);
 		(0, import_defineProperty.default)(this, "actionGuard", void 0);
 		(0, import_defineProperty.default)(this, "executionMode", "sequential");
 		(0, import_defineProperty.default)(this, "actionExecutionModes", /* @__PURE__ */ new Map());
-		(0, import_defineProperty.default)(
-			this,
-			/**
-			* Dispatch action through pipeline
-			* @implements action-dispatcher
-			* 
-			* Dispatch an action through the pipeline
-			* Overloaded to provide type safety for actions with and without payloads
-			*/
-			"dispatch",
-			async (action, payload) => {
-				const startTime = Date.now();
-				this.logger.trace(`Starting dispatch for action '${String(action)}'`, {
-					action,
-					payload,
-					startTime
-				});
-				this.events.emit("action:start", {
-					action,
-					payload
-				});
-				this.logger.trace(`Emitted 'action:start' event`);
-				this.logger.debug(`Dispatching action '${String(action)}'`, { payload });
-				const pipeline = this.pipelines.get(action);
-				if (!pipeline || pipeline.length === 0) {
-					this.logger.warn(`No handlers registered for action '${String(action)}'`);
-					this.logger.trace(`Dispatch completed early - no handlers`);
-					return;
-				}
-				this.logger.trace(`Found ${pipeline.length} handlers for action '${String(action)}'`, { handlerIds: pipeline.map((reg) => reg.id) });
-				const currentExecutionMode = this.actionExecutionModes.get(action) || this.executionMode;
-				const context = {
-					action: String(action),
-					payload,
-					handlers: [...pipeline],
-					aborted: false,
-					abortReason: void 0,
-					currentIndex: 0,
-					jumpToPriority: void 0,
-					executionMode: currentExecutionMode
-				};
-				try {
-					await this.executePipeline(context);
-					const metrics = {
-						action: String(action),
-						executionTime: Date.now() - startTime,
-						handlerCount: context.handlers.length,
-						success: !context.aborted,
-						timestamp: Date.now()
-					};
-					if (context.aborted) {
-						metrics.error = context.abortReason;
-						this.events.emit("action:abort", {
-							action,
-							payload,
-							reason: context.abortReason
-						});
-					} else this.events.emit("action:complete", {
-						action,
-						payload,
-						metrics
-					});
-					this.logger.debug(`Completed action '${String(action)}'`, metrics);
-				} catch (error) {
-					const metrics = {
-						action: String(action),
-						executionTime: Date.now() - startTime,
-						handlerCount: context.handlers.length,
-						success: false,
-						error: error.message || "Unknown error",
-						timestamp: Date.now()
-					};
-					this.logger.error(`Error executing action '${String(action)}'`, metrics);
-					this.events.emit("action:error", {
-						action,
-						payload,
-						error: error instanceof Error ? error : new Error(String(error))
-					});
-					throw error;
-				}
-			}
-		);
-		this.config = {
-			logger: config.logger || createLogger(config.logLevel),
-			logLevel: config.logLevel ?? 3,
-			name: config.name || getLoggerNameFromEnv(),
-			debug: config.debug ?? getDebugFromEnv(),
-			defaultExecutionMode: config.defaultExecutionMode ?? "sequential"
-		};
-		this.logger = this.config.logger;
-		this.actionGuard = new ActionGuard(this.logger);
-		this.executionMode = this.config.defaultExecutionMode;
-		this.logger.trace(`${this.config.name} constructor called`, { config });
-		if (this.config.debug) this.logger.info(`${this.config.name} initialized`, {
-			logLevel: this.config.logLevel,
-			debug: this.config.debug,
-			defaultExecutionMode: this.executionMode
+		(0, import_defineProperty.default)(this, "name", void 0);
+		(0, import_defineProperty.default)(this, "registryConfig", void 0);
+		(0, import_defineProperty.default)(this, "executionStats", /* @__PURE__ */ new Map());
+		this.name = config.name || "ActionRegister";
+		this.registryConfig = config.registry;
+		this.actionGuard = new ActionGuard();
+		if (this.registryConfig?.defaultExecutionMode) this.executionMode = this.registryConfig.defaultExecutionMode;
+		if (this.registryConfig?.debug && process.env.NODE_ENV === "development") console.log(`🎯 ActionRegister created: ${this.name}`, {
+			defaultExecutionMode: this.executionMode,
+			maxHandlers: this.registryConfig.maxHandlers,
+			autoCleanup: this.registryConfig.autoCleanup ?? true
 		});
-		this.logger.trace(`${this.config.name} constructor completed`);
 	}
-	/**
-	* Register action handler with pipeline
-	* @implements action-handler
-	* 
-	* Register a handler for an action in the pipeline
-	* @param action - The action name to handle
-	* @param handler - The handler function to execute
-	* @param config - Optional configuration for the handler
-	* @returns Unregister function to remove the handler
-	* 
-	* @example
-	* ```typescript
-	* const unregister = actionRegister.register('updateUser', 
-	*   async (payload, controller) => {
-	*     // Validate payload
-	*     if (!payload.id) {
-	*       controller.abort('User ID is required');
-	*       return;
-	*     }
-	*     
-	*     // Process update
-	*     await updateUserInStore(payload);
-	*     controller.next();
-	*   }, 
-	*   { priority: 10, blocking: true }
-	* );
-	* 
-	* // Later, remove the handler
-	* unregister();
-	* ```
-	*/
 	register(action, handler, config = {}) {
-		this.logger.trace(`Registering handler for action '${String(action)}'`, { config });
-		const handlerId = config.id || `handler_${++this.handlerCounter}`;
-		this.logger.trace(`Generated handler ID: ${handlerId}`);
+		const handlerId = config.id || `handler_${++this.handlerCounter}_${Math.random().toString(36).substr(2, 5)}`;
 		const registration = {
 			handler,
 			config: {
@@ -658,227 +462,605 @@ var ActionRegister = class {
 				blocking: config.blocking ?? false,
 				once: config.once ?? false,
 				condition: config.condition || (() => true),
-				debounce: config.debounce,
-				throttle: config.throttle,
-				validation: config.validation,
-				middleware: config.middleware ?? false
+				debounce: config.debounce ?? void 0,
+				throttle: config.throttle ?? void 0,
+				validation: config.validation ?? void 0,
+				middleware: config.middleware ?? false,
+				tags: config.tags ?? [],
+				category: config.category ?? void 0,
+				description: config.description ?? void 0,
+				version: config.version ?? void 0,
+				returnType: config.returnType ?? "value",
+				timeout: config.timeout ?? void 0,
+				retries: config.retries ?? 0,
+				dependencies: config.dependencies ?? [],
+				conflicts: config.conflicts ?? [],
+				environment: config.environment ?? void 0,
+				feature: config.feature ?? void 0,
+				metrics: config.metrics ?? {
+					collectTiming: false,
+					collectErrors: false,
+					customMetrics: {}
+				},
+				metadata: config.metadata ?? {}
 			},
 			id: handlerId
 		};
-		this.logger.trace(`Created handler registration`, { registration: {
-			id: handlerId,
-			config: registration.config
-		} });
-		if (!this.pipelines.has(action)) {
-			this.logger.trace(`Creating new pipeline for action: ${String(action)}`);
-			this.pipelines.set(action, []);
-			this.logger.debug(`Created pipeline for action: ${String(action)}`);
-		}
+		if (!this.pipelines.has(action)) this.pipelines.set(action, []);
 		const pipeline = this.pipelines.get(action);
-		this.logger.trace(`Current pipeline for '${String(action)}' has ${pipeline.length} handlers`);
-		if (pipeline.some((reg) => reg.id === handlerId)) {
-			this.logger.warn(`Handler with ID '${handlerId}' already exists for action '${String(action)}'`);
-			this.logger.trace(`Duplicate handler registration aborted`);
-			return () => {};
-		}
+		const existingIndex = pipeline.findIndex((reg) => reg.id === handlerId);
+		if (existingIndex !== -1) return () => {};
+		if (this.registryConfig?.maxHandlers && pipeline.length >= this.registryConfig.maxHandlers) throw new Error(`Maximum number of handlers (${this.registryConfig.maxHandlers}) reached for action '${String(action)}' in registry '${this.name}'`);
 		pipeline.push(registration);
-		this.logger.trace(`Added handler to pipeline, current length: ${pipeline.length}`);
 		pipeline.sort((a, b) => b.config.priority - a.config.priority);
-		this.logger.trace(`Pipeline sorted by priority`, { priorities: pipeline.map((reg) => ({
-			id: reg.id,
-			priority: reg.config.priority
-		})) });
-		this.logger.debug(`Registered handler for action '${String(action)}'`, {
+		if (this.registryConfig?.debug && process.env.NODE_ENV === "development") console.log(`🎯 Handler registered: ${String(action)}`, {
 			handlerId,
-			priority: registration.config.priority,
-			blocking: registration.config.blocking,
-			once: registration.config.once
-		});
-		this.events.emit("handler:register", {
-			action,
-			handlerId,
-			config: registration.config
+			priority: config.priority,
+			tags: config.tags,
+			category: config.category,
+			totalHandlers: pipeline.length,
+			registry: this.name
 		});
 		return () => {
-			this.logger.trace(`Unregistering handler '${handlerId}' from action '${String(action)}'`);
-			const index = pipeline.findIndex((reg) => reg.id === handlerId);
+			const index = pipeline.findIndex((reg) => reg.id === handlerId && reg === registration);
 			if (index !== -1) {
 				pipeline.splice(index, 1);
-				this.logger.debug(`Unregistered handler '${handlerId}' from action '${String(action)}'`);
-				this.logger.trace(`Pipeline now has ${pipeline.length} handlers`);
-				this.events.emit("handler:unregister", {
-					action,
-					handlerId
+				if (this.registryConfig?.debug && process.env.NODE_ENV === "development") console.log(`🎯 Handler unregistered: ${String(action)}`, {
+					handlerId,
+					remainingHandlers: pipeline.length,
+					registry: this.name
 				});
-			} else this.logger.trace(`Handler '${handlerId}' not found in pipeline for unregistration`);
+			}
 		};
 	}
-	/**
-	* Execute the pipeline with proper flow control
-	* @internal
-	*/
-	async executePipeline(context) {
-		this.logger.trace(`Starting pipeline execution`, {
-			action: context.action,
-			handlerCount: context.handlers.length,
-			executionMode: context.executionMode,
-			payload: context.payload
+	async dispatch(action, payload, options) {
+		let autoAbortController;
+		let effectiveSignal = options?.signal;
+		if (options?.autoAbort?.enabled) {
+			autoAbortController = new AbortController();
+			effectiveSignal = autoAbortController.signal;
+			if (options.autoAbort.onControllerCreated) options.autoAbort.onControllerCreated(autoAbortController);
+			if (options?.signal) {
+				const originalSignal = options.signal;
+				if (originalSignal.aborted) autoAbortController.abort();
+				else {
+					const abortHandler$1 = () => autoAbortController.abort();
+					originalSignal.addEventListener("abort", abortHandler$1, { once: true });
+				}
+			}
+		}
+		if (effectiveSignal?.aborted) return;
+		const pipeline = this.pipelines.get(action);
+		if (!pipeline || pipeline.length === 0) return;
+		const filteredHandlers = this.filterHandlers([...pipeline], options?.filter);
+		const actionKey = String(action);
+		let throttleMs;
+		let debounceMs;
+		if (options?.throttle !== void 0) throttleMs = options.throttle;
+		else if (filteredHandlers.length > 0) {
+			for (const handler of filteredHandlers) if (handler.config.throttle !== void 0) {
+				throttleMs = handler.config.throttle;
+				break;
+			}
+		}
+		if (options?.debounce !== void 0) debounceMs = options.debounce;
+		else if (filteredHandlers.length > 0) {
+			for (const handler of filteredHandlers) if (handler.config.debounce !== void 0) {
+				debounceMs = handler.config.debounce;
+				break;
+			}
+		}
+		if (debounceMs !== void 0) {
+			const shouldProceed = await this.actionGuard.debounce(actionKey, debounceMs);
+			if (!shouldProceed) return;
+		}
+		if (throttleMs !== void 0) {
+			const shouldProceed = this.actionGuard.throttle(actionKey, throttleMs);
+			if (!shouldProceed) return;
+		}
+		const currentExecutionMode = options?.executionMode || this.actionExecutionModes.get(action) || this.executionMode;
+		const context = {
+			action: String(action),
+			payload,
+			handlers: filteredHandlers,
+			aborted: false,
+			abortReason: void 0,
+			currentIndex: 0,
+			jumpToPriority: void 0,
+			executionMode: currentExecutionMode,
+			results: [],
+			terminated: false,
+			terminationResult: void 0
+		};
+		const startTime = Date.now();
+		let executionSuccess = true;
+		const abortHandler = effectiveSignal ? () => {
+			context.aborted = true;
+			context.abortReason = "Action dispatch aborted by signal";
+		} : void 0;
+		if (effectiveSignal && abortHandler) effectiveSignal.addEventListener("abort", abortHandler);
+		try {
+			await this.executePipeline(context, autoAbortController, options?.autoAbort);
+		} catch (error) {
+			executionSuccess = false;
+			throw error;
+		} finally {
+			if (effectiveSignal && abortHandler) effectiveSignal.removeEventListener("abort", abortHandler);
+			const duration = Date.now() - startTime;
+			this.updateExecutionStats(action, executionSuccess, duration);
+		}
+	}
+	async dispatchWithResult(action, payload, options) {
+		const startTime = Date.now();
+		let autoAbortController;
+		let effectiveSignal = options?.signal;
+		if (options?.autoAbort?.enabled) {
+			autoAbortController = new AbortController();
+			effectiveSignal = autoAbortController.signal;
+			if (options.autoAbort.onControllerCreated) options.autoAbort.onControllerCreated(autoAbortController);
+			if (options?.signal) {
+				const originalSignal = options.signal;
+				if (originalSignal.aborted) autoAbortController.abort();
+				else {
+					const abortHandler$1 = () => autoAbortController.abort();
+					originalSignal.addEventListener("abort", abortHandler$1, { once: true });
+				}
+			}
+		}
+		if (effectiveSignal?.aborted) return {
+			success: false,
+			aborted: true,
+			abortReason: "Action dispatch aborted by signal",
+			terminated: false,
+			result: void 0,
+			results: [],
+			execution: {
+				duration: 0,
+				handlersExecuted: 0,
+				handlersSkipped: 0,
+				handlersFailed: 0,
+				startTime,
+				endTime: startTime
+			},
+			handlers: [],
+			errors: []
+		};
+		const pipeline = this.pipelines.get(action);
+		if (!pipeline || pipeline.length === 0) return {
+			success: true,
+			aborted: false,
+			terminated: false,
+			result: void 0,
+			results: [],
+			execution: {
+				duration: 0,
+				handlersExecuted: 0,
+				handlersSkipped: 0,
+				handlersFailed: 0,
+				startTime,
+				endTime: startTime
+			},
+			handlers: [],
+			errors: []
+		};
+		const filteredHandlers = this.filterHandlers([...pipeline], options?.filter);
+		const actionKey = String(action);
+		let throttleMs;
+		let debounceMs;
+		if (options?.throttle !== void 0) throttleMs = options.throttle;
+		else if (filteredHandlers.length > 0) {
+			for (const handler of filteredHandlers) if (handler.config.throttle !== void 0) {
+				throttleMs = handler.config.throttle;
+				break;
+			}
+		}
+		if (options?.debounce !== void 0) debounceMs = options.debounce;
+		else if (filteredHandlers.length > 0) {
+			for (const handler of filteredHandlers) if (handler.config.debounce !== void 0) {
+				debounceMs = handler.config.debounce;
+				break;
+			}
+		}
+		if (debounceMs !== void 0) {
+			const shouldProceed = await this.actionGuard.debounce(actionKey, debounceMs);
+			if (!shouldProceed) return {
+				success: false,
+				aborted: true,
+				abortReason: "Debounced execution",
+				terminated: false,
+				result: void 0,
+				results: [],
+				execution: {
+					duration: Date.now() - startTime,
+					handlersExecuted: 0,
+					handlersSkipped: pipeline.length,
+					handlersFailed: 0,
+					startTime,
+					endTime: Date.now()
+				},
+				handlers: [],
+				errors: []
+			};
+		}
+		if (throttleMs !== void 0) {
+			const shouldProceed = this.actionGuard.throttle(actionKey, throttleMs);
+			if (!shouldProceed) return {
+				success: false,
+				aborted: true,
+				abortReason: "Throttled execution",
+				terminated: false,
+				result: void 0,
+				results: [],
+				execution: {
+					duration: Date.now() - startTime,
+					handlersExecuted: 0,
+					handlersSkipped: pipeline.length,
+					handlersFailed: 0,
+					startTime,
+					endTime: Date.now()
+				},
+				handlers: [],
+				errors: []
+			};
+		}
+		const currentExecutionMode = options?.executionMode || this.actionExecutionModes.get(action) || this.executionMode;
+		const context = {
+			action: String(action),
+			payload,
+			handlers: filteredHandlers,
+			aborted: false,
+			abortReason: void 0,
+			currentIndex: 0,
+			jumpToPriority: void 0,
+			executionMode: currentExecutionMode,
+			results: [],
+			terminated: false,
+			terminationResult: void 0
+		};
+		let executionError;
+		const handlerResults = [];
+		const errors = [];
+		const abortHandler = effectiveSignal ? () => {
+			context.aborted = true;
+			context.abortReason = "Action dispatch aborted by signal";
+		} : void 0;
+		if (effectiveSignal && abortHandler) effectiveSignal.addEventListener("abort", abortHandler);
+		try {
+			await this.executePipeline(context, autoAbortController, options?.autoAbort);
+		} catch (error) {
+			executionError = error instanceof Error ? error : new Error(String(error));
+			errors.push({
+				handlerId: "pipeline",
+				error: executionError,
+				timestamp: Date.now()
+			});
+		} finally {
+			if (effectiveSignal && abortHandler) effectiveSignal.removeEventListener("abort", abortHandler);
+		}
+		const endTime = Date.now();
+		const executionSuccess = !executionError && !context.aborted;
+		this.updateExecutionStats(action, executionSuccess, endTime - startTime);
+		const processedResult = this.processResults(context, options?.result);
+		const executionResult = {
+			success: !executionError && !context.aborted,
+			aborted: context.aborted,
+			abortReason: context.abortReason,
+			terminated: context.terminated,
+			result: processedResult,
+			results: context.results,
+			execution: {
+				duration: endTime - startTime,
+				handlersExecuted: context.currentIndex + (context.aborted ? 0 : 1),
+				handlersSkipped: Math.max(0, filteredHandlers.length - (context.currentIndex + 1)),
+				handlersFailed: errors.length,
+				startTime,
+				endTime
+			},
+			handlers: handlerResults,
+			errors
+		};
+		/** Clean up one-time handlers after execution */
+		this.cleanupOneTimeHandlers(action, context.handlers);
+		return executionResult;
+	}
+	filterHandlers(handlers, filterOptions) {
+		if (!filterOptions) return handlers;
+		return handlers.filter((registration) => {
+			const config = registration.config;
+			if (filterOptions.tags && filterOptions.tags.length > 0) {
+				const hasMatchingTag = filterOptions.tags.some((tag) => config.tags.includes(tag));
+				if (!hasMatchingTag) return false;
+			}
+			if (filterOptions.category && config.category !== filterOptions.category) return false;
+			if (filterOptions.handlerIds && filterOptions.handlerIds.length > 0) {
+				if (!filterOptions.handlerIds.includes(config.id)) return false;
+			}
+			if (filterOptions.environment && config.environment !== filterOptions.environment) return false;
+			if (filterOptions.feature && config.feature !== filterOptions.feature) return false;
+			if (filterOptions.excludeTags && filterOptions.excludeTags.length > 0) {
+				const hasExcludedTag = filterOptions.excludeTags.some((tag) => config.tags.includes(tag));
+				if (hasExcludedTag) return false;
+			}
+			if (filterOptions.excludeCategory && config.category === filterOptions.excludeCategory) return false;
+			if (filterOptions.excludeHandlerIds && filterOptions.excludeHandlerIds.length > 0) {
+				if (filterOptions.excludeHandlerIds.includes(config.id)) return false;
+			}
+			if (filterOptions.custom && !filterOptions.custom(config)) return false;
+			return true;
 		});
-		const createController = (registration, _index) => {
+	}
+	processResults(context, resultOptions) {
+		if (!resultOptions || !resultOptions.collect) return void 0;
+		const results = context.results;
+		if (context.terminated && context.terminationResult !== void 0) return context.terminationResult;
+		const limitedResults = resultOptions.maxResults ? results.slice(0, resultOptions.maxResults) : results;
+		if (limitedResults.length === 0) return void 0;
+		switch (resultOptions.strategy) {
+			case "first": return limitedResults[0];
+			case "last": return limitedResults[limitedResults.length - 1];
+			case "all": return limitedResults;
+			case "merge":
+				if (resultOptions.merger) return resultOptions.merger(limitedResults);
+				return limitedResults[limitedResults.length - 1];
+			case "custom":
+				if (resultOptions.merger) return resultOptions.merger(limitedResults);
+				throw new Error("Custom result strategy requires a merger function");
+			default: return limitedResults;
+		}
+	}
+	async executePipeline(context, autoAbortController, autoAbortOptions) {
+		const createController = (_registration, _index) => {
 			return {
 				next: () => {},
 				abort: (reason) => {
-					this.logger.trace(`Handler '${registration.id}' is aborting pipeline`, { reason });
 					context.aborted = true;
 					context.abortReason = reason;
-					this.logger.warn(`Pipeline aborted by handler '${registration.id}'`, { reason });
+					if (autoAbortController && autoAbortOptions?.allowHandlerAbort) autoAbortController.abort(reason);
 				},
 				modifyPayload: (modifier) => {
-					this.logger.trace(`Handler '${registration.id}' is modifying payload`);
-					const oldPayload = context.payload;
 					context.payload = modifier(context.payload);
-					this.logger.debug(`Payload modified by handler '${registration.id}'`);
-					this.logger.trace(`Payload change`, {
-						oldPayload,
-						newPayload: context.payload
-					});
 				},
 				getPayload: () => context.payload,
 				jumpToPriority: (priority) => {
-					this.logger.trace(`Handler '${registration.id}' jumping to priority ${priority}`);
 					context.jumpToPriority = priority;
+				},
+				return: (result) => {
+					context.terminated = true;
+					context.terminationResult = result;
+				},
+				setResult: (result) => {
+					context.results.push(result);
+				},
+				getResults: () => {
+					return [...context.results];
+				},
+				mergeResult: (merger) => {
+					const currentResult = context.results[context.results.length - 1];
+					const previousResults = context.results.slice(0, -1);
+					const mergedResult = merger(previousResults, currentResult);
+					context.results[context.results.length - 1] = mergedResult;
 				}
 			};
 		};
 		switch (context.executionMode) {
 			case "sequential":
-				await executeSequential(context, createController, this.logger);
+				await executeSequential(context, createController);
 				break;
 			case "parallel":
-				await executeParallel(context, createController, this.logger);
+				await executeParallel(context, createController);
 				break;
 			case "race":
-				await executeRace(context, createController, this.logger);
+				await executeRace(context, createController);
 				break;
 			default: throw new Error(`Unknown execution mode: ${context.executionMode}`);
 		}
 		this.cleanupOneTimeHandlers(context.action, context.handlers);
 	}
-	/**
-	* Clean up one-time handlers after pipeline execution
-	* @internal
-	*/
 	cleanupOneTimeHandlers(action, executedHandlers) {
 		const pipeline = this.pipelines.get(action);
 		if (!pipeline) return;
 		const oneTimeHandlers = executedHandlers.filter((reg) => reg.config.once);
 		if (oneTimeHandlers.length === 0) return;
-		this.logger.trace(`Cleaning up ${oneTimeHandlers.length} one-time handlers`);
 		oneTimeHandlers.forEach((registration) => {
 			const index = pipeline.findIndex((reg) => reg.id === registration.id);
 			if (index !== -1) {
 				pipeline.splice(index, 1);
-				this.logger.debug(`Removed one-time handler '${registration.id}'`);
+				if (this.registryConfig?.debug && process.env.NODE_ENV === "development") console.log(`🎯 One-time handler removed: ${String(action)}`, {
+					handlerId: registration.id,
+					remainingHandlers: pipeline.length,
+					registry: this.name
+				});
 			}
 		});
-		this.logger.trace(`Pipeline now has ${pipeline.length} handlers`);
 	}
 	/**
-	* Get the number of handlers registered for an action
-	* @param action - The action to check
-	* @returns Number of handlers registered
+	* Update execution statistics for an action
+	* 
+	* @param action Action name
+	* @param success Whether execution was successful
+	* @param duration Execution duration in milliseconds
 	*/
+	updateExecutionStats(action, success, duration) {
+		if (!this.executionStats.has(action)) this.executionStats.set(action, {
+			totalExecutions: 0,
+			totalDuration: 0,
+			successCount: 0,
+			errorCount: 0
+		});
+		const stats = this.executionStats.get(action);
+		stats.totalExecutions++;
+		stats.totalDuration += duration;
+		if (success) stats.successCount++;
+		else stats.errorCount++;
+	}
 	getHandlerCount(action) {
 		const pipeline = this.pipelines.get(action);
-		const count = pipeline ? pipeline.length : 0;
-		this.logger.trace(`Handler count for '${String(action)}': ${count}`);
-		return count;
+		return pipeline ? pipeline.length : 0;
+	}
+	hasHandlers(action) {
+		return this.getHandlerCount(action) > 0;
+	}
+	getRegisteredActions() {
+		return Array.from(this.pipelines.keys());
+	}
+	clearAction(action) {
+		this.pipelines.delete(action);
+	}
+	clearAll() {
+		this.pipelines.clear();
+	}
+	getName() {
+		return this.name;
 	}
 	/**
-	* Check if any handlers are registered for an action
-	* @param action - The action to check
-	* @returns True if handlers are registered
+	* Get comprehensive registry information (similar to DeclarativeStoreRegistry pattern)
+	* 
+	* @returns Registry information including actions, handlers, and execution modes
 	*/
-	hasHandlers(action) {
-		const hasHandlers = this.getHandlerCount(action) > 0;
-		this.logger.trace(`Has handlers for '${String(action)}': ${hasHandlers}`);
-		return hasHandlers;
+	getRegistryInfo() {
+		const totalHandlers = Array.from(this.pipelines.values()).reduce((total, pipeline) => total + pipeline.length, 0);
+		return {
+			name: this.name,
+			totalActions: this.pipelines.size,
+			totalHandlers,
+			registeredActions: Array.from(this.pipelines.keys()),
+			actionExecutionModes: new Map(this.actionExecutionModes),
+			defaultExecutionMode: this.executionMode
+		};
 	}
 	/**
-	* Get all registered action names
-	* @returns Array of action names
+	* Get detailed statistics for a specific action
+	* 
+	* @param action Action name to get statistics for
+	* @returns Detailed handler statistics
 	*/
-	getRegisteredActions() {
-		const actions = Array.from(this.pipelines.keys());
-		this.logger.trace(`Registered actions`, {
-			actions,
-			count: actions.length
+	getActionStats(action) {
+		const pipeline = this.pipelines.get(action);
+		if (!pipeline) return null;
+		const priorityMap = /* @__PURE__ */ new Map();
+		pipeline.forEach((handler) => {
+			if (!priorityMap.has(handler.config.priority)) priorityMap.set(handler.config.priority, []);
+			priorityMap.get(handler.config.priority).push(handler);
 		});
-		return actions;
+		const handlersByPriority = Array.from(priorityMap.entries()).sort(([a], [b]) => b - a).map(([priority, handlers]) => ({
+			priority,
+			handlers: handlers.map((h) => ({
+				id: h.config.id,
+				tags: h.config.tags,
+				category: h.config.category,
+				description: h.config.description,
+				version: h.config.version
+			}))
+		}));
+		const stats = this.executionStats.get(action);
+		const executionStats = stats ? {
+			totalExecutions: stats.totalExecutions,
+			averageDuration: stats.totalExecutions > 0 ? stats.totalDuration / stats.totalExecutions : 0,
+			successRate: stats.totalExecutions > 0 ? stats.successCount / stats.totalExecutions * 100 : 0,
+			errorCount: stats.errorCount
+		} : void 0;
+		return {
+			action,
+			handlerCount: pipeline.length,
+			handlersByPriority,
+			executionStats
+		};
 	}
 	/**
-	* Clear all handlers for a specific action
-	* @param action - The action to clear
+	* Get statistics for all registered actions
+	* 
+	* @returns Array of statistics for all actions
 	*/
-	clearAction(action) {
-		this.logger.trace(`Clearing handlers for action '${String(action)}'`);
-		const pipeline = this.pipelines.get(action);
-		if (pipeline) {
-			const handlerCount = pipeline.length;
-			this.pipelines.delete(action);
-			this.logger.debug(`Cleared ${handlerCount} handlers for action '${String(action)}'`);
-			this.logger.trace(`Action '${String(action)}' pipeline removed`);
-		} else this.logger.trace(`No pipeline found for action '${String(action)}' to clear`);
+	getAllActionStats() {
+		return Array.from(this.pipelines.keys()).map((action) => this.getActionStats(action)).filter((stats) => stats !== null);
 	}
 	/**
-	* Clear all handlers for all actions
+	* Get handlers by tag across all actions
+	* 
+	* @param tag Tag to filter handlers by
+	* @returns Map of actions to handlers with the specified tag
 	*/
-	clearAll() {
-		this.logger.trace(`Clearing all handlers and pipelines`);
-		const actionCount = this.pipelines.size;
-		const totalHandlers = Array.from(this.pipelines.values()).reduce((sum, pipeline) => sum + pipeline.length, 0);
-		this.logger.trace(`Before clear`, {
-			actionCount,
-			totalHandlers
-		});
-		this.pipelines.clear();
-		this.events.removeAllListeners();
-		this.logger.info(`Cleared all handlers`, {
-			actionCount,
-			totalHandlers
-		});
-		this.logger.trace(`All pipelines and event listeners cleared`);
+	getHandlersByTag(tag) {
+		const result = /* @__PURE__ */ new Map();
+		for (const [action, pipeline] of this.pipelines.entries()) {
+			const matchingHandlers = pipeline.filter((handler) => handler.config.tags.includes(tag));
+			if (matchingHandlers.length > 0) result.set(action, matchingHandlers);
+		}
+		return result;
+	}
+	/**
+	* Get handlers by category across all actions
+	* 
+	* @param category Category to filter handlers by
+	* @returns Map of actions to handlers with the specified category
+	*/
+	getHandlersByCategory(category) {
+		const result = /* @__PURE__ */ new Map();
+		for (const [action, pipeline] of this.pipelines.entries()) {
+			const matchingHandlers = pipeline.filter((handler) => handler.config.category === category);
+			if (matchingHandlers.length > 0) result.set(action, matchingHandlers);
+		}
+		return result;
 	}
 	/**
-	* Add event listener for ActionRegister events
-	* @param event - Event name to listen for
-	* @param handler - Event handler function
-	* @returns Unregister function to remove the listener
+	* Set execution mode for a specific action
+	* 
+	* @param action Action name
+	* @param mode Execution mode to set
 	*/
-	on(event, handler) {
-		return this.events.on(event, handler);
+	setActionExecutionMode(action, mode) {
+		this.actionExecutionModes.set(action, mode);
+		if (this.registryConfig?.debug && process.env.NODE_ENV === "development") console.log(`🎯 Execution mode set for action '${String(action)}': ${mode}`);
 	}
 	/**
-	* Remove event listener
-	* @param event - Event name
-	* @param handler - Event handler to remove
+	* Get execution mode for a specific action
+	* 
+	* @param action Action name
+	* @returns Execution mode for the action, or default if not set
 	*/
-	off(event, handler) {
-		this.events.off(event, handler);
+	getActionExecutionMode(action) {
+		return this.actionExecutionModes.get(action) || this.executionMode;
 	}
 	/**
-	* Get current configuration
-	* @returns Current ActionRegister configuration
+	* Remove execution mode override for a specific action
+	* 
+	* @param action Action name
 	*/
-	getConfig() {
-		return { ...this.config };
+	removeActionExecutionMode(action) {
+		this.actionExecutionModes.delete(action);
+		if (this.registryConfig?.debug && process.env.NODE_ENV === "development") console.log(`🎯 Execution mode reset for action '${String(action)}' to default: ${this.executionMode}`);
 	}
 	/**
-	* Get logger instance
-	* @returns Current logger instance
+	* Clear execution statistics for all actions
+	*/
+	clearExecutionStats() {
+		this.executionStats.clear();
+		if (this.registryConfig?.debug && process.env.NODE_ENV === "development") console.log(`🎯 Execution statistics cleared for registry: ${this.name}`);
+	}
+	/**
+	* Clear execution statistics for a specific action
+	* 
+	* @param action Action name
+	*/
+	clearActionExecutionStats(action) {
+		this.executionStats.delete(action);
+		if (this.registryConfig?.debug && process.env.NODE_ENV === "development") console.log(`🎯 Execution statistics cleared for action: ${String(action)}`);
+	}
+	/**
+	* Get registry configuration (for debugging and inspection)
+	* 
+	* @returns Current registry configuration
+	*/
+	getRegistryConfig() {
+		return this.registryConfig;
+	}
+	/**
+	* Check if registry has debug mode enabled
+	* 
+	* @returns Whether debug mode is enabled
 	*/
-	getLogger() {
-		return this.logger;
+	isDebugEnabled() {
+		return Boolean(this.registryConfig?.debug && process.env.NODE_ENV === "development");
 	}
 };