@context-action/core 0.2.1 → 0.2.3

package/dist/index.js

@@ -27,9 +27,42 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#region src/execution-modes.ts
 /**
 * Execute handlers in sequential mode (one after another)
+* 
+* Executes action handlers one at a time in priority order (highest first).
+* Supports both blocking and non-blocking handlers, with proper abort and
+* termination handling. Handlers can modify payload for subsequent handlers
+* and jump to different priority levels.
+* 
+* @template T - The payload type for the action
+* @template R - The result type for handlers
+* 
+* @param context - Pipeline execution context containing handlers and state
+* @param createController - Factory function for creating pipeline controllers
+* 
+* @throws {Error} When a blocking handler fails or validation errors occur
+* 
+* @example
+* ```typescript
+* // This is called internally by ActionRegister.dispatch()
+* // when executionMode is 'sequential'
+* 
+* // Handlers execute in this order (by priority):
+* // 1. Priority 100: Validation handler
+* // 2. Priority 50: Business logic handler  
+* // 3. Priority 10: Logging handler
+* 
+* await executeSequential(context, (registration, index) => ({
+*   abort: (reason) => { context.aborted = true; context.abortReason = reason },
+*   modifyPayload: (modifier) => { context.payload = modifier(context.payload) },
+*   // ... other controller methods
+* }))
+* ```
+* 
+* @public
 */
 async function executeSequential(context, createController) {
 	let i = 0;
+	const nonBlockingPromises = [];
 	while (i < context.handlers.length) {
 		if (context.aborted || context.terminated) break;
 		const registration = context.handlers[i];
@@ -55,10 +88,15 @@ async function executeSequential(context, createController) {
 				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);
+			if (result instanceof Promise) {
+				const promiseWithHandling = result.then((asyncResult) => {
+					if (asyncResult !== void 0 && !context.terminated) context.results.push(asyncResult);
+					return asyncResult;
+				}).catch((error) => {
+					throw error;
+				});
+				nonBlockingPromises.push(promiseWithHandling);
+			} else context.results.push(result);
 			/** Check if pipeline was terminated by controller.return() */
 			if (context.terminated) break;
 			/** Handle jump to priority AFTER handler execution */
@@ -75,12 +113,56 @@ async function executeSequential(context, createController) {
 			} else i++;
 		} catch (error) {
 			if (registration.config.blocking) throw error;
-			i++;
+			throw error;
 		}
 	}
+	if (nonBlockingPromises.length > 0) await Promise.all(nonBlockingPromises);
 }
 /**
 * Execute handlers in parallel mode (all at once)
+* 
+* Executes all qualifying action handlers simultaneously using Promise.allSettled.
+* Supports both blocking and non-blocking handlers. Blocking handlers can still
+* fail the entire pipeline if they throw errors.
+* 
+* @template T - The payload type for the action
+* @template R - The result type for handlers
+* 
+* @param context - Pipeline execution context containing handlers and state
+* @param createController - Factory function for creating pipeline controllers
+* 
+* @throws {Error} When any blocking handler fails
+* 
+* @example
+* ```typescript
+* // This is called internally by ActionRegister.dispatch()
+* // when executionMode is 'parallel'
+* 
+* // All handlers execute simultaneously:
+* // - Analytics handler (non-blocking)
+* // - Validation handler (blocking)
+* // - Update handler (blocking)
+* // - Notification handler (non-blocking)
+* 
+* await executeParallel(context, (registration, index) => ({
+*   abort: (reason) => { context.aborted = true },
+*   setResult: (result) => { context.results.push(result) },
+*   // ... other controller methods
+* }))
+* ```
+* 
+* @example Use Case
+* ```typescript
+* // Perfect for independent operations
+* register.setActionExecutionMode('logEvent', 'parallel')
+* 
+* // These can all run simultaneously:
+* register.register('logEvent', analyticsHandler, { blocking: false })
+* register.register('logEvent', metricsHandler, { blocking: false })
+* register.register('logEvent', auditHandler, { blocking: true })
+* ```
+* 
+* @public
 */
 async function executeParallel(context, createController) {
 	/** Filter handlers that should run */
@@ -140,6 +222,56 @@ async function executeParallel(context, createController) {
 }
 /**
 * Execute handlers in race mode (first to complete wins)
+* 
+* Executes all qualifying handlers simultaneously using Promise.race, where
+* the first handler to complete determines the pipeline result. Other handlers
+* are effectively cancelled. Useful for scenarios where you want the fastest
+* response from multiple equivalent handlers.
+* 
+* @template T - The payload type for the action
+* @template R - The result type for handlers
+* 
+* @param context - Pipeline execution context containing handlers and state
+* @param createController - Factory function for creating pipeline controllers
+* 
+* @throws {Error} When the winning handler fails and is blocking
+* 
+* @example
+* ```typescript
+* // This is called internally by ActionRegister.dispatch()
+* // when executionMode is 'race'
+* 
+* // Multiple data sources racing for fastest response:
+* // - Database handler (might be slow)
+* // - Cache handler (usually fast)
+* // - API handler (variable speed)
+* // 
+* // Whichever completes first wins
+* 
+* await executeRace(context, (registration, index) => ({
+*   return: (result) => { 
+*     context.terminated = true
+*     context.terminationResult = result 
+*   },
+*   // ... other controller methods
+* }))
+* ```
+* 
+* @example Use Case
+* ```typescript
+* // Race between multiple data sources
+* register.setActionExecutionMode('fetchUserData', 'race')
+* 
+* // These handlers race for fastest response:
+* register.register('fetchUserData', cacheHandler)     // Usually fastest
+* register.register('fetchUserData', databaseHandler)  // Reliable fallback
+* register.register('fetchUserData', apiHandler)       // External source
+* 
+* // First to complete wins, others are ignored
+* const result = await register.dispatchWithResult('fetchUserData', { id: '123' })
+* ```
+* 
+* @public
 */
 async function executeRace(context, createController) {
 	/** Filter handlers that should run */
@@ -189,8 +321,8 @@ async function executeRace(context, createController) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.81.0/node_modules/@oxc-project/runtime/src/helpers/typeof.js
-var require_typeof = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.81.0/node_modules/@oxc-project/runtime/src/helpers/typeof.js": ((exports, module) => {
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.82.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js
+var require_typeof = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.82.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js": ((exports, module) => {
 	function _typeof$2(o) {
 		"@babel/helpers - typeof";
 		return module.exports = _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
@@ -203,8 +335,8 @@ var require_typeof = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc
 }) });
 
 //#endregion
-//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.81.0/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js
-var require_toPrimitive = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.81.0/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js": ((exports, module) => {
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.82.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js
+var require_toPrimitive = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.82.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js": ((exports, module) => {
 	var _typeof$1 = require_typeof()["default"];
 	function toPrimitive$1(t, r) {
 		if ("object" != _typeof$1(t) || !t) return t;
@@ -220,8 +352,8 @@ var require_toPrimitive = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm
 }) });
 
 //#endregion
-//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.81.0/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js
-var require_toPropertyKey = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.81.0/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js": ((exports, module) => {
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.82.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js
+var require_toPropertyKey = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.82.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js": ((exports, module) => {
 	var _typeof = require_typeof()["default"];
 	var toPrimitive = require_toPrimitive();
 	function toPropertyKey$1(t) {
@@ -232,8 +364,8 @@ var require_toPropertyKey = /* @__PURE__ */ __commonJS({ "../../node_modules/.pn
 }) });
 
 //#endregion
-//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.81.0/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js
-var require_defineProperty = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.81.0/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js": ((exports, module) => {
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.82.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js
+var require_defineProperty = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.82.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js": ((exports, module) => {
 	var toPropertyKey = require_toPropertyKey();
 	function _defineProperty$3(e, r, t) {
 		return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
@@ -251,41 +383,81 @@ var require_defineProperty = /* @__PURE__ */ __commonJS({ "../../node_modules/.p
 var import_defineProperty$2 = /* @__PURE__ */ __toESM(require_defineProperty(), 1);
 /**
 * Action Guard system for managing action execution timing
-* @implements action-guard
-* @implements performance-optimization  
-* @implements user-experience-optimization
-* @implements class-naming
-* @memberof core-concepts
-* @internal
-* @since 1.0.0
 * 
-* Manages action execution timing through debouncing and throttling
-* @implements performance-optimization
+* Provides performance optimization and user experience enhancement through
+* debouncing and throttling mechanisms. Debouncing waits for a pause in calls
+* before executing, while throttling limits execution frequency.
 * 
-* @example
+* @example Debouncing Search Input
 * ```typescript
-* const guard = new ActionGuard(logger);
+* const guard = new ActionGuard()
 * 
-* // Debounce search input (wait 300ms after typing stops)
+* // Wait 300ms after user stops typing before searching
+* register.register('searchUsers', async (payload, controller) => {
+*   const query = payload.query
+*   if (query.length < 2) return
+*   
+*   const results = await userService.search(query)
+*   controller.setResult(results)
+* }, {
+*   debounce: 300,  // Built into ActionRegister via ActionGuard
+*   tags: ['search', 'user-input']
+* })
+* ```
+* 
+* @example Throttling High-Frequency Events
+* ```typescript
+* // Limit scroll position updates to once per 100ms
+* register.register('updateScrollPosition', (payload, controller) => {
+*   scrollState.setValue(payload.position)
+* }, {
+*   throttle: 100,  // Built into ActionRegister via ActionGuard
+*   tags: ['scroll', 'performance']
+* })
+* ```
+* 
+* @example Manual Usage (Advanced)
+* ```typescript
+* const guard = new ActionGuard()
+* 
+* // Manual debouncing
 * if (await guard.debounce('search', 300)) {
-*   executeSearch();  
+*   performSearch()  // Only executes after 300ms pause
 * }
 * 
-* // Throttle scroll handler (max once per 100ms)
+* // Manual throttling
 * if (guard.throttle('scroll', 100)) {
-*   updateScrollPosition();
+*   updateUI()  // Max once per 100ms
 * }
 * ```
+* 
+* @internal
 */
 var ActionGuard = class {
 	constructor() {
 		(0, import_defineProperty$2.default)(this, "guards", /* @__PURE__ */ new Map());
 	}
 	/**
-	* Check if action should be debounced
-	* @param actionKey - Unique key for the action
-	* @param debounceMs - Debounce delay in milliseconds
-	* @returns Promise that resolves when debounce period is complete
+	* Apply debouncing to an action
+	* 
+	* Debouncing waits for a specified delay after the last call before allowing
+	* execution. Each new call resets the timer. Useful for search inputs, resize
+	* handlers, and other high-frequency user interactions.
+	* 
+	* @param actionKey - Unique identifier for the action being debounced
+	* @param debounceMs - Delay in milliseconds to wait after the last call
+	* 
+	* @returns Promise resolving to true if execution should proceed, false if cancelled
+	* 
+	* @example Search Input Debouncing
+	* ```typescript
+	* // Only search after user stops typing for 300ms
+	* if (await guard.debounce('userSearch', 300)) {
+	*   performSearch(query)
+	* }
+	* ```
+	* 
+	* @internal
 	*/
 	async debounce(actionKey, debounceMs) {
 		/** Get or create guard state for this action */
@@ -320,10 +492,26 @@ var ActionGuard = class {
 		});
 	}
 	/**
-	* Check if action should be throttled
-	* @param actionKey - Unique key for the action
-	* @param throttleMs - Throttle delay in milliseconds
-	* @returns True if action should proceed, false if throttled
+	* Apply throttling to an action
+	* 
+	* Throttling limits execution frequency by ensuring a minimum interval between
+	* calls. Unlike debouncing, throttling executes immediately on the first call
+	* and then blocks subsequent calls until the interval expires.
+	* 
+	* @param actionKey - Unique identifier for the action being throttled
+	* @param throttleMs - Minimum interval in milliseconds between executions
+	* 
+	* @returns True if execution should proceed, false if currently throttled
+	* 
+	* @example Scroll Handler Throttling
+	* ```typescript
+	* // Update scroll position max once per 100ms
+	* if (guard.throttle('scrollUpdate', 100)) {
+	*   updateScrollPosition()
+	* }
+	* ```
+	* 
+	* @internal
 	*/
 	throttle(actionKey, throttleMs) {
 		/** Get or create guard state for this action */
@@ -362,8 +550,14 @@ var ActionGuard = class {
 		return false;
 	}
 	/**
-	* Clear all guards for an action
-	* @param actionKey - Action key to clear
+	* Clear all guard state for a specific action
+	* 
+	* Removes debounce and throttle timers for the specified action,
+	* preventing memory leaks and allowing immediate re-execution.
+	* 
+	* @param actionKey - Action identifier to clear guards for
+	* 
+	* @internal
 	*/
 	clearGuards(actionKey) {
 		const state = this.guards.get(actionKey);
@@ -380,7 +574,12 @@ var ActionGuard = class {
 		}
 	}
 	/**
-	* Clear all guards
+	* Clear all guard states for all actions
+	* 
+	* Removes all active debounce and throttle timers, useful for cleanup
+	* when shutting down the action system or resetting state.
+	* 
+	* @internal
 	*/
 	clearAll() {
 		/** Iterate through all guard states and clear their timers */
@@ -398,14 +597,28 @@ var ActionGuard = class {
 		this.guards.clear();
 	}
 	/**
-	* Get current guard state for debugging
-	* @param actionKey - Action key to inspect
+	* Get current guard state for debugging purposes
+	* 
+	* Returns the internal state for a specific action, including timer
+	* information and execution timestamps.
+	* 
+	* @param actionKey - Action identifier to inspect
+	* @returns Guard state or undefined if no state exists
+	* 
+	* @internal
 	*/
 	getGuardState(actionKey) {
 		return this.guards.get(actionKey);
 	}
 	/**
-	* Get all active guards for debugging
+	* Get all active guard states for debugging purposes
+	* 
+	* Returns a copy of all current guard states, useful for monitoring
+	* and debugging rate limiting behavior across all actions.
+	* 
+	* @returns Map of action keys to their guard states
+	* 
+	* @internal
 	*/
 	getAllGuardStates() {
 		return new Map(this.guards);
@@ -522,33 +735,84 @@ var OperationQueue = class {
 //#region src/ActionRegister.ts
 var import_defineProperty = /* @__PURE__ */ __toESM(require_defineProperty(), 1);
 /**
-* 중앙화된 액션 등록 및 디스패치 시스템으로, 타입 안전한 액션 파이프라인 관리를 제공하는 핵심 클래스입니다.
+* Action Register for managing action handlers with priority-based execution
 * 
-* @implements {ActionRegister}
-* @implements {Action Pipeline System}
-* @memberof core-concepts
+* Central action registration and dispatch system providing type-safe action pipeline management.
+* Supports sequential, parallel, and race execution modes with advanced handler filtering,
+* throttling, debouncing, and comprehensive result collection.
 * 
-* @example
+* @template TActionMap - Action payload mapping interface extending ActionPayloadMap
+* 
+* @example Basic Usage
 * ```typescript
 * interface AppActions extends ActionPayloadMap {
-*   updateUser: { id: string; name: string };
-*   calculateTotal: void;
+*   updateUser: { id: string; name: string; email: string }
+*   deleteUser: { id: string }
+*   resetUser: void
 * }
 * 
 * const register = new ActionRegister<AppActions>({
 *   name: 'AppRegister',
-*   logLevel: LogLevel.DEBUG
-* });
+*   registry: { debug: true, maxHandlers: 10 }
+* })
 * 
-* // 핸들러 등록
-* register.register('updateUser', ({ id, name }, controller) => {
-*   userStore.setValue({ id, name });
-*   // 핸들러가 자동으로 다음 핸들러로 진행
-* }, { priority: 10 });
+* // Register handler with priority
+* register.register('updateUser', async (payload, controller) => {
+*   await userService.update(payload.id, payload)
+*   controller.setResult({ success: true, userId: payload.id })
+* }, { priority: 10, tags: ['user', 'crud'] })
 * 
-* // 액션 디스패치
-* await register.dispatch('updateUser', { id: '1', name: 'John' });
+* // Dispatch action
+* await register.dispatch('updateUser', { 
+*   id: '123', 
+*   name: 'John Doe', 
+*   email: 'john@example.com' 
+* })
 * ```
+* 
+* @example With Multiple Handlers
+* ```typescript
+* // High priority validation handler
+* register.register('updateUser', async (payload, controller) => {
+*   if (!payload.email.includes('@')) {
+*     controller.abort('Invalid email format')
+*     return
+*   }
+* }, { priority: 100, category: 'validation' })
+* 
+* // Lower priority update handler
+* register.register('updateUser', async (payload, controller) => {
+*   const user = await userService.update(payload.id, payload)
+*   controller.setResult(user)
+* }, { priority: 50, category: 'business-logic' })
+* ```
+* 
+* @example Advanced Configuration
+* ```typescript
+* const register = new ActionRegister<AppActions>({
+*   name: 'AdvancedRegister',
+*   registry: {
+*     debug: true,
+*     maxHandlers: 20,
+*     defaultExecutionMode: 'parallel',
+*     autoCleanup: true
+*   }
+* })
+* 
+* // Handler with debouncing and tags
+* register.register('searchUsers', async (payload, controller) => {
+*   const results = await userService.search(payload.query)
+*   controller.setResult(results)
+* }, {
+*   priority: 10,
+*   debounce: 300,
+*   tags: ['search', 'user'],
+*   category: 'query',
+*   once: false
+* })
+* ```
+* 
+* @public
 */
 var ActionRegister = class {
 	constructor(config = {}) {
@@ -575,6 +839,43 @@ var ActionRegister = class {
 			concurrencyProtection: true
 		});
 	}
+	/**
+	* Register an action handler with optional configuration
+	* 
+	* @param action - The action type to register handler for
+	* @param handler - The handler function to execute
+	* @param config - Optional handler configuration including priority, tags, etc.
+	* 
+	* @returns Unregister function to remove this handler
+	* 
+	* @throws {Error} When maximum handlers limit is reached
+	* 
+	* @example Basic Registration
+	* ```typescript
+	* const unregister = register.register('updateUser', async (payload, controller) => {
+	*   await userService.update(payload.id, payload)
+	* })
+	* 
+	* // Later remove the handler
+	* unregister()
+	* ```
+	* 
+	* @example With Priority and Configuration
+	* ```typescript
+	* register.register('validateUser', async (payload, controller) => {
+	*   if (!payload.email) {
+	*     controller.abort('Email is required')
+	*   }
+	* }, {
+	*   priority: 100,
+	*   tags: ['validation'],
+	*   category: 'security',
+	*   once: false
+	* })
+	* ```
+	* 
+	* @public
+	*/
 	register(action, handler, config = {}) {
 		const handlerId = config.id || `handler_${++this.handlerCounter}_${Math.random().toString(36).substr(2, 5)}`;
 		const unregisterFn = this._performRegistrationSync(action, handler, config, handlerId);
@@ -707,6 +1008,48 @@ var ActionRegister = class {
 			}
 		};
 	}
+	/**
+	* Dispatch an action with optional execution options
+	* 
+	* @param action - The action type to dispatch
+	* @param payload - The action payload data
+	* @param options - Optional dispatch options (execution mode, filters, etc.)
+	* 
+	* @returns Promise that resolves when all handlers complete
+	* 
+	* @throws {Error} When action dispatching fails
+	* 
+	* @example Basic Dispatch
+	* ```typescript
+	* await register.dispatch('updateUser', {
+	*   id: '123',
+	*   name: 'John Doe',
+	*   email: 'john@example.com'
+	* })
+	* ```
+	* 
+	* @example With Options
+	* ```typescript
+	* await register.dispatch('updateUser', payload, {
+	*   executionMode: 'parallel',
+	*   timeout: 5000,
+	*   filter: {
+	*     tags: ['validation', 'business-logic'],
+	*     excludeCategory: 'analytics'
+	*   }
+	* })
+	* ```
+	* 
+	* @example With Throttling
+	* ```typescript
+	* await register.dispatch('searchUsers', { query: 'john' }, {
+	*   throttle: 300,
+	*   debounce: 100
+	* })
+	* ```
+	* 
+	* @public
+	*/
 	async dispatch(action, payload, options) {
 		return this.dispatchQueue.enqueue(async () => {
 			return this._performDispatch(action, payload, options);
@@ -783,7 +1126,9 @@ var ActionRegister = class {
 		if (effectiveSignal && abortHandler) effectiveSignal.addEventListener("abort", abortHandler);
 		try {
 			await this.executePipeline(context, autoAbortController, options?.autoAbort);
+			console.log(`[ActionRegister] Pipeline execution succeeded for ${String(action)}`);
 		} catch (error) {
+			console.log(`[ActionRegister] Pipeline execution failed for ${String(action)}:`, error);
 			executionSuccess = false;
 			throw error;
 		} finally {
@@ -792,6 +1137,43 @@ var ActionRegister = class {
 			this.updateExecutionStats(action, executionSuccess, duration);
 		}
 	}
+	/**
+	* Dispatch an action and return detailed execution results
+	* 
+	* @param action - The action type to dispatch
+	* @param payload - The action payload data
+	* @param options - Optional dispatch options including result collection strategy
+	* 
+	* @returns Promise resolving to comprehensive execution results
+	* 
+	* @example Basic Result Collection
+	* ```typescript
+	* const result = await register.dispatchWithResult('updateUser', payload)
+	* 
+	* if (result.success) {
+	*   console.log(`Executed ${result.execution.handlersExecuted} handlers`)
+	*   console.log(`Duration: ${result.execution.duration}ms`)
+	* }
+	* ```
+	* 
+	* @example Advanced Result Processing
+	* ```typescript
+	* const result = await register.dispatchWithResult('processOrder', order, {
+	*   result: {
+	*     collect: true,
+	*     strategy: 'merge',
+	*     maxResults: 5,
+	*     merger: (results) => results.reduce((acc, curr) => ({ ...acc, ...curr }), {})
+	*   }
+	* })
+	* 
+	* if (result.terminated) {
+	*   console.log('Handler returned early:', result.result)
+	* }
+	* ```
+	* 
+	* @public
+	*/
 	async dispatchWithResult(action, payload, options) {
 		const startTime = Date.now();
 		let autoAbortController;
@@ -1094,22 +1476,105 @@ var ActionRegister = class {
 		if (success) stats.successCount++;
 		else stats.errorCount++;
 	}
+	/**
+	* Get the number of registered handlers for an action
+	* 
+	* @param action - The action type to count handlers for
+	* 
+	* @returns Number of registered handlers
+	* 
+	* @example
+	* ```typescript
+	* register.register('updateUser', handler1)
+	* register.register('updateUser', handler2)
+	* 
+	* console.log(register.getHandlerCount('updateUser')) // 2
+	* ```
+	* 
+	* @public
+	*/
 	getHandlerCount(action) {
 		const pipeline = this.pipelines.get(action);
 		return pipeline ? pipeline.length : 0;
 	}
+	/**
+	* Check if an action has any registered handlers
+	* 
+	* @param action - The action type to check
+	* 
+	* @returns True if action has handlers, false otherwise
+	* 
+	* @example
+	* ```typescript
+	* if (register.hasHandlers('updateUser')) {
+	*   await register.dispatch('updateUser', userData)
+	* }
+	* ```
+	* 
+	* @public
+	*/
 	hasHandlers(action) {
 		return this.getHandlerCount(action) > 0;
 	}
+	/**
+	* Get all registered action types
+	* 
+	* @returns Array of all registered action types
+	* 
+	* @example
+	* ```typescript
+	* const actions = register.getRegisteredActions()
+	* console.log('Registered actions:', actions) // ['updateUser', 'deleteUser', 'resetUser']
+	* ```
+	* 
+	* @public
+	*/
 	getRegisteredActions() {
 		return Array.from(this.pipelines.keys());
 	}
+	/**
+	* Remove all handlers for a specific action
+	* 
+	* @param action - The action type to clear handlers for
+	* 
+	* @example
+	* ```typescript
+	* register.clearAction('updateUser')
+	* console.log(register.hasHandlers('updateUser')) // false
+	* ```
+	* 
+	* @public
+	*/
 	clearAction(action) {
 		this.pipelines.delete(action);
 	}
+	/**
+	* Remove all handlers for all actions
+	* 
+	* @example
+	* ```typescript
+	* register.clearAll()
+	* console.log(register.getRegisteredActions().length) // 0
+	* ```
+	* 
+	* @public
+	*/
 	clearAll() {
 		this.pipelines.clear();
 	}
+	/**
+	* Get the name of this action register
+	* 
+	* @returns The register name
+	* 
+	* @example
+	* ```typescript
+	* const register = new ActionRegister({ name: 'UserRegister' })
+	* console.log(register.getName()) // 'UserRegister'
+	* ```
+	* 
+	* @public
+	*/
 	getName() {
 		return this.name;
 	}