@context-action/core 0.0.1 → 0.0.3

package/dist/index.cjs

@@ -24,8 +24,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const react = __toESM(require("react"));
-const react_jsx_runtime = __toESM(require("react/jsx-runtime"));
 
 //#region ../../node_modules/.pnpm/@oxc-project+runtime@0.77.3/node_modules/@oxc-project/runtime/src/helpers/typeof.js
 var require_typeof = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.77.3/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(exports, module) {
@@ -73,7 +71,7 @@ var require_toPropertyKey = __commonJS({ "../../node_modules/.pnpm/@oxc-project+
 //#region ../../node_modules/.pnpm/@oxc-project+runtime@0.77.3/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js
 var require_defineProperty = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.77.3/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(exports, module) {
 	var toPropertyKey = require_toPropertyKey();
-	function _defineProperty$1(e, r, t) {
+	function _defineProperty$2(e, r, t) {
 		return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
 			value: t,
 			enumerable: !0,
@@ -81,68 +79,311 @@ var require_defineProperty = __commonJS({ "../../node_modules/.pnpm/@oxc-project
 			writable: !0
 		}) : e[r] = t, e;
 	}
-	module.exports = _defineProperty$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	module.exports = _defineProperty$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
 } });
 
 //#endregion
-//#region src/core/ActionRegister.ts
+//#region src/logger.ts
+var import_defineProperty$1 = __toESM(require_defineProperty(), 1);
+/**
+* Log levels in order of severity (lowest to highest)
+*/
+let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+	LogLevel$1[LogLevel$1["TRACE"] = 0] = "TRACE";
+	LogLevel$1[LogLevel$1["DEBUG"] = 1] = "DEBUG";
+	LogLevel$1[LogLevel$1["INFO"] = 2] = "INFO";
+	LogLevel$1[LogLevel$1["WARN"] = 3] = "WARN";
+	LogLevel$1[LogLevel$1["ERROR"] = 4] = "ERROR";
+	LogLevel$1[LogLevel$1["FATAL"] = 5] = "FATAL";
+	return LogLevel$1;
+}({});
+/**
+* Default console logger implementation
+*/
+var ConsoleLogger = class {
+	constructor(level = LogLevel.ERROR) {
+		this.level = level;
+	}
+	shouldLog(level) {
+		return level >= this.level;
+	}
+	formatMessage(level, message) {
+		return `[${level.toUpperCase()}] ${message}`;
+	}
+	trace(message, ...args) {
+		if (this.shouldLog(LogLevel.TRACE)) console.trace(this.formatMessage("trace", message), ...args);
+	}
+	debug(message, ...args) {
+		if (this.shouldLog(LogLevel.DEBUG)) console.debug(this.formatMessage("debug", message), ...args);
+	}
+	info(message, ...args) {
+		if (this.shouldLog(LogLevel.INFO)) console.info(this.formatMessage("info", message), ...args);
+	}
+	warn(message, ...args) {
+		if (this.shouldLog(LogLevel.WARN)) console.warn(this.formatMessage("warn", message), ...args);
+	}
+	error(message, ...args) {
+		if (this.shouldLog(LogLevel.ERROR)) console.error(this.formatMessage("error", message), ...args);
+	}
+	fatal(message, ...args) {
+		if (this.shouldLog(LogLevel.FATAL)) console.error(this.formatMessage("fatal", message), ...args);
+	}
+	setLevel(level) {
+		this.level = level;
+	}
+};
+/**
+* Parse log level from string
+*/
+function parseLogLevel(level) {
+	const upperLevel = level.toUpperCase();
+	switch (upperLevel) {
+		case "TRACE": return LogLevel.TRACE;
+		case "DEBUG": return LogLevel.DEBUG;
+		case "INFO": return LogLevel.INFO;
+		case "WARN": return LogLevel.WARN;
+		case "ERROR": return LogLevel.ERROR;
+		case "FATAL": return LogLevel.FATAL;
+		default: return LogLevel.ERROR;
+	}
+}
+/**
+* Get log level from environment variable or default to ERROR
+*/
+function getLogLevelFromEnv() {
+	if (typeof process !== "undefined" && process.env) {
+		const envLevel = process.env.LOG_LEVEL || process.env.ACTION_LOG_LEVEL;
+		if (envLevel) return parseLogLevel(envLevel);
+	}
+	return LogLevel.TRACE;
+}
+/**
+* Extract trace ID from payload if it exists
+*/
+function extractTraceIdFromPayload(payload) {
+	if (payload && typeof payload === "object") return payload._traceId || payload.traceId || payload.trace_id;
+	return void 0;
+}
+/**
+* Extract session ID from payload if it exists
+*/
+function extractSessionIdFromPayload(payload) {
+	if (payload && typeof payload === "object") return payload._sessionId || payload.sessionId || payload.session_id;
+	return void 0;
+}
+/**
+* Create OTEL context from payload
+*/
+function createOtelContextFromPayload(payload) {
+	return {
+		traceId: extractTraceIdFromPayload(payload),
+		sessionId: extractSessionIdFromPayload(payload),
+		metadata: payload
+	};
+}
+/**
+* OpenTelemetry-aware console logger implementation
+*/
+var OtelConsoleLogger = class extends ConsoleLogger {
+	constructor(level = LogLevel.ERROR) {
+		super(level);
+		(0, import_defineProperty$1.default)(this, "context", {});
+	}
+	setContext(context) {
+		this.context = {
+			...this.context,
+			...context
+		};
+	}
+	getContext() {
+		return { ...this.context };
+	}
+	clearContext() {
+		this.context = {};
+	}
+	formatWithContext(level, message) {
+		const contextParts = [];
+		if (this.context.sessionId) contextParts.push(`session=${this.context.sessionId}`);
+		if (this.context.traceId) contextParts.push(`trace=${this.context.traceId}`);
+		if (this.context.spanId) contextParts.push(`span=${this.context.spanId}`);
+		const contextStr = contextParts.length > 0 ? ` [${contextParts.join(", ")}]` : "";
+		return `[${level.toUpperCase()}]${contextStr} ${message}`;
+	}
+	logWithContext(level, message, ...args) {
+		const levelName = LogLevel[level].toLowerCase();
+		const formattedMessage = this.formatWithContext(levelName, message);
+		switch (level) {
+			case LogLevel.TRACE:
+				if (this.shouldLog(LogLevel.TRACE)) console.trace(formattedMessage, ...args);
+				break;
+			case LogLevel.DEBUG:
+				if (this.shouldLog(LogLevel.DEBUG)) console.debug(formattedMessage, ...args);
+				break;
+			case LogLevel.INFO:
+				if (this.shouldLog(LogLevel.INFO)) console.info(formattedMessage, ...args);
+				break;
+			case LogLevel.WARN:
+				if (this.shouldLog(LogLevel.WARN)) console.warn(formattedMessage, ...args);
+				break;
+			case LogLevel.ERROR:
+				if (this.shouldLog(LogLevel.ERROR)) console.error(formattedMessage, ...args);
+				break;
+			case LogLevel.FATAL:
+				if (this.shouldLog(LogLevel.FATAL)) console.error(formattedMessage, ...args);
+				break;
+		}
+	}
+	trace(message, ...args) {
+		this.logWithContext(LogLevel.TRACE, message, ...args);
+	}
+	debug(message, ...args) {
+		this.logWithContext(LogLevel.DEBUG, message, ...args);
+	}
+	info(message, ...args) {
+		this.logWithContext(LogLevel.INFO, message, ...args);
+	}
+	warn(message, ...args) {
+		this.logWithContext(LogLevel.WARN, message, ...args);
+	}
+	error(message, ...args) {
+		this.logWithContext(LogLevel.ERROR, message, ...args);
+	}
+	fatal(message, ...args) {
+		this.logWithContext(LogLevel.FATAL, message, ...args);
+	}
+};
+
+//#endregion
+//#region src/ActionRegister.ts
 var import_defineProperty = __toESM(require_defineProperty(), 1);
+/**
+* Core action pipeline management system
+* @template T - Action payload map defining available actions and their payload types
+* @example
+* ```typescript
+* interface AppActions extends ActionPayloadMap {
+*   increment: void;
+*   setCount: number;
+* }
+* 
+* const actionRegister = new ActionRegister<AppActions>();
+* 
+* // Register handlers
+* actionRegister.register('increment', () => console.log('Incremented'));
+* actionRegister.register('setCount', (count) => console.log(`Count: ${count}`));
+* 
+* // Dispatch actions
+* await actionRegister.dispatch('increment');
+* await actionRegister.dispatch('setCount', 42);
+* ```
+*/
 var ActionRegister = class {
-	constructor() {
+	constructor(config) {
 		(0, import_defineProperty.default)(this, "pipelines", /* @__PURE__ */ new Map());
 		(0, import_defineProperty.default)(this, "atomSetters", /* @__PURE__ */ new Map());
+		(0, import_defineProperty.default)(this, "handlerCounter", 0);
+		(0, import_defineProperty.default)(this, "logger", void 0);
+		const envLogLevel = getLogLevelFromEnv();
+		const configLogLevel = config?.logLevel ?? envLogLevel;
+		if (config?.logger) this.logger = config.logger;
+		else if (config?.useOtel) this.logger = new OtelConsoleLogger(configLogLevel);
+		else this.logger = new ConsoleLogger(configLogLevel);
+		if (config?.otelContext && this.logger instanceof OtelConsoleLogger) this.logger.setContext(config.otelContext);
+		this.logger.debug("ActionRegister initialized", {
+			logLevel: configLogLevel,
+			useOtel: config?.useOtel ?? false,
+			hasOtelContext: !!config?.otelContext
+		});
 	}
+	/**
+	* 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('increment', () => {
+	*   console.log('Incremented!');
+	* }, { priority: 10 });
+	* 
+	* // Later, remove the handler
+	* unregister();
+	* ```
+	*/
 	register(action, handler, config = {}) {
-		if (!this.pipelines.has(action)) this.pipelines.set(action, /* @__PURE__ */ new Map());
+		if (!this.pipelines.has(action)) {
+			this.pipelines.set(action, /* @__PURE__ */ new Map());
+			this.logger.debug(`Created new pipeline for action: ${String(action)}`);
+		}
 		const pipeline = this.pipelines.get(action);
-		const handlerId = config.id || `handler_${Date.now()}_${Math.random()}`;
+		const handlerId = config.id || `handler_${++this.handlerCounter}`;
 		if (pipeline.has(handlerId)) {
-			console.warn(`Handler with id ${handlerId} already exists`);
+			this.logger.warn(`Handler with id ${handlerId} already exists for action: ${String(action)}`);
 			return () => {};
 		}
 		pipeline.set(handlerId, {
 			handler,
 			config
 		});
+		this.logger.debug(`Registered handler for action: ${String(action)}`, {
+			handlerId,
+			priority: config.priority ?? 0,
+			blocking: config.blocking ?? false
+		});
 		this.sortPipeline(action);
 		return () => {
 			pipeline.delete(handlerId);
+			this.logger.debug(`Unregistered handler: ${handlerId} for action: ${String(action)}`);
 		};
 	}
 	registerAtomSetter(name, setter) {
 		this.atomSetters.set(name, setter);
+		this.logger.debug(`Registered atom setter: ${name}`);
 	}
+	/**
+	* Internal dispatch implementation
+	* @internal
+	*/
 	async dispatch(action, payload) {
 		const pipeline = this.pipelines.get(action);
+		if (this.logger instanceof OtelConsoleLogger && payload) {
+			const otelContext = createOtelContextFromPayload(payload);
+			if (otelContext.traceId || otelContext.sessionId) this.logger.setContext(otelContext);
+		}
+		this.logger.debug(`Dispatching action: ${String(action)}`, { payload });
 		if (!pipeline || pipeline.size === 0) {
-			console.warn(`No handlers registered for action: ${String(action)}`);
+			this.logger.warn(`No handlers registered for action: ${String(action)}`);
 			return;
 		}
 		let modifiedPayload = payload;
 		const handlers = Array.from(pipeline.values());
+		let shouldContinue = true;
+		this.logger.trace(`Executing pipeline for action: ${String(action)}`, { handlerCount: handlers.length });
 		for (const { handler, config } of handlers) {
-			let shouldContinue = true;
+			if (!shouldContinue) break;
 			const controller = {
 				next: () => {
 					shouldContinue = true;
 				},
 				abort: (reason) => {
 					shouldContinue = false;
-					console.log(`Pipeline aborted: ${reason}`);
+					this.logger.warn(`Pipeline aborted: ${reason}`);
 				},
 				modifyPayload: (modifier) => {
 					modifiedPayload = modifier(modifiedPayload);
+					this.logger.trace(`Payload modified for action: ${String(action)}`);
 				}
 			};
 			try {
 				if (config.blocking) await handler(modifiedPayload, controller);
 				else handler(modifiedPayload, controller);
-				if (!shouldContinue) break;
 			} catch (error) {
-				console.error(`Error in pipeline handler:`, error);
+				this.logger.error(`Error in pipeline handler for action: ${String(action)}`, error);
 				if (config.blocking) throw error;
 			}
 		}
+		this.logger.debug(`Completed dispatching action: ${String(action)}`);
 	}
 	sortPipeline(action) {
 		const pipeline = this.pipelines.get(action);
@@ -154,11 +395,15 @@ var ActionRegister = class {
 		});
 		pipeline.clear();
 		sorted.forEach(([id, data]) => pipeline.set(id, data));
+		this.logger.trace(`Sorted pipeline for action: ${String(action)}`, {
+			handlerCount: sorted.length,
+			priorities: sorted.map(([, data]) => data.config.priority ?? 0)
+		});
 	}
 };
 
 //#endregion
-//#region src/core/types.ts
+//#region src/types.ts
 function createAction(type, payload) {
 	return {
 		type,
@@ -169,57 +414,15 @@ function isAction(action, type) {
 	return action?.type === type;
 }
 
-//#endregion
-//#region src/react/ActionContext.tsx
-/**
-* ActionRegister를 Context로 공유할 수 있는 헬퍼 함수
-* @returns Provider, hooks를 포함한 객체
-*/
-function createActionContext() {
-	const ActionContext = (0, react.createContext)(null);
-	const Provider = ({ children }) => {
-		const actionRegisterRef = (0, react.useRef)(new ActionRegister());
-		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ActionContext.Provider, {
-			value: { actionRegisterRef },
-			children
-		});
-	};
-	const useActionContext = () => {
-		const context = (0, react.useContext)(ActionContext);
-		if (!context) throw new Error("useActionContext must be used within Provider");
-		return context;
-	};
-	const useAction = () => {
-		const { actionRegisterRef } = useActionContext();
-		return actionRegisterRef.current;
-	};
-	const useActionHandler = (action, handler, config) => {
-		const actionRegister = useAction();
-		const componentId = (0, react.useId)();
-		(0, react.useEffect)(() => {
-			const unregister = actionRegister.register(action, handler, {
-				...config,
-				id: config?.id || componentId
-			});
-			return unregister;
-		}, [
-			action,
-			handler,
-			config,
-			componentId,
-			actionRegister
-		]);
-	};
-	return {
-		Provider,
-		useActionContext,
-		useAction,
-		useActionHandler
-	};
-}
-
 //#endregion
 exports.ActionRegister = ActionRegister;
+exports.ConsoleLogger = ConsoleLogger;
+exports.LogLevel = LogLevel;
+exports.OtelConsoleLogger = OtelConsoleLogger;
 exports.createAction = createAction;
-exports.createActionContext = createActionContext;
-exports.isAction = isAction;
+exports.createOtelContextFromPayload = createOtelContextFromPayload;
+exports.extractSessionIdFromPayload = extractSessionIdFromPayload;
+exports.extractTraceIdFromPayload = extractTraceIdFromPayload;
+exports.getLogLevelFromEnv = getLogLevelFromEnv;
+exports.isAction = isAction;
+exports.parseLogLevel = parseLogLevel;

package/dist/index.d.cts

@@ -1,30 +1,230 @@
-import React, { ReactNode } from "react";
-
-//#region src/core/ActionRegister.d.ts
+//#region src/logger.d.ts
+/**
+ * Log levels in order of severity (lowest to highest)
+ */
+declare enum LogLevel {
+  TRACE = 0,
+  DEBUG = 1,
+  INFO = 2,
+  WARN = 3,
+  ERROR = 4,
+  FATAL = 5,
+}
+/**
+ * Logger interface for custom logger implementations
+ */
+interface Logger {
+  trace(message: string, ...args: any[]): void;
+  debug(message: string, ...args: any[]): void;
+  info(message: string, ...args: any[]): void;
+  warn(message: string, ...args: any[]): void;
+  error(message: string, ...args: any[]): void;
+  fatal(message: string, ...args: any[]): void;
+}
+/**
+ * Default console logger implementation
+ */
+declare class ConsoleLogger implements Logger {
+  private level;
+  constructor(level?: LogLevel);
+  protected shouldLog(level: LogLevel): boolean;
+  private formatMessage;
+  trace(message: string, ...args: any[]): void;
+  debug(message: string, ...args: any[]): void;
+  info(message: string, ...args: any[]): void;
+  warn(message: string, ...args: any[]): void;
+  error(message: string, ...args: any[]): void;
+  fatal(message: string, ...args: any[]): void;
+  setLevel(level: LogLevel): void;
+}
+/**
+ * Parse log level from string
+ */
+declare function parseLogLevel(level: string): LogLevel;
+/**
+ * Get log level from environment variable or default to ERROR
+ */
+declare function getLogLevelFromEnv(): LogLevel;
+/**
+ * Extract trace ID from payload if it exists
+ */
+declare function extractTraceIdFromPayload(payload: any): string | undefined;
+/**
+ * Extract session ID from payload if it exists
+ */
+declare function extractSessionIdFromPayload(payload: any): string | undefined;
+/**
+ * Create OTEL context from payload
+ */
+declare function createOtelContextFromPayload(payload: any): OtelContext;
+/**
+ * OpenTelemetry context interface for tracing
+ */
+interface OtelContext {
+  /** Session ID for tracking user sessions */
+  sessionId?: string;
+  /** Trace ID for distributed tracing */
+  traceId?: string;
+  /** Span ID for current operation */
+  spanId?: string;
+  /** Parent span ID for operation hierarchy */
+  parentSpanId?: string;
+  /** Additional context metadata */
+  metadata?: Record<string, any>;
+}
+/**
+ * Extended logger interface with OpenTelemetry support
+ */
+interface OtelLogger extends Logger {
+  /** Set OpenTelemetry context */
+  setContext(context: OtelContext): void;
+  /** Get current OpenTelemetry context */
+  getContext(): OtelContext;
+  /** Clear OpenTelemetry context */
+  clearContext(): void;
+  /** Log with OpenTelemetry context */
+  logWithContext(level: LogLevel, message: string, ...args: any[]): void;
+}
+/**
+ * OpenTelemetry-aware console logger implementation
+ */
+declare class OtelConsoleLogger extends ConsoleLogger implements OtelLogger {
+  private context;
+  constructor(level?: LogLevel);
+  setContext(context: OtelContext): void;
+  getContext(): OtelContext;
+  clearContext(): void;
+  private formatWithContext;
+  logWithContext(level: LogLevel, message: string, ...args: any[]): void;
+  trace(message: string, ...args: any[]): void;
+  debug(message: string, ...args: any[]): void;
+  info(message: string, ...args: any[]): void;
+  warn(message: string, ...args: any[]): void;
+  error(message: string, ...args: any[]): void;
+  fatal(message: string, ...args: any[]): void;
+}
+//# sourceMappingURL=logger.d.ts.map
+//#endregion
+//#region src/ActionRegister.d.ts
+/**
+ * Controller object provided to action handlers for pipeline management
+ * @template T - The type of the payload being processed
+ */
 type PipelineController<T = any> = {
+  /** Continue to the next handler in the pipeline */
   next: () => void;
+  /** Abort the pipeline execution with an optional reason */
   abort: (reason?: string) => void;
+  /** Modify the payload that will be passed to subsequent handlers */
   modifyPayload: (modifier: (payload: T) => T) => void;
 };
+/**
+ * Action handler function that processes actions in the pipeline
+ * @template T - The type of the payload
+ * @param payload - The data passed to the handler
+ * @param controller - Pipeline controller for flow management
+ * @returns void or Promise<void> for async handlers
+ */
 type ActionHandler<T = any> = (payload: T, controller: PipelineController<T>) => void | Promise<void>;
+/**
+ * Configuration options for action handlers
+ */
 type HandlerConfig = {
+  /** Priority level (higher numbers execute first). Default: 0 */
   priority?: number;
+  /** Unique identifier for the handler. Auto-generated if not provided */
   id?: string;
+  /** Whether to wait for async handlers to complete. Default: false */
   blocking?: boolean;
 };
+/**
+ * Base interface for defining action payload mappings
+ * @example
+ * ```typescript
+ * interface MyActions extends ActionPayloadMap {
+ *   increment: void;
+ *   setCount: number;
+ *   updateUser: { id: string; name: string };
+ * }
+ * ```
+ */
 interface ActionPayloadMap {}
+/**
+ * Configuration options for ActionRegister
+ */
+interface ActionRegisterConfig {
+  /** Custom logger implementation. Defaults to ConsoleLogger */
+  logger?: Logger;
+  /** Log level for the logger. Defaults to ERROR if not provided */
+  logLevel?: LogLevel;
+  /** OpenTelemetry context for tracing */
+  otelContext?: OtelContext;
+  /** Whether to use OTEL-aware logger. Defaults to false */
+  useOtel?: boolean;
+}
+/**
+ * Core action pipeline management system
+ * @template T - Action payload map defining available actions and their payload types
+ * @example
+ * ```typescript
+ * interface AppActions extends ActionPayloadMap {
+ *   increment: void;
+ *   setCount: number;
+ * }
+ *
+ * const actionRegister = new ActionRegister<AppActions>();
+ *
+ * // Register handlers
+ * actionRegister.register('increment', () => console.log('Incremented'));
+ * actionRegister.register('setCount', (count) => console.log(`Count: ${count}`));
+ *
+ * // Dispatch actions
+ * await actionRegister.dispatch('increment');
+ * await actionRegister.dispatch('setCount', 42);
+ * ```
+ */
 declare class ActionRegister<T extends ActionPayloadMap = ActionPayloadMap> {
   private pipelines;
   private atomSetters;
+  private handlerCounter;
+  readonly logger: Logger;
+  constructor(config?: ActionRegisterConfig);
+  /**
+   * 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('increment', () => {
+   *   console.log('Incremented!');
+   * }, { priority: 10 });
+   *
+   * // Later, remove the handler
+   * unregister();
+   * ```
+   */
   register<K extends keyof T>(action: K, handler: ActionHandler<T[K]>, config?: HandlerConfig): () => void;
   registerAtomSetter(name: string, setter: Function): void;
+  /**
+   * Dispatch an action through the pipeline (for actions without payload)
+   * @param action - The action to dispatch
+   * @returns Promise that resolves when all handlers complete
+   */
   dispatch<K extends keyof T>(action: T[K] extends void ? K : never): Promise<void>;
+  /**
+   * Dispatch an action through the pipeline (for actions with payload)
+   * @param action - The action to dispatch
+   * @param payload - The payload data to pass to handlers
+   * @returns Promise that resolves when all handlers complete
+   */
   dispatch<K extends keyof T>(action: K, payload: T[K]): Promise<void>;
   private sortPipeline;
 }
 //# sourceMappingURL=ActionRegister.d.ts.map
 //#endregion
-//#region src/core/types.d.ts
+//#region src/types.d.ts
 interface BaseActionPayloadMap {}
 type ActionType<T extends Record<string, any>> = keyof T;
 type ActionPayload<T extends Record<string, any>, K extends keyof T> = T[K];
@@ -38,32 +238,7 @@ declare function isAction<T extends Record<string, any>, K extends keyof T>(acti
   payload: T[K];
 };
 //# sourceMappingURL=types.d.ts.map
-//#endregion
-//#region src/react/ActionContext.d.ts
-/**
- * Context type for ActionRegister
- */
-interface ActionContextType<T extends ActionPayloadMap = ActionPayloadMap> {
-  actionRegisterRef: React.RefObject<ActionRegister<T>>;
-}
-/**
- * Return type for createActionContext
- */
-interface ActionContextReturn<T extends ActionPayloadMap = ActionPayloadMap> {
-  Provider: React.FC<{
-    children: ReactNode;
-  }>;
-  useActionContext: () => ActionContextType<T>;
-  useAction: () => ActionRegister<T>;
-  useActionHandler: <K extends keyof T>(action: K, handler: ActionHandler<T[K]>, config?: HandlerConfig) => void;
-}
-/**
- * ActionRegister를 Context로 공유할 수 있는 헬퍼 함수
- * @returns Provider, hooks를 포함한 객체
- */
-declare function createActionContext<T extends ActionPayloadMap = ActionPayloadMap>(): ActionContextReturn<T>;
-//# sourceMappingURL=ActionContext.d.ts.map
 
 //#endregion
-export { ActionHandler, ActionHandlerMap, ActionPayload, ActionPayloadMap, ActionRegister, ActionType, BaseActionPayloadMap, HandlerConfig, PipelineController, createAction, createActionContext, isAction };
+export { ActionHandler, ActionHandlerMap, ActionPayload, ActionPayloadMap, ActionRegister, ActionRegisterConfig, ActionType, BaseActionPayloadMap, ConsoleLogger, HandlerConfig, LogLevel, Logger, OtelConsoleLogger, OtelContext, OtelLogger, PipelineController, createAction, createOtelContextFromPayload, extractSessionIdFromPayload, extractTraceIdFromPayload, getLogLevelFromEnv, isAction, parseLogLevel };
 //# sourceMappingURL=index.d.cts.map