@adaas/a-utils 0.1.18 → 0.1.19

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { A_Inject, A_Scope, A_Feature, A_Concept, A_Container, A_Error, A_TypeGuards, A_Fragment, A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY, A_CommonHelper, A_FormatterHelper, A_Component, A_Context, A_IdentityHelper, A_Entity, A_ScopeError } from '@adaas/a-concept';
+import { A_Feature, A_Inject, A_Scope, A_Error, A_Dependency, A_Concept, A_Container, A_TypeGuards, A_Fragment, A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY, A_CommonHelper, A_FormatterHelper, A_Component, A_Context, A_IdentityHelper, A_Entity, A_ScopeError } from '@adaas/a-concept';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -11,97 +11,36 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
-
-// src/lib/A-Channel/A-Channel.constants.ts
-var A_ChannelFeatures = /* @__PURE__ */ ((A_ChannelFeatures2) => {
-  A_ChannelFeatures2["onTimeout"] = "onTimeout";
-  A_ChannelFeatures2["onRetry"] = "onRetry";
-  A_ChannelFeatures2["onCircuitBreakerOpen"] = "onCircuitBreakerOpen";
-  A_ChannelFeatures2["onCache"] = "onCache";
-  A_ChannelFeatures2["onConnect"] = "onConnect";
-  A_ChannelFeatures2["onDisconnect"] = "onDisconnect";
-  A_ChannelFeatures2["onBeforeRequest"] = "onBeforeRequest";
-  A_ChannelFeatures2["onRequest"] = "onRequest";
-  A_ChannelFeatures2["onAfterRequest"] = "onAfterRequest";
-  A_ChannelFeatures2["onError"] = "onError";
-  A_ChannelFeatures2["onSend"] = "onSend";
-  A_ChannelFeatures2["onConsume"] = "onConsume";
-  return A_ChannelFeatures2;
-})(A_ChannelFeatures || {});
-var A_ChannelRequestStatuses = /* @__PURE__ */ ((A_ChannelRequestStatuses2) => {
-  A_ChannelRequestStatuses2["PENDING"] = "PENDING";
-  A_ChannelRequestStatuses2["SUCCESS"] = "SUCCESS";
-  A_ChannelRequestStatuses2["FAILED"] = "FAILED";
-  return A_ChannelRequestStatuses2;
-})(A_ChannelRequestStatuses || {});
-
-// src/lib/A-Channel/A-ChannelRequest.context.ts
-var A_ChannelRequest = class extends A_Fragment {
-  constructor(params = {}) {
+var A_OperationContext = class extends A_Fragment {
+  constructor(operation, params) {
     super();
-    this._errors = /* @__PURE__ */ new Set();
-    this._status = "PENDING" /* PENDING */;
-    this._params = params;
-  }
-  /**
-   * Returns the status of the request
-   */
-  get status() {
-    return this._status;
+    this.meta.set("name", operation);
+    this.meta.set("params", params || {});
   }
-  /**
-   * Returns the parameters of the request
-   */
-  get failed() {
-    return this._errors.size > 0;
+  get name() {
+    return this._meta.get("name") || this._name;
   }
-  /**
-   * Returns the Params of the Request
-   */
-  get params() {
-    return this._params;
+  get result() {
+    return this._meta.get("result");
   }
-  /**
-   * Returns the Result of the Request
-   */
-  get data() {
-    return this._result;
+  get error() {
+    return this._meta.get("error");
   }
-  get errors() {
-    return this._errors.size > 0 ? this._errors : void 0;
+  get params() {
+    return this._meta.get("params") || {};
   }
-  // ==========================================================
-  // ==================== Mutations ===========================
-  // ==========================================================
-  /**
-   * Adds an error to the context
-   * 
-   * @param error 
-   */
   fail(error) {
-    this._status = "FAILED" /* FAILED */;
-    this._errors.add(error);
+    this._meta.set("error", error);
   }
-  /**
-   * Sets the result of the request
-   * 
-   * @param result 
-   */
   succeed(result) {
-    this._status = "SUCCESS" /* SUCCESS */;
-    this._result = result;
+    this._meta.set("result", result);
   }
-  /**
-   * Serializes the context to a JSON object
-   * 
-   * @returns 
-   */
   toJSON() {
     return {
-      params: this._params,
-      result: this._result,
-      status: this._status,
-      errors: this.errors ? Array.from(this._errors).map((err) => err.toString()) : void 0
+      name: this.name,
+      params: this.params,
+      result: this.result || {},
+      error: this.error?.toJSON()
     };
   }
 };
@@ -120,7 +59,7 @@ var A_ChannelError = class extends A_Error {
       super(originalError, context);
     else
       super(originalError);
-    if (context instanceof A_ChannelRequest)
+    if (context instanceof A_OperationContext)
       this._context = context;
   }
   /***
@@ -135,475 +74,120 @@ var A_ChannelError = class extends A_Error {
 // ==========================================================
 A_ChannelError.MethodNotImplemented = "A-Channel Method Not Implemented";
 
-// src/lib/A-Config/A-Config.constants.ts
-var A_CONSTANTS__CONFIG_ENV_VARIABLES = {};
-var A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY = [];
+// src/lib/A-Channel/A-Channel.constants.ts
+var A_ChannelFeatures = /* @__PURE__ */ ((A_ChannelFeatures2) => {
+  A_ChannelFeatures2["onTimeout"] = "onTimeout";
+  A_ChannelFeatures2["onRetry"] = "onRetry";
+  A_ChannelFeatures2["onCircuitBreakerOpen"] = "onCircuitBreakerOpen";
+  A_ChannelFeatures2["onCache"] = "onCache";
+  A_ChannelFeatures2["onConnect"] = "onConnect";
+  A_ChannelFeatures2["onDisconnect"] = "onDisconnect";
+  A_ChannelFeatures2["onBeforeRequest"] = "onBeforeRequest";
+  A_ChannelFeatures2["onRequest"] = "onRequest";
+  A_ChannelFeatures2["onAfterRequest"] = "onAfterRequest";
+  A_ChannelFeatures2["onError"] = "onError";
+  A_ChannelFeatures2["onSend"] = "onSend";
+  A_ChannelFeatures2["onConsume"] = "onConsume";
+  return A_ChannelFeatures2;
+})(A_ChannelFeatures || {});
+var A_ChannelRequestStatuses = /* @__PURE__ */ ((A_ChannelRequestStatuses2) => {
+  A_ChannelRequestStatuses2["PENDING"] = "PENDING";
+  A_ChannelRequestStatuses2["SUCCESS"] = "SUCCESS";
+  A_ChannelRequestStatuses2["FAILED"] = "FAILED";
+  return A_ChannelRequestStatuses2;
+})(A_ChannelRequestStatuses || {});
 
-// src/lib/A-Config/A-Config.context.ts
-var A_Config = class extends A_Fragment {
-  constructor(config) {
-    super({
-      name: "A_Config"
-    });
-    this.VARIABLES = /* @__PURE__ */ new Map();
-    this.DEFAULT_ALLOWED_TO_READ_PROPERTIES = [
-      ...A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY,
-      ...A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY
-    ];
-    this.config = A_CommonHelper.deepCloneAndMerge(config, {
-      strict: false,
-      defaults: {},
-      variables: A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY
-    });
-    this.CONFIG_PROPERTIES = this.config.variables ? this.config.variables : [];
-    this.config.variables.forEach((variable) => {
-      this.VARIABLES.set(
-        A_FormatterHelper.toUpperSnakeCase(variable),
-        this.config.defaults[variable]
-      );
-    });
+// src/lib/A-Channel/A-ChannelRequest.context.ts
+var A_ChannelRequest = class extends A_OperationContext {
+  constructor(params) {
+    super("request", params);
   }
-  /** 
-   * This method is used to get the configuration property by name
-   * 
-   * @param property 
-   * @returns 
-   */
-  get(property) {
-    if (this.CONFIG_PROPERTIES.includes(property) || this.DEFAULT_ALLOWED_TO_READ_PROPERTIES.includes(property) || !this.config.strict)
-      return this.VARIABLES.get(A_FormatterHelper.toUpperSnakeCase(property));
-    throw new Error("Property not exists or not allowed to read");
+  get status() {
+    return this.result?.status;
   }
-  set(property, value) {
-    const array = Array.isArray(property) ? property : typeof property === "string" ? [{ property, value }] : Object.keys(property).map((key) => ({
-      property: key,
-      value: property[key]
-    }));
-    for (const { property: property2, value: value2 } of array) {
-      let targetValue = value2 ? value2 : this.config?.defaults ? this.config.defaults[property2] : void 0;
-      this.VARIABLES.set(A_FormatterHelper.toUpperSnakeCase(property2), targetValue);
-    }
+  get data() {
+    return this.result?.data;
+  }
+  succeed(result) {
+    const existed = this.result;
+    super.succeed({
+      ...existed,
+      data: result,
+      status: "SUCCESS" /* SUCCESS */
+    });
   }
 };
 
-// src/lib/A-Logger/A-Logger.constants.ts
-var A_LOGGER_DEFAULT_SCOPE_LENGTH = 20;
-var A_LOGGER_COLORS = {
-  green: "32",
-  // Success, completion messages
-  blue: "34",
-  // Info, general messages  
-  red: "31",
-  // Errors, critical issues
-  yellow: "33",
-  // Warnings, caution messages
-  gray: "90",
-  // Debug, less important info
-  magenta: "35",
-  // Special highlighting
-  cyan: "36",
-  // Headers, titles
-  white: "37",
-  // Default text
-  pink: "95"
-  // Custom highlighting
-};
-var A_LOGGER_ANSI = {
-  RESET: "\x1B[0m",
-  PREFIX: "\x1B[",
-  SUFFIX: "m"
-};
-var A_LOGGER_TIME_FORMAT = {
-  MINUTES_PAD: 2,
-  SECONDS_PAD: 2,
-  MILLISECONDS_PAD: 3,
-  SEPARATOR: ":"
-};
-var A_LOGGER_FORMAT = {
-  SCOPE_OPEN: "[",
-  SCOPE_CLOSE: "]",
-  TIME_OPEN: "|",
-  TIME_CLOSE: "|",
-  SEPARATOR: "-------------------------------",
-  PIPE: "| "
-};
-var A_LOGGER_ENV_KEYS = {
-  LOG_LEVEL: "A_LOGGER_LEVEL"
-};
-
-// src/lib/A-Logger/A-Logger.component.ts
-var A_Logger = class extends A_Component {
-  // =============================================
-  // Constructor and Initialization
-  // =============================================
+// src/lib/A-Channel/A-Channel.component.ts
+var A_Channel = class extends A_Component {
   /**
-   * Initialize A_Logger with dependency injection
+   * Creates a new A_Channel instance.
    * 
-   * @param scope - The current scope context for message prefixing
-   * @param config - Optional configuration for log level filtering
+   * The channel must be registered with A_Context before use:
+   * ```typescript
+   * const channel = new A_Channel();
+   * A_Context.root.register(channel);
+   * ```
    */
-  constructor(scope, config) {
+  constructor() {
     super();
-    this.scope = scope;
-    this.config = config;
-    this.COLORS = A_LOGGER_COLORS;
-    this.STANDARD_SCOPE_LENGTH = config?.get("A_LOGGER_DEFAULT_SCOPE_LENGTH") || A_LOGGER_DEFAULT_SCOPE_LENGTH;
+    /**
+     * Indicates whether the channel is currently processing requests.
+     * This flag is managed automatically during request/send operations.
+     * 
+     * @readonly
+     */
+    this._processing = false;
+    /**
+     * Internal cache storage for channel-specific data.
+     * Can be used by custom implementations for caching responses,
+     * connection pools, or other channel-specific state.
+     * 
+     * @protected
+     */
+    this._cache = /* @__PURE__ */ new Map();
   }
-  // =============================================
-  // Scope and Formatting Utilities
-  // =============================================
   /**
-   * Get the formatted scope length for consistent message alignment
-   * Uses a standard length to ensure all messages align properly regardless of scope name
+   * Indicates whether the channel is currently processing requests.
    * 
-   * @returns The scope length to use for padding calculations
+   * @returns {boolean} True if channel is processing, false otherwise
    */
-  get scopeLength() {
-    return Math.max(this.scope.name.length, this.STANDARD_SCOPE_LENGTH);
+  get processing() {
+    return this._processing;
   }
   /**
-   * Get the formatted scope name with proper padding
-   * Ensures consistent width for all scope names in log output
+   * Promise that resolves when the channel is fully initialized.
+   * 
+   * Automatically calls the onConnect lifecycle hook if not already called.
+   * This ensures the channel is ready for communication operations.
    * 
-   * @returns Padded scope name for consistent formatting
+   * @returns {Promise<void>} Promise that resolves when initialization is complete
    */
-  get formattedScope() {
-    return this.scope.name.padEnd(this.STANDARD_SCOPE_LENGTH);
+  get initialize() {
+    if (!this._initialized) {
+      this._initialized = this.connect();
+    }
+    return this._initialized;
   }
-  // =============================================
-  // Message Compilation and Formatting
-  // =============================================
+  async onConnect(...args) {
+  }
+  async onDisconnect(...args) {
+  }
+  async onBeforeRequest(...args) {
+  }
+  async onRequest(...args) {
+  }
+  async onAfterRequest(...args) {
+  }
+  async onError(...args) {
+  }
+  async onSend(...args) {
+  }
+  // ==========================================================
+  // ================= Public API Methods ===================
+  // ==========================================================
   /**
-   * Compile log arguments into formatted console output with colors and proper alignment
-   * 
-   * This method handles the core formatting logic for all log messages:
-   * - Applies terminal color codes for visual distinction
-   * - Formats scope names with consistent padding
-   * - Handles different data types appropriately
-   * - Maintains proper indentation for multi-line content
-   * 
-   * @param color - The color key to apply to the message
-   * @param args - Variable arguments to format and display
-   * @returns Array of formatted strings ready for console output
-   */
-  compile(color, ...args) {
-    const timeString = this.getTime();
-    const scopePadding = " ".repeat(this.scopeLength + 3);
-    const isMultiArg = args.length > 1;
-    return [
-      // Header with color, scope, and timestamp
-      `${A_LOGGER_ANSI.PREFIX}${this.COLORS[color]}${A_LOGGER_ANSI.SUFFIX}${A_LOGGER_FORMAT.SCOPE_OPEN}${this.formattedScope}${A_LOGGER_FORMAT.SCOPE_CLOSE} ${A_LOGGER_FORMAT.TIME_OPEN}${timeString}${A_LOGGER_FORMAT.TIME_CLOSE}`,
-      // Top separator for multi-argument messages
-      isMultiArg ? `
-${scopePadding}${A_LOGGER_FORMAT.TIME_OPEN}${A_LOGGER_FORMAT.SEPARATOR}` : "",
-      // Process each argument with appropriate formatting
-      ...args.map((arg, i) => {
-        const shouldAddNewline = i > 0 || isMultiArg;
-        switch (true) {
-          case arg instanceof A_Error:
-            return this.compile_A_Error(arg);
-          case arg instanceof Error:
-            return this.compile_Error(arg);
-          case (typeof arg === "object" && arg !== null):
-            return this.formatObject(arg, shouldAddNewline, scopePadding);
-          default:
-            return this.formatString(String(arg), shouldAddNewline, scopePadding);
-        }
-      }),
-      // Bottom separator and color reset
-      isMultiArg ? `
-${scopePadding}${A_LOGGER_FORMAT.TIME_OPEN}${A_LOGGER_FORMAT.SEPARATOR}${A_LOGGER_ANSI.RESET}` : A_LOGGER_ANSI.RESET
-    ];
-  }
-  /**
-   * Format an object for display with proper JSON indentation
-   * 
-   * @param obj - The object to format
-   * @param shouldAddNewline - Whether to add a newline prefix
-   * @param scopePadding - The padding string for consistent alignment
-   * @returns Formatted object string
-   */
-  formatObject(obj, shouldAddNewline, scopePadding) {
-    let jsonString;
-    try {
-      jsonString = JSON.stringify(obj, null, 2);
-    } catch (error) {
-      const seen = /* @__PURE__ */ new WeakSet();
-      jsonString = JSON.stringify(obj, (key, value) => {
-        if (typeof value === "object" && value !== null) {
-          if (seen.has(value)) {
-            return "[Circular Reference]";
-          }
-          seen.add(value);
-        }
-        return value;
-      }, 2);
-    }
-    const formatted = jsonString.replace(/\n/g, `
-${scopePadding}${A_LOGGER_FORMAT.PIPE}`);
-    return shouldAddNewline ? `
-${scopePadding}${A_LOGGER_FORMAT.PIPE}` + formatted : formatted;
-  }
-  /**
-   * Format a string for display with proper indentation
-   * 
-   * @param str - The string to format
-   * @param shouldAddNewline - Whether to add a newline prefix
-   * @param scopePadding - The padding string for consistent alignment
-   * @returns Formatted string
-   */
-  formatString(str, shouldAddNewline, scopePadding) {
-    const prefix = shouldAddNewline ? "\n" : "";
-    return (prefix + str).replace(/\n/g, `
-${scopePadding}${A_LOGGER_FORMAT.PIPE}`);
-  }
-  // =============================================
-  // Log Level Management
-  // =============================================
-  /**
-   * Determine if a log message should be output based on configured log level
-   * 
-   * Log level hierarchy:
-   * - debug: Shows all messages
-   * - info: Shows info, warning, and error messages
-   * - warn: Shows warning and error messages only
-   * - error: Shows error messages only
-   * - all: Shows all messages (alias for debug)
-   * 
-   * @param logMethod - The type of log method being called
-   * @returns True if the message should be logged, false otherwise
-   */
-  shouldLog(logMethod) {
-    const shouldLog = this.config?.get(A_LOGGER_ENV_KEYS.LOG_LEVEL) || "all";
-    switch (shouldLog) {
-      case "debug":
-        return true;
-      case "info":
-        return logMethod === "log" || logMethod === "warning" || logMethod === "error";
-      case "warn":
-        return logMethod === "warning" || logMethod === "error";
-      case "error":
-        return logMethod === "error";
-      case "all":
-        return true;
-      default:
-        return false;
-    }
-  }
-  log(param1, ...args) {
-    if (!this.shouldLog("log")) return;
-    if (typeof param1 === "string" && this.COLORS[param1]) {
-      console.log(...this.compile(param1, ...args));
-    } else {
-      console.log(...this.compile("blue", param1, ...args));
-    }
-  }
-  /**
-   * Log warning messages with yellow color coding
-   * 
-   * Use for non-critical issues that should be brought to attention
-   * but don't prevent normal operation
-   * 
-   * @param args - Arguments to log as warnings
-   * 
-   * @example
-   * ```typescript
-   * logger.warning('Deprecated method used');
-   * logger.warning('Rate limit approaching:', { current: 95, limit: 100 });
-   * ```
-   */
-  warning(...args) {
-    if (!this.shouldLog("warning")) return;
-    console.log(...this.compile("yellow", ...args));
-  }
-  /**
-   * Log error messages with red color coding
-   * 
-   * Use for critical issues, exceptions, and failures that need immediate attention
-   * 
-   * @param args - Arguments to log as errors
-   * @returns void (for compatibility with console.log)
-   * 
-   * @example
-   * ```typescript
-   * logger.error('Database connection failed');
-   * logger.error(new Error('Validation failed'));
-   * logger.error('Critical error:', error, { context: 'user-registration' });
-   * ```
-   */
-  error(...args) {
-    if (!this.shouldLog("error")) return;
-    console.log(...this.compile("red", ...args));
-  }
-  // =============================================
-  // Specialized Error Formatting
-  // =============================================
-  /**
-   * Legacy method for A_Error logging (kept for backward compatibility)
-   * 
-   * @deprecated Use error() method instead which handles A_Error automatically
-   * @param error - The A_Error instance to log
-   */
-  log_A_Error(error) {
-    const time = this.getTime();
-    const scopePadding = " ".repeat(this.scopeLength + 3);
-    console.log(`\x1B[31m[${this.formattedScope}] |${time}| ERROR ${error.code}
-${scopePadding}| ${error.message}
-${scopePadding}| ${error.description} 
-${scopePadding}|-------------------------------
-${scopePadding}| ${error.stack?.split("\n").map((line, index) => index === 0 ? line : `${scopePadding}| ${line}`).join("\n") || "No stack trace"}
-${scopePadding}|-------------------------------
-\x1B[0m` + (error.originalError ? `\x1B[31m${scopePadding}| Wrapped From  ${error.originalError.message}
-${scopePadding}|-------------------------------
-${scopePadding}| ${error.originalError.stack?.split("\n").map((line, index) => index === 0 ? line : `${scopePadding}| ${line}`).join("\n") || "No stack trace"}
-${scopePadding}|-------------------------------
-\x1B[0m` : "") + (error.link ? `\x1B[31m${scopePadding}| Read in docs: ${error.link}
-${scopePadding}|-------------------------------
-\x1B[0m` : ""));
-  }
-  /**
-   * Format A_Error instances for inline display within compiled messages
-   * 
-   * Provides detailed formatting for A_Error objects including:
-   * - Error code and message
-   * - Description and stack trace
-   * - Original error information (if wrapped)
-   * - Documentation links (if available)
-   * 
-   * @param error - The A_Error instance to format
-   * @returns Formatted string ready for display
-   */
-  compile_A_Error(error) {
-    const scopePadding = " ".repeat(this.scopeLength + 3);
-    return `
-${scopePadding}|-------------------------------
-${scopePadding}|  Error:  | ${error.code}
-${scopePadding}|-------------------------------
-${scopePadding}|${" ".repeat(10)}| ${error.message}
-${scopePadding}|${" ".repeat(10)}| ${error.description} 
-${scopePadding}|-------------------------------
-${scopePadding}| ${error.stack?.split("\n").map((line, index) => index === 0 ? line : `${scopePadding}| ${line}`).join("\n") || "No stack trace"}
-${scopePadding}|-------------------------------` + (error.originalError ? `${scopePadding}| Wrapped From  ${error.originalError.message}
-${scopePadding}|-------------------------------
-${scopePadding}| ${error.originalError.stack?.split("\n").map((line, index) => index === 0 ? line : `${scopePadding}| ${line}`).join("\n") || "No stack trace"}
-${scopePadding}|-------------------------------` : "") + (error.link ? `${scopePadding}| Read in docs: ${error.link}
-${scopePadding}|-------------------------------` : "");
-  }
-  /**
-   * Format standard Error instances for inline display within compiled messages
-   * 
-   * Converts standard JavaScript Error objects into a readable JSON format
-   * with proper indentation and stack trace formatting
-   * 
-   * @param error - The Error instance to format
-   * @returns Formatted string ready for display
-   */
-  compile_Error(error) {
-    const scopePadding = " ".repeat(this.scopeLength + 3);
-    return JSON.stringify({
-      name: error.name,
-      message: error.message,
-      stack: error.stack?.split("\n").map((line, index) => index === 0 ? line : `${scopePadding}| ${line}`).join("\n")
-    }, null, 2).replace(/\n/g, `
-${scopePadding}| `).replace(/\\n/g, "\n");
-  }
-  // =============================================
-  // Utility Methods
-  // =============================================
-  /**
-   * Generate timestamp string for log messages
-   * 
-   * Format: MM:SS:mmm (minutes:seconds:milliseconds)
-   * This provides sufficient precision for debugging while remaining readable
-   * 
-   * @returns Formatted timestamp string
-   * 
-   * @example
-   * Returns: "15:42:137" for 3:42:15 PM and 137 milliseconds
-   */
-  getTime() {
-    const now = /* @__PURE__ */ new Date();
-    const minutes = String(now.getMinutes()).padStart(A_LOGGER_TIME_FORMAT.MINUTES_PAD, "0");
-    const seconds = String(now.getSeconds()).padStart(A_LOGGER_TIME_FORMAT.SECONDS_PAD, "0");
-    const milliseconds = String(now.getMilliseconds()).padStart(A_LOGGER_TIME_FORMAT.MILLISECONDS_PAD, "0");
-    return `${minutes}${A_LOGGER_TIME_FORMAT.SEPARATOR}${seconds}${A_LOGGER_TIME_FORMAT.SEPARATOR}${milliseconds}`;
-  }
-};
-A_Logger = __decorateClass([
-  __decorateParam(0, A_Inject(A_Scope)),
-  __decorateParam(1, A_Inject(A_Config))
-], A_Logger);
-
-// src/lib/A-Channel/A-Channel.component.ts
-var A_Channel = class extends A_Component {
-  /**
-   * Creates a new A_Channel instance.
-   * 
-   * The channel must be registered with A_Context before use:
-   * ```typescript
-   * const channel = new A_Channel();
-   * A_Context.root.register(channel);
-   * ```
-   */
-  constructor() {
-    super();
-    /**
-     * Indicates whether the channel is currently processing requests.
-     * This flag is managed automatically during request/send operations.
-     * 
-     * @readonly
-     */
-    this._processing = false;
-    /**
-     * Internal cache storage for channel-specific data.
-     * Can be used by custom implementations for caching responses,
-     * connection pools, or other channel-specific state.
-     * 
-     * @protected
-     */
-    this._cache = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Indicates whether the channel is currently processing requests.
-   * 
-   * @returns {boolean} True if channel is processing, false otherwise
-   */
-  get processing() {
-    return this._processing;
-  }
-  /**
-   * Promise that resolves when the channel is fully initialized.
-   * 
-   * Automatically calls the onConnect lifecycle hook if not already called.
-   * This ensures the channel is ready for communication operations.
-   * 
-   * @returns {Promise<void>} Promise that resolves when initialization is complete
-   */
-  get initialize() {
-    if (!this._initialized) {
-      this._initialized = this.connect();
-    }
-    return this._initialized;
-  }
-  async onConnect(...args) {
-  }
-  async onDisconnect(...args) {
-  }
-  async onBeforeRequest(...args) {
-  }
-  async onRequest(...args) {
-  }
-  async onAfterRequest(...args) {
-  }
-  async onError(...args) {
-  }
-  async onSend(...args) {
-  }
-  // ==========================================================
-  // ================= Public API Methods ===================
-  // ==========================================================
-  /**
-   * Initializes the channel by calling the onConnect lifecycle hook.
+   * Initializes the channel by calling the onConnect lifecycle hook.
    * 
    * This method is called automatically when accessing the `initialize` property.
    * You can also call it manually if needed.
@@ -668,7 +252,6 @@ var A_Channel = class extends A_Component {
     });
     const context = new A_ChannelRequest(params);
     try {
-      requestScope.inherit(A_Context.scope(this));
       requestScope.register(context);
       await this.call("onBeforeRequest" /* onBeforeRequest */, requestScope);
       await this.call("onRequest" /* onRequest */, requestScope);
@@ -679,8 +262,10 @@ var A_Channel = class extends A_Component {
       this._processing = false;
       const channelError = new A_ChannelError(error);
       context.fail(channelError);
+      requestScope.register(channelError);
       await this.call("onError" /* onError */, requestScope);
-      return context;
+      requestScope.destroy();
+      throw channelError;
     }
   }
   /**
@@ -731,7 +316,7 @@ var A_Channel = class extends A_Component {
     const requestScope = new A_Scope({
       name: `a-channel@scope:send:${A_IdentityHelper.generateTimeId()}`
     });
-    const context = new A_ChannelRequest(message);
+    const context = new A_OperationContext("send", message);
     try {
       requestScope.inherit(A_Context.scope(this));
       requestScope.register(context);
@@ -740,8 +325,10 @@ var A_Channel = class extends A_Component {
     } catch (error) {
       this._processing = false;
       const channelError = new A_ChannelError(error);
+      requestScope.register(channelError);
       context.fail(channelError);
       await this.call("onError" /* onError */, requestScope);
+      requestScope.destroy();
     }
   }
   /**
@@ -756,7 +343,7 @@ var A_Channel = class extends A_Component {
     await this.initialize;
     this._processing = true;
     const requestScope = new A_Scope({ name: `a-channel@scope:consume:${A_IdentityHelper.generateTimeId()}` });
-    const context = new A_ChannelRequest();
+    const context = new A_OperationContext("consume", {});
     try {
       requestScope.inherit(A_Context.scope(this));
       requestScope.register(context);
@@ -807,141 +394,741 @@ __decorateClass([
     name: "onSend" /* onSend */
   })
 ], A_Channel.prototype, "onSend", 1);
-var HttpChannel = class extends A_Channel {
+
+// src/lib/A-Command/A-Command.constants.ts
+var A_Command_Status = /* @__PURE__ */ ((A_Command_Status2) => {
+  A_Command_Status2["CREATED"] = "CREATED";
+  A_Command_Status2["INITIALIZED"] = "INITIALIZED";
+  A_Command_Status2["COMPILED"] = "COMPILED";
+  A_Command_Status2["EXECUTING"] = "EXECUTING";
+  A_Command_Status2["COMPLETED"] = "COMPLETED";
+  A_Command_Status2["FAILED"] = "FAILED";
+  return A_Command_Status2;
+})(A_Command_Status || {});
+var A_CommandTransitions = /* @__PURE__ */ ((A_CommandTransitions2) => {
+  A_CommandTransitions2["CREATED_TO_INITIALIZED"] = "created_initialized";
+  A_CommandTransitions2["INITIALIZED_TO_EXECUTING"] = "initialized_executing";
+  A_CommandTransitions2["EXECUTING_TO_COMPLETED"] = "executing_completed";
+  A_CommandTransitions2["EXECUTING_TO_FAILED"] = "executing_failed";
+  return A_CommandTransitions2;
+})(A_CommandTransitions || {});
+var A_CommandFeatures = /* @__PURE__ */ ((A_CommandFeatures2) => {
+  A_CommandFeatures2["onInit"] = "onInit";
+  A_CommandFeatures2["onBeforeExecute"] = "onBeforeExecute";
+  A_CommandFeatures2["onExecute"] = "onExecute";
+  A_CommandFeatures2["onAfterExecute"] = "onAfterExecute";
+  A_CommandFeatures2["onComplete"] = "onComplete";
+  A_CommandFeatures2["onFail"] = "onFail";
+  A_CommandFeatures2["onError"] = "onError";
+  return A_CommandFeatures2;
+})(A_CommandFeatures || {});
+var A_CommandError = class extends A_Error {
 };
-var PollyspotChannel = class extends HttpChannel {
-  constructor() {
+A_CommandError.CommandScopeBindingError = "A-Command Scope Binding Error";
+A_CommandError.ExecutionError = "A-Command Execution Error";
+A_CommandError.ResultProcessingError = "A-Command Result Processing Error";
+/**
+ * Error indicating that the command was interrupted during execution
+ */
+A_CommandError.CommandInterruptedError = "A-Command Interrupted Error";
+var A_StateMachineError = class extends A_Error {
+};
+A_StateMachineError.InitializationError = "A-StateMachine Initialization Error";
+A_StateMachineError.TransitionError = "A-StateMachine Transition Error";
+
+// src/lib/A-StateMachine/A-StateMachineTransition.context.ts
+var A_StateMachineTransition = class extends A_OperationContext {
+  constructor(params) {
+    super(
+      "a-state-machine-transition",
+      params
+    );
+    this._meta.set("from", params.from);
+    this._meta.set("to", params.to);
+  }
+  get from() {
+    return this._meta.get("from");
+  }
+  get to() {
+    return this._meta.get("to");
+  }
+};
+
+// src/lib/A-StateMachine/A-StateMachine.component.ts
+var _a, _b, _c, _d;
+var A_StateMachine = class extends A_Component {
+  /**
+   * Gets a promise that resolves when the state machine is fully initialized and ready for transitions.
+   * This ensures that all initialization hooks have been executed before allowing state transitions.
+   * 
+   * @returns Promise<void> that resolves when initialization is complete
+   * 
+   * @example
+   * ```typescript
+   * const stateMachine = new MyStateMachine();
+   * await stateMachine.ready; // Wait for initialization
+   * await stateMachine.transition('idle', 'running');
+   * ```
+   */
+  get ready() {
+    if (!this._initialized) {
+      this._initialized = this.call("onInitialize" /* onInitialize */);
+    }
+    return this._initialized;
+  }
+  async [_d = "onInitialize" /* onInitialize */](...args) {
+  }
+  async [_c = "onBeforeTransition" /* onBeforeTransition */](...args) {
+  }
+  async [_b = "onAfterTransition" /* onAfterTransition */](...args) {
+  }
+  async [_a = "onError" /* onError */](...args) {
+  }
+  /**
+   * Executes a state transition from one state to another.
+   * This is the core method of the state machine that handles the complete transition lifecycle.
+   * 
+   * @param from - The state to transition from (must be a key of T)
+   * @param to - The state to transition to (must be a key of T)
+   * @param props - Optional properties to pass to the transition context (should match T[keyof T])
+   * @returns Promise<void> that resolves when the transition is complete
+   * 
+   * @throws {A_StateMachineError} When the transition fails for any reason
+   * 
+   * @example
+   * ```typescript
+   * interface OrderStates {
+   *   pending: { orderId: string };
+   *   processing: { orderId: string; processedBy: string };
+   * }
+   * 
+   * const orderMachine = new A_StateMachine<OrderStates>();
+   * 
+   * // Transition with props
+   * await orderMachine.transition('pending', 'processing', {
+   *   orderId: '12345',
+   *   processedBy: 'user-456'
+   * });
+   * ```
+   * 
+   * The transition process follows this lifecycle:
+   * 1. Wait for state machine initialization (ready)
+   * 2. Create transition name in camelCase format (e.g., "pending_processing")
+   * 3. Create operation context with transition data
+   * 4. Create isolated scope for the transition
+   * 5. Call onBeforeTransition hook
+   * 6. Execute the specific transition method (if defined)
+   * 7. Call onAfterTransition hook
+   * 8. Clean up scope and return result
+   * 
+   * If any step fails, the onError hook is called and a wrapped error is thrown.
+   */
+  async transition(from, to, props) {
+    await this.ready;
+    const transitionName = `${A_FormatterHelper.toCamelCase(String(from))}_${A_FormatterHelper.toCamelCase(String(to))}`;
+    const transition = new A_StateMachineTransition({
+      from: String(from),
+      to: String(to),
+      props
+    });
+    const scope = new A_Scope({
+      name: `A-StateMachine-Transition-Scope-${transitionName}`,
+      fragments: [transition]
+    });
+    try {
+      await this.call("onBeforeTransition" /* onBeforeTransition */, scope);
+      await this.call(transitionName, scope);
+      await this.call("onAfterTransition" /* onAfterTransition */, scope);
+      scope.destroy();
+      return transition.result;
+    } catch (error) {
+      const wrappedError = new A_StateMachineError({
+        title: A_StateMachineError.TransitionError,
+        description: `An error occurred while transitioning to "${transitionName}"`,
+        originalError: error
+      });
+      scope.register(wrappedError);
+      await this.call("onError" /* onError */, scope);
+      scope.destroy();
+      throw wrappedError;
+    }
+  }
+};
+__decorateClass([
+  A_Feature.Extend()
+], A_StateMachine.prototype, _d, 1);
+__decorateClass([
+  A_Feature.Extend()
+], A_StateMachine.prototype, _c, 1);
+__decorateClass([
+  A_Feature.Extend()
+], A_StateMachine.prototype, _b, 1);
+__decorateClass([
+  A_Feature.Extend()
+], A_StateMachine.prototype, _a, 1);
+
+// src/lib/A-Config/A-Config.constants.ts
+var A_CONSTANTS__CONFIG_ENV_VARIABLES = {};
+var A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY = [];
+
+// src/lib/A-Config/A-Config.context.ts
+var A_Config = class extends A_Fragment {
+  constructor(config) {
+    super({
+      name: "A_Config"
+    });
+    this.VARIABLES = /* @__PURE__ */ new Map();
+    this.DEFAULT_ALLOWED_TO_READ_PROPERTIES = [
+      ...A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY,
+      ...A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY
+    ];
+    this.config = A_CommonHelper.deepCloneAndMerge(config, {
+      strict: false,
+      defaults: {},
+      variables: A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY
+    });
+    this.CONFIG_PROPERTIES = this.config.variables ? this.config.variables : [];
+    this.config.variables.forEach((variable) => {
+      this.VARIABLES.set(
+        A_FormatterHelper.toUpperSnakeCase(variable),
+        this.config.defaults[variable]
+      );
+    });
+  }
+  /** 
+   * This method is used to get the configuration property by name
+   * 
+   * @param property 
+   * @returns 
+   */
+  get(property) {
+    if (this.CONFIG_PROPERTIES.includes(property) || this.DEFAULT_ALLOWED_TO_READ_PROPERTIES.includes(property) || !this.config.strict)
+      return this.VARIABLES.get(A_FormatterHelper.toUpperSnakeCase(property));
+    throw new Error("Property not exists or not allowed to read");
+  }
+  set(property, value) {
+    const array = Array.isArray(property) ? property : typeof property === "string" ? [{ property, value }] : Object.keys(property).map((key) => ({
+      property: key,
+      value: property[key]
+    }));
+    for (const { property: property2, value: value2 } of array) {
+      let targetValue = value2 ? value2 : this.config?.defaults ? this.config.defaults[property2] : void 0;
+      this.VARIABLES.set(A_FormatterHelper.toUpperSnakeCase(property2), targetValue);
+    }
+  }
+};
+
+// src/lib/A-Logger/A-Logger.constants.ts
+var A_LOGGER_DEFAULT_SCOPE_LENGTH = 20;
+var A_LOGGER_COLORS = {
+  // System colors (reserved for specific purposes)
+  red: "31",
+  // Errors, critical issues
+  yellow: "33",
+  // Warnings, caution messages
+  green: "32",
+  // Success, completion messages
+  // Safe palette for random selection (grey-blue-violet theme)
+  blue: "34",
+  // Info, general messages
+  cyan: "36",
+  // Headers, titles
+  magenta: "35",
+  // Special highlighting
+  gray: "90",
+  // Debug, less important info
+  brightBlue: "94",
+  // Bright blue variant
+  brightCyan: "96",
+  // Bright cyan variant
+  brightMagenta: "95",
+  // Bright magenta variant
+  darkGray: "30",
+  // Dark gray
+  lightGray: "37",
+  // Light gray (white)
+  // Extended blue-violet palette
+  indigo: "38;5;54",
+  // Deep indigo
+  violet: "38;5;93",
+  // Violet
+  purple: "38;5;129",
+  // Purple
+  lavender: "38;5;183",
+  // Lavender
+  skyBlue: "38;5;117",
+  // Sky blue
+  steelBlue: "38;5;67",
+  // Steel blue
+  slateBlue: "38;5;62",
+  // Slate blue
+  deepBlue: "38;5;18",
+  // Deep blue
+  lightBlue: "38;5;153",
+  // Light blue
+  periwinkle: "38;5;111",
+  // Periwinkle
+  cornflower: "38;5;69",
+  // Cornflower blue
+  powder: "38;5;152",
+  // Powder blue
+  // Additional grays for variety
+  charcoal: "38;5;236",
+  // Charcoal
+  silver: "38;5;250",
+  // Silver
+  smoke: "38;5;244",
+  // Smoke gray
+  slate: "38;5;240"
+  // Slate gray
+};
+var A_LOGGER_SAFE_RANDOM_COLORS = [
+  "blue",
+  "cyan",
+  "magenta",
+  "gray",
+  "brightBlue",
+  "brightCyan",
+  "brightMagenta",
+  "darkGray",
+  "lightGray",
+  "indigo",
+  "violet",
+  "purple",
+  "lavender",
+  "skyBlue",
+  "steelBlue",
+  "slateBlue",
+  "deepBlue",
+  "lightBlue",
+  "periwinkle",
+  "cornflower",
+  "powder",
+  "charcoal",
+  "silver",
+  "smoke",
+  "slate"
+];
+var A_LOGGER_ANSI = {
+  RESET: "\x1B[0m",
+  PREFIX: "\x1B[",
+  SUFFIX: "m"
+};
+var A_LOGGER_TIME_FORMAT = {
+  MINUTES_PAD: 2,
+  SECONDS_PAD: 2,
+  MILLISECONDS_PAD: 3,
+  SEPARATOR: ":"
+};
+var A_LOGGER_FORMAT = {
+  SCOPE_OPEN: "[",
+  SCOPE_CLOSE: "]",
+  TIME_OPEN: "|",
+  TIME_CLOSE: "|",
+  SEPARATOR: "-------------------------------",
+  PIPE: "| "
+};
+var A_LOGGER_ENV_KEYS = {
+  LOG_LEVEL: "A_LOGGER_LEVEL",
+  DEFAULT_SCOPE_LENGTH: "A_LOGGER_DEFAULT_SCOPE_LENGTH",
+  DEFAULT_SCOPE_COLOR: "A_LOGGER_DEFAULT_SCOPE_COLOR",
+  DEFAULT_LOG_COLOR: "A_LOGGER_DEFAULT_LOG_COLOR"
+};
+
+// src/lib/A-Logger/A-Logger.component.ts
+var A_Logger = class extends A_Component {
+  // =============================================
+  // Constructor and Initialization
+  // =============================================
+  /**
+   * Initialize A_Logger with dependency injection
+   * Colors are configured through A_Config or generated randomly if not provided
+   * 
+   * @param scope - The current scope context for message prefixing
+   * @param config - Optional configuration for log level filtering and color settings
+   */
+  constructor(scope, config) {
     super();
-    this.baseUrl = "https://pollyspot.example.com";
+    this.scope = scope;
+    this.config = config;
+    this.COLORS = A_LOGGER_COLORS;
+    this.STANDARD_SCOPE_LENGTH = config?.get(A_LOGGER_ENV_KEYS.DEFAULT_SCOPE_LENGTH) || A_LOGGER_DEFAULT_SCOPE_LENGTH;
+    const configScopeColor = config?.get(A_LOGGER_ENV_KEYS.DEFAULT_SCOPE_COLOR);
+    const configLogColor = config?.get(A_LOGGER_ENV_KEYS.DEFAULT_LOG_COLOR);
+    if (configScopeColor || configLogColor) {
+      this.DEFAULT_SCOPE_COLOR = configScopeColor || this.generateColorFromScopeName(this.scope.name);
+      this.DEFAULT_LOG_COLOR = configLogColor || this.generateColorFromScopeName(this.scope.name);
+    } else {
+      const complementaryColors = this.generateComplementaryColorsFromScope(this.scope.name);
+      this.DEFAULT_SCOPE_COLOR = complementaryColors.scopeColor;
+      this.DEFAULT_LOG_COLOR = complementaryColors.logColor;
+    }
+  }
+  // =============================================
+  // Color Generation Utilities
+  // =============================================
+  /**
+   * Generate a simple hash from a string
+   * Used to create deterministic color selection based on scope name
+   * 
+   * @param str - The string to hash
+   * @returns A numeric hash value
+   */
+  simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash);
+  }
+  /**
+   * Generate a deterministic color based on scope name
+   * Same scope names will always get the same color, but uses safe color palette
+   * 
+   * @param scopeName - The scope name to generate color for
+   * @returns A color key from the safe colors palette
+   */
+  generateColorFromScopeName(scopeName) {
+    const safeColors = A_LOGGER_SAFE_RANDOM_COLORS;
+    const hash = this.simpleHash(scopeName);
+    const colorIndex = hash % safeColors.length;
+    return safeColors[colorIndex];
+  }
+  /**
+   * Generate a pair of complementary colors based on scope name
+   * Ensures visual harmony between scope and message colors while being deterministic
+   * 
+   * @param scopeName - The scope name to base colors on
+   * @returns Object with scopeColor and logColor that work well together
+   */
+  generateComplementaryColorsFromScope(scopeName) {
+    const colorPairs = [
+      { scopeColor: "indigo", logColor: "lightBlue" },
+      { scopeColor: "deepBlue", logColor: "cyan" },
+      { scopeColor: "purple", logColor: "lavender" },
+      { scopeColor: "steelBlue", logColor: "skyBlue" },
+      { scopeColor: "slateBlue", logColor: "periwinkle" },
+      { scopeColor: "charcoal", logColor: "silver" },
+      { scopeColor: "violet", logColor: "brightMagenta" },
+      { scopeColor: "darkGray", logColor: "lightGray" },
+      { scopeColor: "cornflower", logColor: "powder" },
+      { scopeColor: "slate", logColor: "smoke" }
+    ];
+    const hash = this.simpleHash(scopeName);
+    const pairIndex = hash % colorPairs.length;
+    return colorPairs[pairIndex];
+  }
+  // =============================================
+  // Factory Methods
+  // =============================================
+  // =============================================
+  // Scope and Formatting Utilities
+  // =============================================
+  /**
+   * Get the formatted scope length for consistent message alignment
+   * Uses a standard length to ensure all messages align properly regardless of scope name
+   * 
+   * @returns The scope length to use for padding calculations
+   */
+  get scopeLength() {
+    return Math.max(this.scope.name.length, this.STANDARD_SCOPE_LENGTH);
   }
-};
-var GlobalErrorhandler = class extends A_Component {
-  async handleError(context, logger, config) {
+  /**
+   * Get the formatted scope name with proper padding, centered within the container
+   * Ensures consistent width for all scope names in log output with centered alignment
+   * 
+   * @returns Centered and padded scope name for consistent formatting
+   */
+  get formattedScope() {
+    const scopeName = this.scope.name;
+    const totalLength = this.STANDARD_SCOPE_LENGTH;
+    if (scopeName.length >= totalLength) {
+      return scopeName.substring(0, totalLength);
+    }
+    const totalPadding = totalLength - scopeName.length;
+    const leftPadding = Math.floor(totalPadding / 2);
+    const rightPadding = totalPadding - leftPadding;
+    return " ".repeat(leftPadding) + scopeName + " ".repeat(rightPadding);
   }
-  async anotherError(context, logger, config) {
+  // =============================================
+  // Message Compilation and Formatting
+  // =============================================
+  /**
+   * Compile log arguments into formatted console output with colors and proper alignment
+   * 
+   * This method handles the core formatting logic for all log messages:
+   * - Applies separate colors for scope and message content
+   * - Formats scope names with consistent padding
+   * - Handles different data types appropriately
+   * - Maintains proper indentation for multi-line content
+   * 
+   * @param messageColor - The color key to apply to the message content
+   * @param args - Variable arguments to format and display
+   * @returns Array of formatted strings ready for console output
+   */
+  compile(messageColor, ...args) {
+    const timeString = this.getTime();
+    const scopePadding = " ".repeat(this.scopeLength + 3);
+    const isMultiArg = args.length > 1;
+    return [
+      // Header with separate colors for scope and message content
+      `${A_LOGGER_ANSI.PREFIX}${this.COLORS[this.DEFAULT_SCOPE_COLOR]}${A_LOGGER_ANSI.SUFFIX}${A_LOGGER_FORMAT.SCOPE_OPEN}${this.formattedScope}${A_LOGGER_FORMAT.SCOPE_CLOSE}${A_LOGGER_ANSI.RESET} ${A_LOGGER_ANSI.PREFIX}${this.COLORS[messageColor]}${A_LOGGER_ANSI.SUFFIX}${A_LOGGER_FORMAT.TIME_OPEN}${timeString}${A_LOGGER_FORMAT.TIME_CLOSE}`,
+      // Top separator for multi-argument messages
+      isMultiArg ? `
+${scopePadding}${A_LOGGER_FORMAT.TIME_OPEN}${A_LOGGER_FORMAT.SEPARATOR}` : "",
+      // Process each argument with appropriate formatting
+      ...args.map((arg, i) => {
+        const shouldAddNewline = i > 0 || isMultiArg;
+        switch (true) {
+          case arg instanceof A_Error:
+            return this.compile_A_Error(arg);
+          case arg instanceof Error:
+            return this.compile_Error(arg);
+          case (typeof arg === "object" && arg !== null):
+            return this.formatObject(arg, shouldAddNewline, scopePadding);
+          default:
+            return this.formatString(String(arg), shouldAddNewline, scopePadding);
+        }
+      }),
+      // Bottom separator and color reset
+      isMultiArg ? `
+${scopePadding}${A_LOGGER_FORMAT.TIME_OPEN}${A_LOGGER_FORMAT.SEPARATOR}${A_LOGGER_ANSI.RESET}` : A_LOGGER_ANSI.RESET
+    ];
   }
-};
-__decorateClass([
-  A_Feature.Extend({
-    name: "onError" /* onError */,
-    scope: [PollyspotChannel]
-  }),
-  __decorateParam(0, A_Inject(A_ChannelRequest)),
-  __decorateParam(1, A_Inject(A_Logger)),
-  __decorateParam(2, A_Inject(A_Config))
-], GlobalErrorhandler.prototype, "handleError", 1);
-__decorateClass([
-  A_Feature.Extend({
-    name: "onError" /* onError */
-  }),
-  __decorateParam(0, A_Inject(A_ChannelRequest)),
-  __decorateParam(1, A_Inject(A_Logger)),
-  __decorateParam(2, A_Inject(A_Config))
-], GlobalErrorhandler.prototype, "anotherError", 1);
-
-// src/lib/A-Command/A-Command.constants.ts
-var A_CONSTANTS__A_Command_Status = /* @__PURE__ */ ((A_CONSTANTS__A_Command_Status2) => {
-  A_CONSTANTS__A_Command_Status2["CREATED"] = "CREATED";
-  A_CONSTANTS__A_Command_Status2["INITIALIZATION"] = "INITIALIZATION";
-  A_CONSTANTS__A_Command_Status2["INITIALIZED"] = "INITIALIZED";
-  A_CONSTANTS__A_Command_Status2["COMPILATION"] = "COMPILATION";
-  A_CONSTANTS__A_Command_Status2["COMPILED"] = "COMPILED";
-  A_CONSTANTS__A_Command_Status2["IN_PROGRESS"] = "IN_PROGRESS";
-  A_CONSTANTS__A_Command_Status2["COMPLETED"] = "COMPLETED";
-  A_CONSTANTS__A_Command_Status2["FAILED"] = "FAILED";
-  return A_CONSTANTS__A_Command_Status2;
-})(A_CONSTANTS__A_Command_Status || {});
-var A_CommandFeatures = /* @__PURE__ */ ((A_CommandFeatures2) => {
-  A_CommandFeatures2["onInit"] = "onInit";
-  A_CommandFeatures2["onCompile"] = "onCompile";
-  A_CommandFeatures2["onExecute"] = "onExecute";
-  A_CommandFeatures2["onComplete"] = "onComplete";
-  A_CommandFeatures2["onFail"] = "onFail";
-  return A_CommandFeatures2;
-})(A_CommandFeatures || {});
-var A_Memory = class extends A_Fragment {
   /**
-   * Memory object that allows to store intermediate values and errors
+   * Format an object for display with proper JSON indentation
    * 
-   * @param initialValues 
+   * @param obj - The object to format
+   * @param shouldAddNewline - Whether to add a newline prefix
+   * @param scopePadding - The padding string for consistent alignment
+   * @returns Formatted object string
    */
-  constructor(initialValues) {
-    super();
-    this._memory = new Map(Object.entries(initialValues || {}));
-    this._errors = /* @__PURE__ */ new Set();
+  formatObject(obj, shouldAddNewline, scopePadding) {
+    let jsonString;
+    try {
+      jsonString = JSON.stringify(obj, null, 2);
+    } catch (error) {
+      const seen = /* @__PURE__ */ new WeakSet();
+      jsonString = JSON.stringify(obj, (key, value) => {
+        if (typeof value === "object" && value !== null) {
+          if (seen.has(value)) {
+            return "[Circular Reference]";
+          }
+          seen.add(value);
+        }
+        return value;
+      }, 2);
+    }
+    const formatted = jsonString.replace(/\n/g, `
+${scopePadding}${A_LOGGER_FORMAT.PIPE}`);
+    return shouldAddNewline ? `
+${scopePadding}${A_LOGGER_FORMAT.PIPE}` + formatted : formatted;
   }
-  get Errors() {
-    return this._errors.size > 0 ? this._errors : void 0;
+  /**
+   * Format a string for display with proper indentation
+   * 
+   * @param str - The string to format
+   * @param shouldAddNewline - Whether to add a newline prefix
+   * @param scopePadding - The padding string for consistent alignment
+   * @returns Formatted string
+   */
+  formatString(str, shouldAddNewline, scopePadding) {
+    const prefix = shouldAddNewline ? "\n" : "";
+    return (prefix + str).replace(/\n/g, `
+${scopePadding}${A_LOGGER_FORMAT.PIPE}`);
   }
+  // =============================================
+  // Log Level Management
+  // =============================================
   /**
-   * Verifies that all required keys are present in the proxy values
+   * Determine if a log message should be output based on configured log level
    * 
-   * @param requiredKeys 
-   * @returns 
+   * Log level hierarchy:
+   * - debug: Shows all messages (debug, info, warning, error)
+   * - info: Shows info, warning, and error messages
+   * - warn: Shows warning and error messages only
+   * - error: Shows error messages only
+   * - all: Shows all messages (alias for debug)
+   * 
+   * @param logMethod - The type of log method being called
+   * @returns True if the message should be logged, false otherwise
    */
-  async prerequisites(requiredKeys) {
-    return requiredKeys.every((key) => this._memory.has(key));
+  shouldLog(logMethod) {
+    const shouldLog = this.config?.get(A_LOGGER_ENV_KEYS.LOG_LEVEL) || "info";
+    switch (shouldLog) {
+      case "debug":
+        return true;
+      case "info":
+        return logMethod === "info" || logMethod === "warning" || logMethod === "error";
+      case "warn":
+        return logMethod === "warning" || logMethod === "error";
+      case "error":
+        return logMethod === "error";
+      case "all":
+        return true;
+      default:
+        return false;
+    }
+  }
+  debug(param1, ...args) {
+    if (!this.shouldLog("debug")) return;
+    if (typeof param1 === "string" && this.COLORS[param1]) {
+      console.log(...this.compile(param1, ...args));
+    } else {
+      console.log(...this.compile(this.DEFAULT_LOG_COLOR, param1, ...args));
+    }
+  }
+  info(param1, ...args) {
+    if (!this.shouldLog("info")) return;
+    if (typeof param1 === "string" && this.COLORS[param1]) {
+      console.log(...this.compile(param1, ...args));
+    } else {
+      console.log(...this.compile(this.DEFAULT_LOG_COLOR, param1, ...args));
+    }
+  }
+  log(param1, ...args) {
+    this.info(param1, ...args);
   }
   /**
-   * Adds an error to the context
+   * Log warning messages with yellow color coding
+   * 
+   * Use for non-critical issues that should be brought to attention
+   * but don't prevent normal operation
+   * 
+   * @param args - Arguments to log as warnings
    * 
-   * @param error 
+   * @example
+   * ```typescript
+   * logger.warning('Deprecated method used');
+   * logger.warning('Rate limit approaching:', { current: 95, limit: 100 });
+   * ```
    */
-  async error(error) {
-    this._errors.add(error);
+  warning(...args) {
+    if (!this.shouldLog("warning")) return;
+    console.log(...this.compile("yellow", ...args));
   }
   /**
-   * Retrieves a value from the context memory
+   * Log error messages with red color coding
    * 
-   * @param key 
-   * @returns 
+   * Use for critical issues, exceptions, and failures that need immediate attention
+   * 
+   * @param args - Arguments to log as errors
+   * @returns void (for compatibility with console.log)
+   * 
+   * @example
+   * ```typescript
+   * logger.error('Database connection failed');
+   * logger.error(new Error('Validation failed'));
+   * logger.error('Critical error:', error, { context: 'user-registration' });
+   * ```
    */
-  get(key) {
-    return this._memory.get(key);
+  error(...args) {
+    if (!this.shouldLog("error")) return;
+    console.log(...this.compile("red", ...args));
   }
+  // =============================================
+  // Specialized Error Formatting
+  // =============================================
   /**
-   * Saves a value in the context memory
+   * Legacy method for A_Error logging (kept for backward compatibility)
    * 
-   * @param key 
-   * @param value 
+   * @deprecated Use error() method instead which handles A_Error automatically
+   * @param error - The A_Error instance to log
    */
-  async set(key, value) {
-    this._memory.set(key, value);
+  log_A_Error(error) {
+    const time = this.getTime();
+    const scopePadding = " ".repeat(this.scopeLength + 3);
+    console.log(`\x1B[31m[${this.formattedScope}] |${time}| ERROR ${error.code}
+${scopePadding}| ${error.message}
+${scopePadding}| ${error.description} 
+${scopePadding}|-------------------------------
+${scopePadding}| ${error.stack?.split("\n").map((line, index) => index === 0 ? line : `${scopePadding}| ${line}`).join("\n") || "No stack trace"}
+${scopePadding}|-------------------------------
+\x1B[0m` + (error.originalError ? `\x1B[31m${scopePadding}| Wrapped From  ${error.originalError.message}
+${scopePadding}|-------------------------------
+${scopePadding}| ${error.originalError.stack?.split("\n").map((line, index) => index === 0 ? line : `${scopePadding}| ${line}`).join("\n") || "No stack trace"}
+${scopePadding}|-------------------------------
+\x1B[0m` : "") + (error.link ? `\x1B[31m${scopePadding}| Read in docs: ${error.link}
+${scopePadding}|-------------------------------
+\x1B[0m` : ""));
   }
   /**
-   * Removes a value from the context memory by key
+   * Format A_Error instances for inline display within compiled messages
    * 
-   * @param key 
+   * Provides detailed formatting for A_Error objects including:
+   * - Error code and message
+   * - Description and stack trace
+   * - Original error information (if wrapped)
+   * - Documentation links (if available)
+   * 
+   * @param error - The A_Error instance to format
+   * @returns Formatted string ready for display
    */
-  async drop(key) {
-    this._memory.delete(key);
+  compile_A_Error(error) {
+    const scopePadding = " ".repeat(this.scopeLength + 3);
+    return `
+${scopePadding}|-------------------------------
+${scopePadding}|  Error:  | ${error.code}
+${scopePadding}|-------------------------------
+${scopePadding}|${" ".repeat(10)}| ${error.message}
+${scopePadding}|${" ".repeat(10)}| ${error.description} 
+${scopePadding}|-------------------------------
+${scopePadding}| ${error.stack?.split("\n").map((line, index) => index === 0 ? line : `${scopePadding}| ${line}`).join("\n") || "No stack trace"}
+${scopePadding}|-------------------------------` + (error.originalError ? `${scopePadding}| Wrapped From  ${error.originalError.message}
+${scopePadding}|-------------------------------
+${scopePadding}| ${error.originalError.stack?.split("\n").map((line, index) => index === 0 ? line : `${scopePadding}| ${line}`).join("\n") || "No stack trace"}
+${scopePadding}|-------------------------------` : "") + (error.link ? `${scopePadding}| Read in docs: ${error.link}
+${scopePadding}|-------------------------------` : "");
   }
   /**
-   * Clears all stored values in the context memory
+   * Format standard Error instances for inline display within compiled messages
+   * 
+   * Converts standard JavaScript Error objects into a readable JSON format
+   * with proper indentation and stack trace formatting
+   * 
+   * @param error - The Error instance to format
+   * @returns Formatted string ready for display
    */
-  async clear() {
-    this._memory.clear();
+  compile_Error(error) {
+    const scopePadding = " ".repeat(this.scopeLength + 3);
+    return JSON.stringify({
+      name: error.name,
+      message: error.message,
+      stack: error.stack?.split("\n").map((line, index) => index === 0 ? line : `${scopePadding}| ${line}`).join("\n")
+    }, null, 2).replace(/\n/g, `
+${scopePadding}| `).replace(/\\n/g, "\n");
   }
+  // =============================================
+  // Utility Methods
+  // =============================================
   /**
-   * Converts all stored values to a plain object
+   * Generate timestamp string for log messages
+   * 
+   * Format: MM:SS:mmm (minutes:seconds:milliseconds)
+   * This provides sufficient precision for debugging while remaining readable
    * 
-   * [!] By default uses all saved in memory values 
+   * @returns Formatted timestamp string
    * 
-   * @returns 
+   * @example
+   * Returns: "15:42:137" for 3:42:15 PM and 137 milliseconds
    */
-  toJSON() {
-    const obj = {};
-    this._memory.forEach((value, key) => {
-      obj[key] = typeof value === "object" && value !== null && "toJSON" in value && typeof value.toJSON === "function" ? value.toJSON() : value;
-    });
-    return obj;
+  getTime() {
+    const now = /* @__PURE__ */ new Date();
+    const minutes = String(now.getMinutes()).padStart(A_LOGGER_TIME_FORMAT.MINUTES_PAD, "0");
+    const seconds = String(now.getSeconds()).padStart(A_LOGGER_TIME_FORMAT.SECONDS_PAD, "0");
+    const milliseconds = String(now.getMilliseconds()).padStart(A_LOGGER_TIME_FORMAT.MILLISECONDS_PAD, "0");
+    return `${minutes}${A_LOGGER_TIME_FORMAT.SEPARATOR}${seconds}${A_LOGGER_TIME_FORMAT.SEPARATOR}${milliseconds}`;
   }
 };
-var A_CommandError = class extends A_Error {
-};
-A_CommandError.CommandScopeBindingError = "A-Command Scope Binding Error";
+A_Logger = __decorateClass([
+  __decorateParam(0, A_Inject(A_Scope)),
+  __decorateParam(1, A_Inject(A_Config))
+], A_Logger);
 
 // src/lib/A-Command/A-Command.entity.ts
+var _a2, _b2, _c2, _d2, _e, _f, _g, _h, _i, _j, _k;
 var A_Command = class extends A_Entity {
   /**
    * 
@@ -956,159 +1143,292 @@ var A_Command = class extends A_Entity {
    */
   constructor(params) {
     super(params);
+    /** Map of event listeners organized by event name */
     this._listeners = /* @__PURE__ */ new Map();
   }
   // ====================================================================
-  // ================== Static A-Command Information ====================
+  // ================== Static Command Information ======================
   // ====================================================================
   /**
-   * Command Identifier that corresponds to the class name
+   * Static command identifier derived from the class name
+   * Used for command registration and serialization
    */
   static get code() {
     return super.entity;
   }
+  // ====================================================================
+  // ================== Public Getter Properties =======================
+  // ====================================================================
   /**
-   * Execution Duration in milliseconds
+   * Total execution duration in milliseconds
+   * 
+   * - If completed/failed: Returns total time from start to end
+   * - If currently executing: Returns elapsed time since start
+   * - If not started: Returns undefined
    */
   get duration() {
     return this._endTime && this._startTime ? this._endTime.getTime() - this._startTime.getTime() : this._startTime ? (/* @__PURE__ */ new Date()).getTime() - this._startTime.getTime() : void 0;
   }
   /**
-   * A shared scope between all features of the command during its execution
+   * Idle time before execution started in milliseconds
+   * 
+   * Time between command creation and execution start.
+   * Useful for monitoring command queue performance.
+   */
+  get idleTime() {
+    return this._startTime && this._createdAt ? this._startTime.getTime() - this._createdAt.getTime() : void 0;
+  }
+  /**
+   * Command execution scope for dependency injection
+   * 
+   * Provides access to components, services, and shared resources
+   * during command execution. Inherits from the scope where the
+   * command was registered.
    */
   get scope() {
     return this._executionScope;
   }
   /**
-   * Unique code identifying the command type
-   * Example: 'user.create', 'task.complete', etc.
+   * Unique command type identifier
    * 
+   * Derived from the class name and used for:
+   * - Command registration and resolution
+   * - Serialization and deserialization
+   * - Logging and debugging
+   * 
+   * @example 'create-user-command', 'process-order-command'
    */
   get code() {
     return this.constructor.code;
   }
   /**
-   * Current status of the command
+   * Current lifecycle status of the command
+   * 
+   * Indicates the current phase in the command execution lifecycle.
+   * Used to track progress and determine available operations.
    */
   get status() {
     return this._status;
   }
   /**
-   * Start time of the command execution
+   * Timestamp when the command was created
+   * 
+   * Marks the initial instantiation time, useful for tracking
+   * command age and queue performance metrics.
+   */
+  get createdAt() {
+    return this._createdAt;
+  }
+  /**
+   * Timestamp when command execution started
+   * 
+   * Undefined until execution begins. Used for calculating
+   * execution duration and idle time.
    */
   get startedAt() {
     return this._startTime;
   }
   /**
-   * End time of the command execution
+   * Timestamp when command execution ended
+   * 
+   * Set when command reaches COMPLETED or FAILED status.
+   * Used for calculating total execution duration.
    */
   get endedAt() {
     return this._endTime;
   }
   /**
-   * Result of the command execution stored in the context
+   * Result data produced by command execution
+   * 
+   * Contains the output data from successful command execution.
+   * Undefined until command completes successfully.
    */
   get result() {
     return this._result;
   }
   /**
-   * Errors encountered during the command execution stored in the context
+   * Array of errors that occurred during execution
+   * 
+   * Automatically wraps native errors in A_Error instances
+   * for consistent error handling. Empty array if no errors occurred.
    */
-  get errors() {
-    return this._errors;
+  get error() {
+    return this._error;
   }
   /**
-   * Parameters used to invoke the command
-   */
+       * Command initialization parameters
+       * 
+       * Contains the input data used to create and configure the command.
+       * These parameters are immutable during command execution.
+                      return new A_Error(err);
+                  }
+              });
+      }
+  
+      /**
+       * Command initialization parameters
+       * 
+       * Contains the input data used to create and configure the command.
+       * These parameters are immutable during command execution.
+       */
   get params() {
     return this._params;
   }
   /**
-   * Indicates if the command has failed
+   * Indicates if the command has been processed (completed or failed)
+   * 
+   * Returns true if the command has completed or failed, false otherwise.
    */
-  get isFailed() {
-    return this._status === "FAILED" /* FAILED */;
+  get isProcessed() {
+    return this._status === "COMPLETED" /* COMPLETED */ || this._status === "FAILED" /* FAILED */;
   }
-  /**
-   * Indicates if the command has completed successfully
-   */
-  get isCompleted() {
-    return this._status === "COMPLETED" /* COMPLETED */;
+  async [_k = "onBeforeTransition" /* onBeforeTransition */](transition, logger, ...args) {
+    this.checkScopeInheritance();
+    logger?.debug("yellow", `Command ${this.aseid.toString()} transitioning from ${transition.from} to ${transition.to}`);
   }
-  // --------------------------------------------------------------------------
-  // A-Command Lifecycle Methods
-  // --------------------------------------------------------------------------
-  // should create a new Task in DB  with basic records
-  async init() {
+  async [_j = "created_initialized" /* CREATED_TO_INITIALIZED */](transition, ...args) {
     if (this._status !== "CREATED" /* CREATED */) {
       return;
     }
-    this._status = "INITIALIZATION" /* INITIALIZATION */;
-    this._startTime = /* @__PURE__ */ new Date();
-    this.emit("onInit" /* onInit */);
-    await this.call("onInit" /* onInit */, this.scope);
+    this._createdAt = /* @__PURE__ */ new Date();
     this._status = "INITIALIZED" /* INITIALIZED */;
+    this.emit("onInit" /* onInit */);
   }
-  // Should compile everything before execution
-  async compile() {
-    if (this._status !== "INITIALIZED" /* INITIALIZED */) {
+  async [_i = "initialized_executing" /* INITIALIZED_TO_EXECUTING */](transition, ...args) {
+    if (this._status !== "INITIALIZED" /* INITIALIZED */ && this._status !== "CREATED" /* CREATED */) {
       return;
     }
-    this.checkScopeInheritance();
-    this._status = "COMPILATION" /* COMPILATION */;
-    this.emit("onCompile" /* onCompile */);
-    await this.call("onCompile" /* onCompile */, this.scope);
-    this._status = "COMPILED" /* COMPILED */;
+    this._startTime = /* @__PURE__ */ new Date();
+    this._status = "EXECUTING" /* EXECUTING */;
+    this.emit("onExecute" /* onExecute */);
   }
   /**
-   * Processes the command execution
+   * Handles command completion after successful execution
    * 
-   * @returns 
+   * EXECUTION -> COMPLETED transition
    */
-  async process() {
-    if (this._status !== "COMPILED" /* COMPILED */)
-      return;
-    this._status = "IN_PROGRESS" /* IN_PROGRESS */;
-    this.checkScopeInheritance();
-    this.emit("onExecute" /* onExecute */);
-    await this.call("onExecute" /* onExecute */, this.scope);
+  async [_h = "executing_completed" /* EXECUTING_TO_COMPLETED */](transition, ...args) {
+    this._endTime = /* @__PURE__ */ new Date();
+    this._status = "COMPLETED" /* COMPLETED */;
+    this.emit("onComplete" /* onComplete */);
+  }
+  /**
+   * Handles command failure during execution
+   * 
+   * EXECUTION -> FAILED transition
+   */
+  async [_g = "executing_failed" /* EXECUTING_TO_FAILED */](transition, error, ...args) {
+    this._endTime = /* @__PURE__ */ new Date();
+    this._status = "FAILED" /* FAILED */;
+    this.emit("onFail" /* onFail */);
+  }
+  /**
+   * Default behavior for Command Initialization uses StateMachine to transition states
+   */
+  async [_f = "onInit" /* onInit */](stateMachine, ...args) {
+    await stateMachine.transition("CREATED" /* CREATED */, "INITIALIZED" /* INITIALIZED */);
+  }
+  async [_e = "onBeforeExecute" /* onBeforeExecute */](stateMachine, ...args) {
+    await stateMachine.transition("INITIALIZED" /* INITIALIZED */, "EXECUTING" /* EXECUTING */);
+  }
+  async [_d2 = "onExecute" /* onExecute */](...args) {
+  }
+  /**
+   * By Default on AfterExecute calls the Completion method to mark the command as completed
+   * 
+   * [!] This can be overridden to implement custom behavior using A_Feature overrides
+   */
+  async [_c2 = "onAfterExecute" /* onAfterExecute */](...args) {
+  }
+  async [_b2 = "onComplete" /* onComplete */](stateMachine, ...args) {
+    await stateMachine.transition("EXECUTING" /* EXECUTING */, "COMPLETED" /* COMPLETED */);
+  }
+  async [_a2 = "onFail" /* onFail */](stateMachine, operation, ...args) {
+    await stateMachine.transition("EXECUTING" /* EXECUTING */, "FAILED" /* FAILED */);
+  }
+  // --------------------------------------------------------------------------
+  // A-Command Lifecycle Methods
+  // --------------------------------------------------------------------------
+  /**
+   * Initializes the command before execution.
+   */
+  async init() {
+    await this.call("onInit" /* onInit */, this.scope);
   }
   /**
    * Executes the command logic.
    */
   async execute() {
-    this.checkScopeInheritance();
+    if (this.isProcessed) return;
     try {
-      await this.init();
-      await this.compile();
-      await this.process();
-      await this.complete();
+      this.checkScopeInheritance();
+      const context = new A_OperationContext("execute-command");
+      this.scope.register(context);
+      await new Promise(async (resolve, reject) => {
+        try {
+          const onBeforeExecuteFeature = new A_Feature({
+            name: "onBeforeExecute" /* onBeforeExecute */,
+            component: this,
+            scope: this.scope
+          });
+          const onExecuteFeature = new A_Feature({
+            name: "onExecute" /* onExecute */,
+            component: this,
+            scope: this.scope
+          });
+          const onAfterExecuteFeature = new A_Feature({
+            name: "onAfterExecute" /* onAfterExecute */,
+            component: this,
+            scope: this.scope
+          });
+          this.on("onComplete" /* onComplete */, () => {
+            onBeforeExecuteFeature.interrupt();
+            onExecuteFeature.interrupt();
+            onAfterExecuteFeature.interrupt();
+            resolve();
+          });
+          await onBeforeExecuteFeature.process(this.scope);
+          await onExecuteFeature.process(this.scope);
+          await onAfterExecuteFeature.process(this.scope);
+          if (this._origin === "invoked") {
+            await this.complete();
+          }
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
     } catch (error) {
-      await this.fail();
+      let targetError = error instanceof A_Error ? error : new A_CommandError({
+        title: A_CommandError.ExecutionError,
+        description: `An error occurred while executing command "${this.aseid.toString()}".`,
+        originalError: error
+      });
+      await this.fail(targetError);
     }
-    this._executionScope.destroy();
   }
   /**
    * Marks the command as completed
    */
-  async complete() {
-    this.checkScopeInheritance();
+  async complete(result) {
+    if (this.isProcessed) return;
     this._status = "COMPLETED" /* COMPLETED */;
-    this._endTime = /* @__PURE__ */ new Date();
-    this._result = this.scope.resolve(A_Memory).toJSON();
-    this.emit("onComplete" /* onComplete */);
+    this._result = result;
     await this.call("onComplete" /* onComplete */, this.scope);
+    this.scope.destroy();
   }
   /**
    * Marks the command as failed
    */
-  async fail() {
-    this.checkScopeInheritance();
+  async fail(error) {
+    if (this.isProcessed) return;
     this._status = "FAILED" /* FAILED */;
-    this._endTime = /* @__PURE__ */ new Date();
-    this._errors = this.scope.resolve(A_Memory).Errors;
-    this.emit("onFail" /* onFail */);
+    if (error) {
+      this._error = error;
+      this.scope.register(error);
+    }
     await this.call("onFail" /* onFail */, this.scope);
+    this.scope.destroy();
   }
   // --------------------------------------------------------------------------   
   // A-Command Event-Emitter methods
@@ -1140,7 +1460,7 @@ var A_Command = class extends A_Entity {
    * @param event 
    */
   emit(event) {
-    this._listeners.get(event)?.forEach((listener) => {
+    this._listeners.get(event)?.forEach(async (listener) => {
       listener(this);
     });
   }
@@ -1156,8 +1476,12 @@ var A_Command = class extends A_Entity {
    */
   fromNew(newEntity) {
     super.fromNew(newEntity);
-    this._executionScope = new A_Scope();
-    this._executionScope.register(new A_Memory());
+    this._origin = "invoked";
+    this._executionScope = new A_Scope({
+      name: `A-Command-Execution-Scope-${this.aseid.toString()}`,
+      components: [A_StateMachine]
+    });
+    this._createdAt = /* @__PURE__ */ new Date();
     this._params = newEntity;
     this._status = "CREATED" /* CREATED */;
   }
@@ -1170,23 +1494,20 @@ var A_Command = class extends A_Entity {
    */
   fromJSON(serialized) {
     super.fromJSON(serialized);
-    this._executionScope = new A_Scope();
-    const memory = new A_Memory();
-    this._executionScope.register(memory);
+    this._origin = "serialized";
+    this._executionScope = new A_Scope({
+      name: `A-Command-Execution-Scope-${this.aseid.toString()}`,
+      components: [A_StateMachine]
+    });
+    if (serialized.createdAt) this._createdAt = new Date(serialized.createdAt);
     if (serialized.startedAt) this._startTime = new Date(serialized.startedAt);
     if (serialized.endedAt) this._endTime = new Date(serialized.endedAt);
-    if (serialized.result) {
-      Object.entries(serialized.result).forEach(([key, value]) => {
-        memory.set(key, value);
-      });
-    }
-    if (serialized.errors) {
-      serialized.errors.forEach((err) => {
-        memory.error(new A_Error(err));
-      });
-    }
     this._params = serialized.params;
-    this._status = serialized.status || "CREATED" /* CREATED */;
+    this._status = serialized.status;
+    if (serialized.error)
+      this._error = new A_CommandError(serialized.error);
+    if (serialized.result)
+      this._result = serialized.result;
   }
   /**
    * Converts the Command instance to a plain object
@@ -1199,13 +1520,23 @@ var A_Command = class extends A_Entity {
       code: this.code,
       status: this._status,
       params: this._params,
+      createdAt: this._createdAt.toISOString(),
       startedAt: this._startTime ? this._startTime.toISOString() : void 0,
       endedAt: this._endTime ? this._endTime.toISOString() : void 0,
       duration: this.duration,
+      idleTime: this.idleTime,
       result: this.result,
-      errors: this.errors ? Array.from(this.errors).map((err) => err.toJSON()) : void 0
+      error: this.error ? this.error.toJSON() : void 0
     };
   }
+  //============================================================================================
+  //                                Helpers Methods
+  //============================================================================================
+  /**
+   * Ensures that the command's execution scope inherits from the context scope
+   * 
+   * Throws an error if the command is not bound to any context scope
+   */
   checkScopeInheritance() {
     let attachedScope;
     try {
@@ -1213,7 +1544,7 @@ var A_Command = class extends A_Entity {
     } catch (error) {
       throw new A_CommandError({
         title: A_CommandError.CommandScopeBindingError,
-        description: `Command ${this.code} is not bound to any context scope. Ensure the command is properly registered within a context before execution.`,
+        description: `Command ${this.aseid.toString()} is not bound to any context scope. Ensure the command is properly registered within a context before execution.`,
         originalError: error
       });
     }
@@ -1222,6 +1553,59 @@ var A_Command = class extends A_Entity {
     }
   }
 };
+__decorateClass([
+  A_Feature.Extend(),
+  __decorateParam(0, A_Inject(A_StateMachineTransition)),
+  __decorateParam(1, A_Inject(A_Logger))
+], A_Command.prototype, _k, 1);
+__decorateClass([
+  A_Feature.Extend(),
+  __decorateParam(0, A_Inject(A_StateMachineTransition))
+], A_Command.prototype, _j, 1);
+__decorateClass([
+  A_Feature.Extend(),
+  __decorateParam(0, A_Inject(A_StateMachineTransition))
+], A_Command.prototype, _i, 1);
+__decorateClass([
+  A_Feature.Extend(),
+  __decorateParam(0, A_Inject(A_StateMachineTransition))
+], A_Command.prototype, _h, 1);
+__decorateClass([
+  A_Feature.Extend(),
+  __decorateParam(0, A_Inject(A_StateMachineTransition)),
+  __decorateParam(1, A_Inject(A_Error))
+], A_Command.prototype, _g, 1);
+__decorateClass([
+  A_Feature.Extend(),
+  __decorateParam(0, A_Inject(A_StateMachine))
+], A_Command.prototype, _f, 1);
+__decorateClass([
+  A_Feature.Extend({
+    after: /.*/
+  }),
+  __decorateParam(0, A_Dependency.Required()),
+  __decorateParam(0, A_Inject(A_StateMachine))
+], A_Command.prototype, _e, 1);
+__decorateClass([
+  A_Feature.Extend()
+], A_Command.prototype, _d2, 1);
+__decorateClass([
+  A_Feature.Extend()
+], A_Command.prototype, _c2, 1);
+__decorateClass([
+  A_Feature.Extend({
+    after: /.*/
+  }),
+  __decorateParam(0, A_Inject(A_StateMachine))
+], A_Command.prototype, _b2, 1);
+__decorateClass([
+  A_Feature.Extend({
+    after: /.*/
+  }),
+  __decorateParam(0, A_Dependency.Required()),
+  __decorateParam(0, A_Inject(A_StateMachine)),
+  __decorateParam(1, A_Inject(A_OperationContext))
+], A_Command.prototype, _a2, 1);
 var A_FSPolyfillClass = class {
   constructor(logger) {
     this.logger = logger;
@@ -2282,6 +2666,334 @@ var A_Manifest = class extends A_Fragment {
     return new A_ManifestChecker(this, componentCtor, method, true);
   }
 };
+var A_MemoryContext = class extends A_Fragment {
+  set(param, value) {
+    super.set(param, value);
+  }
+  get(param) {
+    return super.get(param);
+  }
+};
+var A_MemoryError = class extends A_Error {
+};
+A_MemoryError.MemoryInitializationError = "Memory initialization error";
+A_MemoryError.MemoryDestructionError = "Memory destruction error";
+A_MemoryError.MemoryGetError = "Memory GET operation failed";
+A_MemoryError.MemorySetError = "Memory SET operation failed";
+A_MemoryError.MemoryDropError = "Memory DROP operation failed";
+A_MemoryError.MemoryClearError = "Memory CLEAR operation failed";
+A_MemoryError.MemoryHasError = "Memory HAS operation failed";
+A_MemoryError.MemorySerializeError = "Memory toJSON operation failed";
+
+// src/lib/A-Memory/A-Memory.component.ts
+var _a3, _b3, _c3, _d3, _e2, _f2, _g2, _h2, _i2;
+var A_Memory = class extends A_Component {
+  get ready() {
+    if (!this._ready) {
+      this._ready = this.init();
+    }
+    return this._ready;
+  }
+  /**
+   * Handles errors during memory operations
+   */
+  async [_i2 = "onError" /* onError */](...args) {
+  }
+  /**
+   * Handles memory expiration
+   */
+  async [_h2 = "onExpire" /* onExpire */](...args) {
+  }
+  /**
+   * Initializes the memory context
+   */
+  async [_g2 = "onInit" /* onInit */](context, ...args) {
+    if (!context) {
+      context = new A_MemoryContext();
+      A_Context.scope(this).register(context);
+    }
+  }
+  async [_f2 = "onDestroy" /* onDestroy */](context, ...args) {
+    context.clear();
+  }
+  /**
+   * Handles the 'get' operation for retrieving a value from memory
+   */
+  async [_e2 = "onGet" /* onGet */](operation, context, ...args) {
+    operation.succeed(context.get(operation.params.key));
+  }
+  /**
+   * Handles the 'has' operation for checking existence of a key in memory
+   */
+  async [_d3 = "onHas" /* onHas */](operation, context, ...args) {
+    operation.succeed(context.has(operation.params.key));
+  }
+  /**
+   * Handles the 'set' operation for saving a value in memory
+   */
+  async [_c3 = "onSet" /* onSet */](operation, context, ...args) {
+    context.set(operation.params.key, operation.params.value);
+  }
+  /**
+   * Handles the 'drop' operation for removing a value from memory
+   */
+  async [_b3 = "onDrop" /* onDrop */](operation, context, ...args) {
+    context.drop(operation.params.key);
+  }
+  /**
+   * Handles the 'clear' operation for clearing all values from memory
+   */
+  async [_a3 = "onClear" /* onClear */](operation, context, ...args) {
+    context.clear();
+  }
+  // ======================================================================
+  // =========================A-Memory Methods=============================
+  // ======================================================================
+  /**
+   * Initializes the memory context
+   */
+  async init() {
+    if (this._ready)
+      return this._ready;
+    const scope = new A_Scope({ name: "A-Memory-Init-Scope" }).inherit(A_Context.scope(this));
+    try {
+      await this.call("onInit" /* onInit */, scope);
+    } catch (error) {
+      const initError = new A_MemoryError({
+        title: A_MemoryError.MemoryInitializationError,
+        description: "An error occurred during memory initialization",
+        originalError: error
+      });
+      scope.register(initError);
+      await this.call("onError" /* onError */, scope);
+      scope.destroy();
+      throw initError;
+    }
+  }
+  /**
+   * Destroys the memory context
+   *
+   * This method is responsible for cleaning up any resources
+   * used by the memory context and resetting its state.
+   */
+  async destroy() {
+    const scope = new A_Scope({ name: "A-Memory-Destroy-Scope" }).inherit(A_Context.scope(this));
+    try {
+      this._ready = void 0;
+      await this.call("onDestroy" /* onDestroy */, scope);
+    } catch (error) {
+      const destroyError = new A_MemoryError({
+        title: A_MemoryError.MemoryDestructionError,
+        description: "An error occurred during memory destruction",
+        originalError: error
+      });
+      scope.register(destroyError);
+      await this.call("onError" /* onError */, scope);
+      scope.destroy();
+      throw destroyError;
+    }
+  }
+  /**
+    * Retrieves a value from the context memory
+    * 
+    * @param key - memory key to retrieve
+    * @returns - value associated with the key or undefined if not found
+    */
+  async get(key) {
+    const operation = new A_OperationContext("get", { key });
+    const scope = new A_Scope({
+      name: "A-Memory-Get-Operation-Scope",
+      fragments: [operation]
+    });
+    try {
+      await this.call("onGet" /* onGet */, scope);
+      scope.destroy();
+      return operation.result;
+    } catch (error) {
+      const getError = new A_MemoryError({
+        title: A_MemoryError.MemoryGetError,
+        description: `An error occurred while getting the value for key "${String(key)}"`,
+        originalError: error
+      });
+      scope.register(getError);
+      await this.call("onError" /* onError */, scope);
+      scope.destroy();
+      throw getError;
+    }
+  }
+  /**
+   * Checks if a value exists in the context memory
+   * 
+   * @param key - memory key to check
+   * @returns - true if key exists, false otherwise
+   */
+  async has(key) {
+    const operation = new A_OperationContext("has", { key });
+    const scope = new A_Scope({
+      name: "A-Memory-Has-Operation-Scope",
+      fragments: [operation]
+    });
+    try {
+      await this.call("onHas" /* onHas */, scope);
+      scope.destroy();
+      return operation.result;
+    } catch (error) {
+      const getError = new A_MemoryError({
+        title: A_MemoryError.MemoryHasError,
+        description: `An error occurred while checking existence for key "${String(key)}"`,
+        originalError: error
+      });
+      scope.register(getError);
+      await this.call("onError" /* onError */, scope);
+      scope.destroy();
+      throw getError;
+    }
+  }
+  /**
+   * Saves a value in the context memory
+   * 
+   * @param key 
+   * @param value 
+   */
+  async set(key, value) {
+    const operation = new A_OperationContext("set", { key, value });
+    const scope = new A_Scope({
+      name: "A-Memory-Set-Operation-Scope",
+      fragments: [operation]
+    });
+    try {
+      await this.call("onSet" /* onSet */, scope);
+    } catch (error) {
+      const setError = new A_MemoryError({
+        title: A_MemoryError.MemorySetError,
+        description: `An error occurred while setting the value for key "${String(key)}"`,
+        originalError: error
+      });
+      scope.register(setError);
+      await this.call("onError" /* onError */, scope);
+      scope.destroy();
+      throw setError;
+    }
+  }
+  /**
+   * Removes a value from the context memory by key
+   * 
+   * @param key 
+   */
+  async drop(key) {
+    const operation = new A_OperationContext("drop", { key });
+    const scope = new A_Scope({
+      name: "A-Memory-Drop-Operation-Scope",
+      fragments: [operation]
+    });
+    try {
+      await this.call("onDrop" /* onDrop */, scope);
+    } catch (error) {
+      const dropError = new A_MemoryError({
+        title: A_MemoryError.MemoryDropError,
+        description: `An error occurred while dropping the value for key "${String(key)}"`,
+        originalError: error
+      });
+      scope.register(dropError);
+      await this.call("onError" /* onError */, scope);
+      scope.destroy();
+      throw dropError;
+    }
+  }
+  /**
+   * Clears all stored values in the context memory
+   */
+  async clear() {
+    const operation = new A_OperationContext("clear");
+    const scope = new A_Scope({
+      name: "A-Memory-Clear-Operation-Scope",
+      fragments: [operation]
+    });
+    try {
+      await this.call("onClear" /* onClear */, scope);
+    } catch (error) {
+      const clearError = new A_MemoryError({
+        title: A_MemoryError.MemoryClearError,
+        description: `An error occurred while clearing the memory`,
+        originalError: error
+      });
+      scope.register(clearError);
+      await this.call("onError" /* onError */, scope);
+      scope.destroy();
+      throw clearError;
+    }
+  }
+  /**
+   * Serializes the memory context to a JSON object
+   *  
+   * @returns - serialized memory object 
+   */
+  async toJSON() {
+    const operation = new A_OperationContext("serialize");
+    const scope = new A_Scope({
+      name: "A-Memory-Serialize-Operation-Scope",
+      fragments: [operation]
+    });
+    try {
+      await this.call("onSerialize" /* onSerialize */, scope);
+      return operation.result;
+    } catch (error) {
+      const serializeError = new A_MemoryError({
+        title: A_MemoryError.MemorySerializeError,
+        description: `An error occurred while serializing the memory`,
+        originalError: error
+      });
+      scope.register(serializeError);
+      await this.call("onError" /* onError */, scope);
+      scope.destroy();
+      throw serializeError;
+    }
+  }
+};
+__decorateClass([
+  A_Feature.Extend()
+], A_Memory.prototype, _i2, 1);
+__decorateClass([
+  A_Feature.Extend()
+], A_Memory.prototype, _h2, 1);
+__decorateClass([
+  A_Feature.Extend(),
+  __decorateParam(0, A_Inject(A_MemoryContext))
+], A_Memory.prototype, _g2, 1);
+__decorateClass([
+  A_Feature.Extend(),
+  __decorateParam(0, A_Inject(A_MemoryContext))
+], A_Memory.prototype, _f2, 1);
+__decorateClass([
+  A_Feature.Extend(),
+  __decorateParam(0, A_Dependency.Required()),
+  __decorateParam(0, A_Inject(A_OperationContext)),
+  __decorateParam(1, A_Inject(A_MemoryContext))
+], A_Memory.prototype, _e2, 1);
+__decorateClass([
+  A_Feature.Extend(),
+  __decorateParam(0, A_Dependency.Required()),
+  __decorateParam(0, A_Inject(A_OperationContext)),
+  __decorateParam(1, A_Inject(A_MemoryContext))
+], A_Memory.prototype, _d3, 1);
+__decorateClass([
+  A_Feature.Extend(),
+  __decorateParam(0, A_Dependency.Required()),
+  __decorateParam(0, A_Inject(A_OperationContext)),
+  __decorateParam(1, A_Inject(A_MemoryContext))
+], A_Memory.prototype, _c3, 1);
+__decorateClass([
+  A_Feature.Extend(),
+  __decorateParam(0, A_Dependency.Required()),
+  __decorateParam(0, A_Inject(A_OperationContext)),
+  __decorateParam(1, A_Inject(A_MemoryContext))
+], A_Memory.prototype, _b3, 1);
+__decorateClass([
+  A_Feature.Extend(),
+  __decorateParam(0, A_Dependency.Required()),
+  __decorateParam(0, A_Inject(A_OperationContext)),
+  __decorateParam(1, A_Inject(A_MemoryContext))
+], A_Memory.prototype, _a3, 1);
 
 // src/lib/A-Schedule/A-Deferred.class.ts
 var A_Deferred = class {
@@ -2368,6 +3080,6 @@ var A_Schedule = class extends A_Component {
   }
 };
 
-export { A_CONSTANTS__A_Command_Status, A_CONSTANTS__CONFIG_ENV_VARIABLES, A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY, A_Channel, A_ChannelError, A_ChannelFeatures, A_ChannelRequest, A_ChannelRequestStatuses, A_Command, A_CommandError, A_CommandFeatures, A_Config, A_ConfigError, A_ConfigLoader, A_Deferred, A_Logger, A_Manifest, A_ManifestChecker, A_ManifestError, A_Memory, A_Polyfill, A_Schedule, A_ScheduleObject, A_TYPES__ConfigFeature, ConfigReader, ENVConfigReader, FileConfigReader };
+export { A_CONSTANTS__CONFIG_ENV_VARIABLES, A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY, A_Channel, A_ChannelError, A_ChannelFeatures, A_ChannelRequestStatuses, A_Command, A_CommandError, A_CommandFeatures, A_CommandTransitions, A_Command_Status, A_Config, A_ConfigError, A_ConfigLoader, A_Deferred, A_Logger, A_Manifest, A_ManifestChecker, A_ManifestError, A_Memory, A_Polyfill, A_Schedule, A_ScheduleObject, A_TYPES__ConfigFeature, ConfigReader, ENVConfigReader, FileConfigReader };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map