@context-action/core 0.5.0 → 0.7.1

package/dist/index.js

@@ -44,6 +44,7 @@ async function executeSequential(context, createController) {
 	while (i < context.handlers.length) {
 		if (context.aborted || context.terminated) break;
 		const registration = context.handlers[i];
+		if (!registration) continue;
 		context.currentIndex = i;
 		const controller = createController(registration, i);
 		try {
@@ -61,7 +62,8 @@ async function executeSequential(context, createController) {
 					errors.push({
 						handlerId: handlerError.handlerId,
 						error: handlerError.error,
-						timestamp: handlerError.timestamp
+						timestamp: handlerError.timestamp,
+						severity: "non-blocking"
 					});
 					return void 0;
 				});
@@ -153,7 +155,7 @@ async function executeParallel(context, createController) {
 	const failures = results.filter((result, index) => {
 		if (result.status === "rejected") {
 			const registration = runnableHandlers[index];
-			return registration.config.blocking;
+			return registration?.config.blocking ?? false;
 		}
 		return false;
 	});
@@ -319,7 +321,11 @@ var ActionGuard = class {
 			/** Initialize new guard state with default values */
 			state = {
 				lastExecuted: 0,
-				isThrottled: false
+				isThrottled: false,
+				debounceTimer: void 0,
+				throttleTimer: void 0,
+				debouncePromise: void 0,
+				debounceResolve: void 0
 			};
 			this.guards.set(actionKey, state);
 		}
@@ -373,7 +379,11 @@ var ActionGuard = class {
 			/** Initialize new guard state with default values */
 			state = {
 				lastExecuted: 0,
-				isThrottled: false
+				isThrottled: false,
+				debounceTimer: void 0,
+				throttleTimer: void 0,
+				debouncePromise: void 0,
+				debounceResolve: void 0
 			};
 			this.guards.set(actionKey, state);
 		}
@@ -415,7 +425,6 @@ var ActionGuard = class {
 	clearGuards(actionKey) {
 		const state = this.guards.get(actionKey);
 		if (state) {
-			/** Clear debounce timer if active to prevent memory leaks */
 			if (state.debounceTimer) {
 				clearTimeout(state.debounceTimer);
 				if (state.debounceResolve) {
@@ -424,12 +433,10 @@ var ActionGuard = class {
 				}
 				state.debounceTimer = void 0;
 			}
-			/** Clear throttle timer if active to prevent memory leaks */
 			if (state.throttleTimer) {
 				clearTimeout(state.throttleTimer);
 				state.throttleTimer = void 0;
 			}
-			/** Remove guard state from memory */
 			this.guards.delete(actionKey);
 		}
 	}
@@ -557,9 +564,12 @@ var OperationQueue = class {
 				timestamp: Date.now()
 			};
 			let insertIndex = this.queue.length;
-			for (let i = 0; i < this.queue.length; i++) if ((this.queue[i].priority || 0) < priority) {
-				insertIndex = i;
-				break;
+			for (let i = 0; i < this.queue.length; i++) {
+				const item = this.queue[i];
+				if (item && (item.priority || 0) < priority) {
+					insertIndex = i;
+					break;
+				}
 			}
 			this.queue.splice(insertIndex, 0, queuedOperation);
 			this.processQueue();
@@ -681,8 +691,11 @@ var ActionRegister = class {
 		this.pipelines = /* @__PURE__ */ new Map();
 		this.executionMode = "sequential";
 		this.actionExecutionModes = /* @__PURE__ */ new Map();
+		this.unregisterFunctions = /* @__PURE__ */ new Map();
 		this.filterCache = /* @__PURE__ */ new Map();
-		this.filterCacheMaxSize = 100;
+		this.handlerIdCounter = 0;
+		this.controllerPool = [];
+		this.maxControllerPoolSize = 10;
 		this.name = config.name || "ActionRegister";
 		this.registryConfig = config.registry;
 		this.maxHandlersPerAction = config.registry?.maxHandlersPerAction ?? 1e3;
@@ -727,11 +740,10 @@ var ActionRegister = class {
 		}
 	}
 	/**
-	* 🆕 Generate unique handler ID using crypto
+	* 🔧 Generate unique handler ID using optimized counter-based approach
 	*/
 	generateHandlerId(action) {
-		const uuid = crypto.randomUUID();
-		return `${String(action)}_${uuid.slice(0, 8)}`;
+		return `${String(action)}_${this.name}_${++this.handlerIdCounter}`;
 	}
 	/**
 	* 🔧 Create and merge AbortSignal instances with proper cleanup
@@ -800,7 +812,8 @@ var ActionRegister = class {
 				once: config.once ?? false,
 				debounce: config.debounce ?? void 0,
 				throttle: config.throttle ?? void 0,
-				replaceExisting: config.replaceExisting ?? false
+				replaceExisting: config.replaceExisting ?? false,
+				cleanup: config.cleanup
 			},
 			id: handlerId
 		};
@@ -811,56 +824,60 @@ var ActionRegister = class {
 			return () => {};
 		}
 		const existingIndex = pipeline.findIndex((reg) => reg.id === handlerId);
-		if (existingIndex !== -1) if (config.replaceExisting) {
-			const oldRegistration = pipeline[existingIndex];
-			if (oldRegistration && typeof oldRegistration.cleanup === "function") try {
-				oldRegistration.cleanup();
-			} catch (cleanupError) {
-				this.log(`Cleanup error for replaced handler: ${String(action)}`, cleanupError, "warn");
-			}
-			pipeline[existingIndex] = registration;
-			pipeline.sort((a, b) => b.config.priority - a.config.priority);
-			this.invalidateFilterCache();
-			this.log(`Handler replaced: ${String(action)}`, {
-				handlerId,
-				priority: config.priority,
-				totalHandlers: pipeline.length,
-				oldHandlerCleaned: Boolean(oldRegistration.cleanup)
-			});
-			return () => {
-				const index = pipeline.findIndex((reg) => reg.id === handlerId && reg === registration);
-				if (index !== -1) {
-					pipeline.splice(index, 1);
-					this.invalidateFilterCache();
-					this.log(`Replaced handler unregistered: ${String(action)}`, { handlerId });
+		if (existingIndex !== -1) {
+			const existing = pipeline[existingIndex];
+			const existingUnregister = this.unregisterFunctions.get(handlerId);
+			if (config.replaceExisting) {
+				if (existingUnregister) {
+					existingUnregister();
+					this.unregisterFunctions.delete(handlerId);
 				}
-			};
-		} else {
-			this.log(`Handler duplicate ignored: ${String(action)}`, {
-				handlerId,
-				note: "Use replaceExisting:true to replace"
-			}, "warn");
-			return () => {};
+				if (existing && typeof existing.cleanup === "function") try {
+					existing.cleanup();
+				} catch (cleanupError) {
+					this.log(`Cleanup error for replaced handler: ${String(action)}`, cleanupError, "warn");
+				}
+				pipeline[existingIndex] = registration;
+				pipeline.sort((a, b) => b.config.priority - a.config.priority);
+				this.invalidateFilterCache();
+				const newUnregister = this.createUnregisterFunction(action, handlerId, registration);
+				this.unregisterFunctions.set(handlerId, newUnregister);
+				this.log(`Handler replaced: ${String(action)}`, {
+					handlerId,
+					priority: config.priority,
+					totalHandlers: pipeline.length,
+					hadExistingUnregister: Boolean(existingUnregister)
+				});
+				return newUnregister;
+			} else {
+				if (!existing) throw new Error("Internal error: existing handler should be defined in duplicate handler block");
+				this.log(`Handler duplicate ignored, returning existing unregister: ${String(action)}`, {
+					handlerId,
+					existingPriority: existing.config.priority,
+					newPriority: config.priority,
+					existingBlocking: existing.config.blocking,
+					newBlocking: config.blocking,
+					note: "Use replaceExisting:true to replace"
+				}, "warn");
+				if (existingUnregister) return existingUnregister;
+				else {
+					const newUnregister = this.createUnregisterFunction(action, handlerId, existing);
+					this.unregisterFunctions.set(handlerId, newUnregister);
+					return newUnregister;
+				}
+			}
 		}
 		pipeline.push(registration);
 		pipeline.sort((a, b) => b.config.priority - a.config.priority);
 		this.invalidateFilterCache();
+		const unregister = this.createUnregisterFunction(action, handlerId, registration);
+		this.unregisterFunctions.set(handlerId, unregister);
 		this.log(`Handler registered: ${String(action)}`, {
 			handlerId,
 			priority: config.priority,
 			totalHandlers: pipeline.length
 		});
-		return () => {
-			const index = pipeline.findIndex((reg) => reg.id === handlerId && reg === registration);
-			if (index !== -1) {
-				pipeline.splice(index, 1);
-				this.invalidateFilterCache();
-				this.log(`Handler unregistered: ${String(action)}`, {
-					handlerId,
-					remainingHandlers: pipeline.length
-				});
-			}
-		};
+		return unregister;
 	}
 	/**
 	* Dispatch an action with optional execution options
@@ -887,12 +904,30 @@ var ActionRegister = class {
 	* 🆕 실제 디스패치 작업 수행 (큐에서 호출됨)
 	*/
 	async _performDispatch(action, payload, options) {
+		this.log(`Starting dispatch for action '${String(action)}'`, {
+			hasPayload: payload !== void 0,
+			payloadType: payload?.constructor?.name || typeof payload,
+			options: options ? Object.keys(options) : "none",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
 		if (payload instanceof Event && process.env.NODE_ENV === "development") console.warn(`Event object passed to action "${String(action)}"`, payload.type);
 		const [effectiveSignal, autoAbortController, cleanup] = this.createAbortSignal(options);
 		if (options?.autoAbort?.onControllerCreated && autoAbortController) options.autoAbort.onControllerCreated(autoAbortController);
-		if (effectiveSignal?.aborted) return;
+		if (effectiveSignal?.aborted) {
+			this.log(`Dispatch aborted before execution for '${String(action)}'`);
+			return;
+		}
 		const pipeline = this.pipelines.get(action);
-		if (!pipeline || pipeline.length === 0) return;
+		this.log(`Pipeline lookup for '${String(action)}'`, {
+			pipelineExists: Boolean(pipeline),
+			handlersCount: pipeline?.length || 0,
+			allRegisteredActions: Array.from(this.pipelines.keys()),
+			pipelineMap: Object.fromEntries(Array.from(this.pipelines.entries()).map(([k, v]) => [k, v.length]))
+		});
+		if (!pipeline || pipeline.length === 0) {
+			this.log(`No handlers found for action '${String(action)}', dispatch cancelled`, {}, "warn");
+			return;
+		}
 		const filteredHandlers = options?.filter ? this.filterHandlers(pipeline, options.filter) : pipeline;
 		const actionKey = String(action);
 		let throttleMs;
@@ -938,6 +973,8 @@ var ActionRegister = class {
 			context.abortReason = "Action dispatch aborted by signal";
 		} : void 0;
 		if (effectiveSignal && abortHandler) effectiveSignal.addEventListener("abort", abortHandler);
+		const contextWithErrors = context;
+		contextWithErrors.collectedErrors;
 		try {
 			await this.executePipeline(context, autoAbortController, options?.autoAbort);
 			this.log(`Pipeline execution succeeded for ${String(action)}`);
@@ -989,6 +1026,7 @@ var ActionRegister = class {
 		if (!pipeline || pipeline.length === 0) return {
 			success: true,
 			aborted: false,
+			abortReason: void 0,
 			terminated: false,
 			result: void 0,
 			successResults: [],
@@ -1007,68 +1045,8 @@ var ActionRegister = class {
 		};
 		const filteredHandlers = options?.filter ? this.filterHandlers(pipeline, options.filter) : pipeline;
 		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,
-				successResults: [],
-				results: [],
-				failedResults: [],
-				execution: {
-					duration: Date.now() - _startTime,
-					handlersExecuted: 0,
-					handlersSkipped: pipeline.length,
-					handlersFailed: 0,
-					startTime: _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,
-				successResults: [],
-				results: [],
-				failedResults: [],
-				execution: {
-					duration: Date.now() - _startTime,
-					handlersExecuted: 0,
-					handlersSkipped: pipeline.length,
-					handlersFailed: 0,
-					startTime: _startTime,
-					endTime: Date.now()
-				},
-				handlers: [],
-				errors: []
-			};
-		}
+		const guardResult = await this.applyActionGuardControlsWithResult(actionKey, filteredHandlers, options, _startTime, pipeline.length);
+		if (guardResult) return guardResult;
 		const currentExecutionMode = options?.executionMode || this.actionExecutionModes.get(action) || this.executionMode;
 		const context = {
 			action: String(action),
@@ -1085,26 +1063,54 @@ var ActionRegister = class {
 		};
 		let executionError;
 		const handlerResults = [];
-		const errors = [];
+		filteredHandlers.forEach((handler) => {
+			handlerResults.push({
+				id: handler.config.id,
+				executed: false,
+				duration: void 0,
+				result: void 0,
+				error: void 0,
+				metadata: void 0
+			});
+		});
 		const abortHandler = effectiveSignal ? () => {
 			context.aborted = true;
 			context.abortReason = "Action dispatch aborted by signal";
 		} : void 0;
 		if (effectiveSignal && abortHandler) effectiveSignal.addEventListener("abort", abortHandler);
+		let errors = [];
 		try {
 			await this.executePipeline(context, autoAbortController, options?.autoAbort);
+			const contextWithErrors = context;
+			errors = contextWithErrors.collectedErrors || [];
+			const executedCount = Math.min(context.currentIndex + (context.aborted ? 0 : 1), filteredHandlers.length);
+			for (let i = 0; i < executedCount; i++) {
+				const handler = filteredHandlers[i];
+				if (!handler) continue;
+				const handlerResult = handlerResults.find((hr) => hr.id === handler.config.id);
+				if (handlerResult) handlerResult.executed = true;
+			}
 		} catch (error) {
+			const contextWithErrors = context;
+			errors = contextWithErrors.collectedErrors || [];
 			executionError = error instanceof Error ? error : new Error(String(error));
 			errors.push({
 				handlerId: "pipeline",
 				error: executionError,
-				timestamp: Date.now()
+				timestamp: Date.now(),
+				severity: "blocking"
 			});
+			const executedCount = Math.min(context.currentIndex + 1, filteredHandlers.length);
+			for (let i = 0; i < executedCount; i++) {
+				const handler = filteredHandlers[i];
+				if (!handler) continue;
+				const handlerResult = handlerResults.find((hr) => hr.id === handler.config.id);
+				if (handlerResult) handlerResult.executed = true;
+			}
 		} finally {
 			cleanup();
 		}
 		const endTime = Date.now();
-		!executionError && context.aborted;
 		const processedResult = this.processResults(context, options?.result);
 		const successResults = context.results.filter((result) => result !== void 0);
 		const failedResults = errors.map((err) => ({
@@ -1123,7 +1129,7 @@ var ActionRegister = class {
 			failedResults,
 			execution: {
 				duration: endTime - _startTime,
-				handlersExecuted: context.currentIndex + (context.aborted ? 0 : 1),
+				handlersExecuted: filteredHandlers.length === 0 ? 0 : context.currentIndex + (context.aborted ? 0 : 1),
 				handlersSkipped: Math.max(0, filteredHandlers.length - (context.currentIndex + 1)),
 				handlersFailed: errors.length,
 				startTime: _startTime,
@@ -1142,6 +1148,82 @@ var ActionRegister = class {
 		return executionResult;
 	}
 	/**
+	* 🔧 Unified method for dispatchWithResult that returns ExecutionResult on guard rejection
+	*/
+	async applyActionGuardControlsWithResult(actionKey, filteredHandlers, options, startTime, pipelineLength) {
+		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,
+				successResults: [],
+				results: [],
+				failedResults: [],
+				execution: {
+					duration: Date.now() - startTime,
+					handlersExecuted: 0,
+					handlersSkipped: pipelineLength,
+					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,
+				successResults: [],
+				results: [],
+				failedResults: [],
+				execution: {
+					duration: Date.now() - startTime,
+					handlersExecuted: 0,
+					handlersSkipped: pipelineLength,
+					handlersFailed: 0,
+					startTime,
+					endTime: Date.now()
+				},
+				handlers: [],
+				errors: []
+			};
+		}
+		return null;
+	}
+	/**
+	* 🔧 Calculate optimal cache size based on current handler count
+	* Note: This caches handler SELECTION metadata only, never execution results
+	*/
+	get filterCacheMaxSize() {
+		const totalHandlers = Array.from(this.pipelines.values()).reduce((sum, pipeline) => sum + pipeline.length, 0);
+		return totalHandlers * 10 || 100;
+	}
+	/**
 	* 🔧 Generate cache key for filter options
 	*/
 	generateFilterCacheKey(filterOptions) {
@@ -1161,6 +1243,48 @@ var ActionRegister = class {
 	invalidateFilterCache() {
 		this.filterCache.clear();
 	}
+	/**
+	* 🔧 Create or reuse PipelineController from pool for better performance
+	*/
+	getControllerFromPool(context, autoAbortController, autoAbortOptions) {
+		let controller = this.controllerPool.pop();
+		if (!controller) controller = {};
+		controller.abort = (reason) => {
+			context.aborted = true;
+			context.abortReason = reason;
+			if (autoAbortController && autoAbortOptions?.allowHandlerAbort) autoAbortController.abort(reason);
+		};
+		controller.modifyPayload = (modifier) => {
+			context.payload = modifier(context.payload);
+		};
+		controller.getPayload = () => context.payload;
+		controller.jumpToPriority = (priority) => {
+			context.jumpToPriority = priority;
+		};
+		controller.return = (result) => {
+			context.terminated = true;
+			context.terminationResult = result;
+		};
+		controller.setResult = (result) => {
+			context.results.push(result);
+		};
+		controller.getResults = () => {
+			return [...context.results];
+		};
+		controller.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;
+		};
+		return controller;
+	}
+	/**
+	* 🔧 Return controller to pool for reuse
+	*/
+	returnControllerToPool(controller) {
+		if (this.controllerPool.length < this.maxControllerPoolSize) this.controllerPool.push(controller);
+	}
 	filterHandlers(handlers, filterOptions) {
 		if (!filterOptions) return handlers;
 		const cacheKey = this.generateFilterCacheKey(filterOptions);
@@ -1180,9 +1304,10 @@ var ActionRegister = class {
 			return true;
 		});
 		if (!filterOptions.custom) {
-			if (this.filterCache.size >= this.filterCacheMaxSize) {
-				const firstKey = this.filterCache.keys().next().value;
-				if (firstKey) this.filterCache.delete(firstKey);
+			const currentMaxSize = this.filterCacheMaxSize;
+			if (this.filterCache.size >= currentMaxSize) {
+				const oldestKey = this.filterCache.keys().next().value;
+				if (oldestKey !== void 0) this.filterCache.delete(oldestKey);
 			}
 			this.filterCache.set(cacheKey, filtered);
 		}
@@ -1209,36 +1334,7 @@ var ActionRegister = class {
 	}
 	async executePipeline(context, autoAbortController, autoAbortOptions) {
 		const createController = (_registration, _index) => {
-			return {
-				abort: (reason) => {
-					context.aborted = true;
-					context.abortReason = reason;
-					if (autoAbortController && autoAbortOptions?.allowHandlerAbort) autoAbortController.abort(reason);
-				},
-				modifyPayload: (modifier) => {
-					context.payload = modifier(context.payload);
-				},
-				getPayload: () => context.payload,
-				jumpToPriority: (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;
-				}
-			};
+			return this.getControllerFromPool(context, autoAbortController, autoAbortOptions);
 		};
 		switch (context.executionMode) {
 			case "sequential":
@@ -1400,6 +1496,15 @@ var ActionRegister = class {
 		return Array.from(this.pipelines.keys()).map((action) => this.getActionStats(action)).filter((stats) => stats !== null);
 	}
 	/**
+	* Set global execution mode for all actions
+	* 
+	* @param mode Execution mode to set
+	*/
+	setExecutionMode(mode) {
+		this.executionMode = mode;
+		if (this.registryConfig?.debug && process.env.NODE_ENV === "development") console.log(`🎯 Global execution mode set to: ${mode}`);
+	}
+	/**
 	* Set execution mode for a specific action
 	* 
 	* @param action Action name
@@ -1444,6 +1549,55 @@ var ActionRegister = class {
 		return this.isDebugMode;
 	}
 	/**
+	* Creates a consistent unregister function for a handler
+	* 
+	* @param action - Action key
+	* @param handlerId - Handler identifier
+	* @param registration - Handler registration object
+	* @returns Unregister function
+	* @private
+	*/
+	createUnregisterFunction(action, handlerId, registration) {
+		return () => {
+			const pipeline = this.pipelines.get(action);
+			if (!pipeline) return;
+			const index = pipeline.findIndex((reg) => reg.id === handlerId && reg === registration);
+			if (index !== -1) {
+				pipeline.splice(index, 1);
+				this.invalidateFilterCache();
+				this.unregisterFunctions.delete(handlerId);
+				if (registration.config.cleanup && typeof registration.config.cleanup === "function") try {
+					registration.config.cleanup();
+				} catch (cleanupError) {
+					this.log(`Cleanup error during unregister: ${String(action)}`, cleanupError, "warn");
+				}
+				this.log(`Handler unregistered: ${String(action)}`, {
+					handlerId,
+					remainingHandlers: pipeline.length
+				});
+			}
+		};
+	}
+	/**
+	* Gets the total count of registered unregister functions
+	* 
+	* @returns Number of unregister functions
+	* @public
+	*/
+	getUnregisterFunctionCount() {
+		return this.unregisterFunctions.size;
+	}
+	/**
+	* Checks if an unregister function exists for the given handler ID
+	* 
+	* @param handlerId - Handler identifier to check
+	* @returns True if unregister function exists
+	* @public
+	*/
+	hasUnregisterFunction(handlerId) {
+		return this.unregisterFunctions.has(handlerId);
+	}
+	/**
 	* 🆕 Destroy method for comprehensive cleanup
 	* 
 	* Cleans up all internal resources including pipelines, guards, queues, and statistics.
@@ -1452,11 +1606,20 @@ var ActionRegister = class {
 	* @public
 	*/
 	destroy() {
+		this.unregisterFunctions.forEach((unregister) => {
+			try {
+				unregister();
+			} catch (error) {
+				this.log("Error during unregister in destroy", error, "error");
+			}
+		});
+		this.unregisterFunctions.clear();
 		this.pipelines.clear();
 		this.actionGuard.destroy();
 		this.dispatchQueue?.clear?.();
 		this.actionExecutionModes.clear();
 		this.filterCache.clear();
+		this.controllerPool.length = 0;
 		this.log("ActionRegister destroyed");
 	}
 };
@@ -1533,7 +1696,17 @@ var ActionRegister = class {
 * @public
 */
 function createActionHandler(registry, action, handler, config) {
-	const finalConfig = createReactHandlerConfig(String(action), void 0, config);
+	const timestamp = Date.now();
+	const random = Math.random().toString(36).substr(2, 5);
+	const finalConfig = {
+		priority: config?.priority ?? 0,
+		id: config?.id || `react_${String(action)}_${timestamp}_${random}`,
+		blocking: config?.blocking ?? false,
+		once: config?.once ?? false,
+		debounce: config?.debounce ?? void 0,
+		throttle: config?.throttle ?? void 0,
+		replaceExisting: true
+	};
 	let currentUnregister;
 	let isRegistered = false;
 	return {
@@ -1561,96 +1734,6 @@ function createActionHandler(registry, action, handler, config) {
 	};
 }
 /**
-* 🆕 React handler configuration factory
-* 
-* Creates optimized handler configurations for React environments with
-* proper cleanup and unique ID generation.
-* 
-* @template T - ActionPayloadMap type
-* @template K - Action key type
-* 
-* @param action - Action name
-* @param componentId - Optional component identifier for debugging
-* @param config - Base handler configuration
-* 
-* @returns Optimized configuration for React environments
-* 
-* @example
-* ```tsx
-* function MyComponent({ userId }: { userId: string }) {
-*   const registry = useActionRegister();
-*   
-*   useEffect(() => {
-*     const config = createReactHandlerConfig('updateUser', 'MyComponent', {
-*       priority: 10
-*     });
-*     
-*     const unregister = registry.register('updateUser', handler, config);
-*     return unregister;
-*   }, [registry, handler]);
-* }
-* ```
-* 
-* @public
-*/
-function createReactHandlerConfig(action, componentId, config = {}) {
-	const timestamp = Date.now();
-	const random = Math.random().toString(36).substr(2, 5);
-	return {
-		priority: config.priority ?? 0,
-		id: config.id || `${componentId || "react"}_${action}_${timestamp}_${random}`,
-		blocking: config.blocking ?? false,
-		once: config.once ?? false,
-		debounce: config.debounce ?? void 0,
-		throttle: config.throttle ?? void 0,
-		replaceExisting: true
-	};
-}
-/**
-* 🆕 React action dispatcher factory
-* 
-* Creates a dispatcher function optimized for React component usage
-* with proper error boundaries and async handling.
-* 
-* @template T - ActionPayloadMap type
-* 
-* @param registry - ActionRegister instance
-* @param errorHandler - Optional error handler for unhandled dispatch errors
-* 
-* @returns Optimized dispatch function for React components
-* 
-* @example
-* ```tsx
-* function MyComponent() {
-*   const registry = useActionRegister();
-*   
-*   const dispatch = createReactDispatcher(registry, (error, action, payload) => {
-*     console.error(`Failed to dispatch ${action}:`, error);
-*   });
-*   
-*   const handleClick = useCallback(() => {
-*     dispatch('userClick', { buttonId: 'submit' });
-*   }, [dispatch]);
-* }
-* ```
-* 
-* @public
-*/
-function createReactDispatcher(registry, errorHandler) {
-	return async (action, payload, options) => {
-		try {
-			await registry.dispatch(action, payload, {
-				immediate: false,
-				...options
-			});
-		} catch (error) {
-			const errorObj = error instanceof Error ? error : new Error(String(error));
-			if (errorHandler) errorHandler(errorObj, action, payload);
-			else console.error(`[ActionRegister] Dispatch failed for action '${String(action)}':`, errorObj);
-		}
-	};
-}
-/**
 * 🆕 React development utilities
 * 
 * Provides debugging and development helpers specifically for React environments.
@@ -1692,7 +1775,7 @@ const ReactDevUtils = {
 * Utilities for integrating ActionRegister errors with React Error Boundaries.
 */
 var ReactActionError = class ReactActionError extends Error {
-	constructor(message, action, payload, handlerId, originalError) {
+	constructor(message, action, payload, handlerId = void 0, originalError) {
 		super(message);
 		this.name = "ReactActionError";
 		this.action = action;
@@ -1719,5 +1802,5 @@ function isReactActionError(error) {
 }
 
 //#endregion
-export { ActionGuard, ActionRegister, ReactActionError, ReactDevUtils, createActionHandler, createReactDispatcher, createReactHandlerConfig, executeParallel, executeRace, executeSequential, isReactActionError };
+export { ActionGuard, ActionRegister, ReactActionError, ReactDevUtils, createActionHandler, executeParallel, executeRace, executeSequential, isReactActionError };
 //# sourceMappingURL=index.js.map