diff --git a/packages/core/src/breadcrumbs/breadcrumb-store.ts b/packages/core/src/breadcrumbs/breadcrumb-store.ts
new file mode 100644
index 00000000..54e2eeec
--- /dev/null
+++ b/packages/core/src/breadcrumbs/breadcrumb-store.ts
@@ -0,0 +1,27 @@
+import type { Breadcrumb } from '@hawk.so/types';
+
+/**
+ * Hint passed to beforeBreadcrumb callback.
+ */
+export interface BreadcrumbHint {
+  [key: string]: unknown;
+}
+
+/**
+ * Breadcrumb input type - breadcrumb data with optional timestamp.
+ */
+export type BreadcrumbInput = Omit<Breadcrumb, 'timestamp'> & { timestamp?: number };
+
+/**
+ * Contract for breadcrumb storage. Also serves as public breadcrumbs API.
+ */
+export interface BreadcrumbStore {
+  add(breadcrumb: BreadcrumbInput, hint?: BreadcrumbHint): void;
+  get(): Breadcrumb[];
+  clear(): void;
+}
+
+/**
+ * @deprecated Use {@link BreadcrumbStore} instead.
+ */
+export type BreadcrumbsAPI = BreadcrumbStore;
diff --git a/packages/core/src/errors.ts b/packages/core/src/errors.ts
deleted file mode 100644
index 8fcc5823..00000000
--- a/packages/core/src/errors.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Error triggered when event was rejected by beforeSend method
- */
-export class EventRejectedError extends Error {
-  /**
-   * @param message - error message
-   */
-  constructor(message: string) {
-    super(message);
-    this.name = 'EventRejectedError';
-  }
-}
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index fb1d91f7..7357da6c 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -10,5 +10,7 @@ export type { Transport } from './transports/transport';
 export type { SanitizerTypeHandler } from './modules/sanitizer';
 export { StackParser } from './modules/stack-parser';
 export { buildElementSelector } from './utils/selector';
-export { EventRejectedError } from './errors';
 export { isErrorProcessed, markErrorAsProcessed } from './utils/event';
+export type { BreadcrumbStore, BreadcrumbsAPI, BreadcrumbHint, BreadcrumbInput } from './breadcrumbs/breadcrumb-store';
+export type { ErrorSnapshot, MessageProcessor, ProcessingPayload } from './messages/message-processor';
+export { BreadcrumbsMessageProcessor } from './messages/breadcrumbs-message-processor';
diff --git a/packages/core/src/messages/breadcrumbs-message-processor.ts b/packages/core/src/messages/breadcrumbs-message-processor.ts
new file mode 100644
index 00000000..c183bb61
--- /dev/null
+++ b/packages/core/src/messages/breadcrumbs-message-processor.ts
@@ -0,0 +1,24 @@
+import type { ErrorSnapshot, MessageProcessor, ProcessingPayload } from './message-processor';
+
+/**
+ * Attaches breadcrumbs to payload.
+ */
+export class BreadcrumbsMessageProcessor implements MessageProcessor<'errors/javascript'> {
+  /**
+   * Sets `payload.breadcrumbs` from snapshot if non-empty; skips otherwise.
+   *
+   * @param payload - event message payload to enrich
+   * @param snapshot - snapshot carrying breadcrumbs captured at error time
+   * @returns modified payload with breadcrumbs set, or original payload unchanged
+   */
+  public apply(
+    payload: ProcessingPayload<'errors/javascript'>,
+    snapshot?: ErrorSnapshot
+  ): ProcessingPayload<'errors/javascript'> | null {
+    if (snapshot?.breadcrumbs && snapshot.breadcrumbs.length > 0) {
+      payload.breadcrumbs = snapshot.breadcrumbs;
+    }
+
+    return payload;
+  }
+}
diff --git a/packages/core/src/messages/message-processor.ts b/packages/core/src/messages/message-processor.ts
new file mode 100644
index 00000000..698ed149
--- /dev/null
+++ b/packages/core/src/messages/message-processor.ts
@@ -0,0 +1,59 @@
+import type { Breadcrumb, CatcherMessagePayload, CatcherMessageType } from '@hawk.so/types';
+
+/**
+ * Extracted addons type from catcher message payload.
+ *
+ * @typeParam T - catcher message type
+ */
+type ExtractAddons<T extends CatcherMessageType> =
+  CatcherMessagePayload<T> extends { addons?: infer A } ? A : never;
+
+/**
+ * Payload type used during message processing pipeline.
+ *
+ * Same as {@link CatcherMessagePayload} but with `addons` always defined and partially filled —
+ * processors may contribute individual addon fields independently of each other.
+ *
+ * @typeParam T - catcher message type this payload belongs to
+ */
+export type ProcessingPayload<T extends CatcherMessageType> =
+  Omit<CatcherMessagePayload<T>, 'addons'> & {
+    addons: Partial<ExtractAddons<T>>;
+  };
+
+/**
+ * Snapshot of event context captured synchronously at error time,
+ * before any processing.
+ */
+export interface ErrorSnapshot {
+  /**
+   * Original caught error.
+   */
+  error?: Error | string;
+
+  /**
+   * Breadcrumbs captured at error time.
+   */
+  breadcrumbs?: Breadcrumb[];
+}
+
+/**
+ * Single step in message processing pipeline before message is sent.
+ *
+ * @typeParam T - catcher message type this processor handles
+ */
+export interface MessageProcessor<T extends CatcherMessageType = CatcherMessageType> {
+  /**
+   * Handles input message. May mutate, replace or drop it.
+   *
+   * Dropped message won't be sent.
+   *
+   * @param payload - processed event message payload with partially-built addons
+   * @param snapshot - additional context with original error
+   * @returns modified payload, or `null` to drop message
+   */
+  apply(
+    payload: ProcessingPayload<T>,
+    snapshot?: ErrorSnapshot,
+  ): ProcessingPayload<T> | null
+}
diff --git a/packages/core/src/modules/sanitizer.ts b/packages/core/src/modules/sanitizer.ts
index ba2488ed..44289824 100644
--- a/packages/core/src/modules/sanitizer.ts
+++ b/packages/core/src/modules/sanitizer.ts
@@ -154,7 +154,6 @@ export class Sanitizer {
     depth: number,
     seen: WeakSet<object>
   ): Record<string, any> | '<deep object>' | '<big object>' {
-
     // If the maximum depth is reached, return a placeholder
     if (depth > Sanitizer.maxDepth) {
       return '<deep object>';
diff --git a/packages/javascript/src/addons/breadcrumbs.ts b/packages/javascript/src/addons/breadcrumbs.ts
index c953e790..c0d05c10 100644
--- a/packages/javascript/src/addons/breadcrumbs.ts
+++ b/packages/javascript/src/addons/breadcrumbs.ts
@@ -2,6 +2,7 @@
  * @file Breadcrumbs module - captures chronological trail of events before an error
  */
 import type { Breadcrumb, BreadcrumbLevel, BreadcrumbType, Json, JsonNode } from '@hawk.so/types';
+import type { BreadcrumbHint, BreadcrumbInput, BreadcrumbStore } from '@hawk.so/core';
 import { buildElementSelector, isValidBreadcrumb, log, Sanitizer } from '@hawk.so/core';
 
 /**
@@ -10,9 +11,10 @@ import { buildElementSelector, isValidBreadcrumb, log, Sanitizer } from '@hawk.s
 const DEFAULT_MAX_BREADCRUMBS = 15;
 
 /**
- * Hint object passed to beforeBreadcrumb callback
+ * Hint object passed to beforeBreadcrumb callback.
+ * Extends generic {@link BreadcrumbHint} with browser-specific data.
  */
-export interface BreadcrumbHint {
+export interface BrowserBreadcrumbHint extends BreadcrumbHint {
   /**
    * Original event that triggered the breadcrumb (if any)
    */
@@ -51,7 +53,7 @@ export interface BreadcrumbsOptions {
    * - Return `false` — the breadcrumb will be discarded.
    * - Any other value is invalid — the original breadcrumb is stored as-is (a warning is logged).
    */
-  beforeBreadcrumb?: (breadcrumb: Breadcrumb, hint?: BreadcrumbHint) => Breadcrumb | false | void;
+  beforeBreadcrumb?: (breadcrumb: Breadcrumb, hint?: BrowserBreadcrumbHint) => Breadcrumb | false | void;
 
   /**
    * Enable automatic fetch/XHR breadcrumbs
@@ -75,12 +77,6 @@ export interface BreadcrumbsOptions {
   trackClicks?: boolean;
 }
 
-/**
- * Breadcrumb input type - breadcrumb data with optional timestamp
- * (timestamp will be auto-generated if not provided)
- */
-export type BreadcrumbInput = Omit<Breadcrumb, 'timestamp'> & { timestamp?: Breadcrumb['timestamp'] };
-
 /**
  * Internal breadcrumbs options - all fields except 'beforeBreadcrumb' are required
  * (they have default values and are always set during init)
@@ -90,17 +86,18 @@ interface InternalBreadcrumbsOptions {
   trackFetch: boolean;
   trackNavigation: boolean;
   trackClicks: boolean;
-  beforeBreadcrumb?: (breadcrumb: Breadcrumb, hint?: BreadcrumbHint) => Breadcrumb | false | void;
+  beforeBreadcrumb?: (breadcrumb: Breadcrumb, hint?: BrowserBreadcrumbHint) => Breadcrumb | false | void;
 }
 
 /**
- * BreadcrumbManager - singleton that manages breadcrumb collection and storage
+ * Browser implementation of BreadcrumbStore.
+ * Singleton that manages breadcrumb collection and storage.
  */
-export class BreadcrumbManager {
+export class BrowserBreadcrumbStore implements BreadcrumbStore {
   /**
    * Singleton instance
    */
-  private static instance: BreadcrumbManager | null = null;
+  private static instance: BrowserBreadcrumbStore | null = null;
 
   /**
    * Breadcrumbs buffer (FIFO)
@@ -167,10 +164,10 @@ export class BreadcrumbManager {
   /**
    * Get singleton instance
    */
-  public static getInstance(): BreadcrumbManager {
-    BreadcrumbManager.instance ??= new BreadcrumbManager();
+  public static getInstance(): BrowserBreadcrumbStore {
+    BrowserBreadcrumbStore.instance ??= new BrowserBreadcrumbStore();
 
-    return BreadcrumbManager.instance;
+    return BrowserBreadcrumbStore.instance;
   }
 
   /**
@@ -180,8 +177,6 @@ export class BreadcrumbManager {
    */
   public init(options: BreadcrumbsOptions = {}): void {
     if (this.isInitialized) {
-      log('[BreadcrumbManager] init has already been called; breadcrumb configuration is global and subsequent init options are ignored.', 'warn');
-
       return;
     }
 
@@ -219,7 +214,7 @@ export class BreadcrumbManager {
    * @param hint - Optional hint object with original event data (Event, Response, XMLHttpRequest, etc.)
    *               Used by beforeBreadcrumb callback to access original event context
    */
-  public addBreadcrumb(breadcrumb: BreadcrumbInput, hint?: BreadcrumbHint): void {
+  public add(breadcrumb: BreadcrumbInput, hint?: BrowserBreadcrumbHint): void {
     /**
      * Ensure timestamp
      */
@@ -293,14 +288,14 @@ export class BreadcrumbManager {
   /**
    * Get current breadcrumbs snapshot (oldest to newest)
    */
-  public getBreadcrumbs(): Breadcrumb[] {
+  public get(): Breadcrumb[] {
     return [ ...this.breadcrumbs ];
   }
 
   /**
    * Clear all breadcrumbs
    */
-  public clearBreadcrumbs(): void {
+  public clear(): void {
     this.breadcrumbs.length = 0;
   }
 
@@ -358,9 +353,9 @@ export class BreadcrumbManager {
       this.popstateHandler = null;
     }
 
-    this.clearBreadcrumbs();
+    this.clear();
     this.isInitialized = false;
-    BreadcrumbManager.instance = null;
+    BrowserBreadcrumbStore.instance = null;
   }
 
 
@@ -399,7 +394,7 @@ export class BreadcrumbManager {
 
         const duration = Date.now() - startTime;
 
-        manager.addBreadcrumb({
+        manager.add({
           type: 'request',
           category: 'fetch',
           message: `${response.status} ${method} ${url}`,
@@ -419,7 +414,7 @@ export class BreadcrumbManager {
       } catch (error) {
         const duration = Date.now() - startTime;
 
-        manager.addBreadcrumb({
+        manager.add({
           type: 'request',
           category: 'fetch',
           message: `[FAIL] ${method} ${url}`,
@@ -483,7 +478,7 @@ export class BreadcrumbManager {
           const url = this.hawkUrl || '';
           const status = this.status;
 
-          manager.addBreadcrumb({
+          manager.add({
             type: 'request',
             category: 'xhr',
             message: `${status} ${method} ${url}`,
@@ -529,7 +524,7 @@ export class BreadcrumbManager {
 
       lastUrl = to;
 
-      manager.addBreadcrumb({
+      manager.add({
         type: 'navigation',
         category: 'navigation',
         message: `Navigated to ${to}`,
@@ -599,7 +594,7 @@ export class BreadcrumbManager {
        */
       const text = (target.textContent || target.innerText || '').trim().substring(0, 50);
 
-      manager.addBreadcrumb({
+      manager.add({
         type: 'ui',
         category: 'ui.click',
         message: `Click on ${selector}`,
diff --git a/packages/javascript/src/addons/userAgentInfo.ts b/packages/javascript/src/addons/userAgentInfo.ts
deleted file mode 100644
index ec7c3706..00000000
--- a/packages/javascript/src/addons/userAgentInfo.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * @file Integration for adding User Agent info
- */
-
-/**
- * @param event - event to modify
- * @param data - event data
- */
-export default function (event, data): void {
-  data.payload.userAgent = {
-    name: window.navigator.userAgent,
-    frame: {
-      width: window.innerWidth,
-      height: window.innerHeight,
-    },
-  };
-}
diff --git a/packages/javascript/src/catcher.ts b/packages/javascript/src/catcher.ts
index 08b0e889..462906f1 100644
--- a/packages/javascript/src/catcher.ts
+++ b/packages/javascript/src/catcher.ts
@@ -1,21 +1,21 @@
 import './modules/element-sanitizer';
 import Socket from './modules/socket';
-import type { BreadcrumbsAPI, CatcherMessage, HawkInitialSettings, HawkJavaScriptEvent, Transport } from './types';
+import type { CatcherMessage, HawkInitialSettings, HawkJavaScriptEvent, Transport } from './types';
 import { VueIntegration } from './integrations/vue';
 import type {
   AffectedUser,
+  CatcherMessagePayload,
   DecodedIntegrationToken,
   EncodedIntegrationToken,
   EventContext,
-  JavaScriptAddons,
-  Json,
   VueIntegrationAddons
 } from '@hawk.so/types';
 import type { JavaScriptCatcherIntegrations } from '@/types';
 import { ConsoleCatcher } from './addons/consoleCatcher';
-import { BreadcrumbManager } from './addons/breadcrumbs';
+import { BrowserBreadcrumbStore } from './addons/breadcrumbs';
+import type { BreadcrumbStore, MessageProcessor, ProcessingPayload } from '@hawk.so/core';
 import {
-  EventRejectedError,
+  BreadcrumbsMessageProcessor,
   HawkUserManager,
   isErrorProcessed,
   isLoggerSet,
@@ -31,6 +31,9 @@ import {
 import { HawkLocalStorage } from './storages/hawk-local-storage';
 import { createBrowserLogger } from './logger/logger';
 import { BrowserRandomGenerator } from './utils/random';
+import { BrowserAddonMessageProcessor } from './messages/browser-addon-message-processor';
+import { ConsoleOutputAddonMessageProcessor } from './messages/console-output-addon-message-processor';
+import { DebugAddonMessageProcessor } from './messages/debug-addon-message-processor';
 
 /**
  * Allow to use global VERSION, that will be overwritten by Webpack
@@ -121,9 +124,9 @@ export default class Catcher {
   private readonly consoleCatcher: ConsoleCatcher | null = null;
 
   /**
-   * Breadcrumb manager instance
+   * Breadcrumb store instance
    */
-  private readonly breadcrumbManager: BreadcrumbManager | null;
+  private readonly breadcrumbStore: BrowserBreadcrumbStore | null;
 
   /**
    * Manages currently authenticated user identity.
@@ -133,6 +136,11 @@ export default class Catcher {
     new BrowserRandomGenerator()
   );
 
+  /**
+   * Ordered list of message processors applied to every outgoing event message.
+   */
+  private readonly messageProcessors: MessageProcessor<typeof Catcher.type>[];
+
   /**
    * Catcher constructor
    *
@@ -161,6 +169,9 @@ export default class Catcher {
       settings.consoleTracking !== null && settings.consoleTracking !== undefined
         ? settings.consoleTracking
         : true;
+    this.messageProcessors = [
+      new BrowserAddonMessageProcessor(),
+    ];
 
     if (!this.token) {
       log(
@@ -188,17 +199,26 @@ export default class Catcher {
 
     if (this.consoleTracking) {
       this.consoleCatcher = ConsoleCatcher.getInstance();
-      this.consoleCatcher.init();
+      this.messageProcessors.push(new ConsoleOutputAddonMessageProcessor(this.consoleCatcher));
     }
 
     /**
      * Initialize breadcrumbs
      */
     if (settings.breadcrumbs !== false) {
-      this.breadcrumbManager = BreadcrumbManager.getInstance();
-      this.breadcrumbManager.init(settings.breadcrumbs ?? {});
+      this.breadcrumbStore = BrowserBreadcrumbStore.getInstance();
+      this.breadcrumbStore.init(settings.breadcrumbs ?? {});
+      this.messageProcessors.push(new BreadcrumbsMessageProcessor());
     } else {
-      this.breadcrumbManager = null;
+      this.breadcrumbStore = null;
+    }
+
+    if (this.debug) {
+      this.messageProcessors.push(new DebugAddonMessageProcessor());
+    }
+
+    if (settings.messageProcessors) {
+      this.messageProcessors.push(...settings.messageProcessors);
     }
 
     /**
@@ -297,11 +317,11 @@ export default class Catcher {
    *   data: { userId: '123' }
    * });
    */
-  public get breadcrumbs(): BreadcrumbsAPI {
+  public get breadcrumbs(): BreadcrumbStore {
     return {
-      add: (breadcrumb, hint) => this.breadcrumbManager?.addBreadcrumb(breadcrumb, hint),
-      get: () => this.breadcrumbManager?.getBreadcrumbs() ?? [],
-      clear: () => this.breadcrumbManager?.clearBreadcrumbs(),
+      add: (breadcrumb, hint) => this.breadcrumbStore?.add(breadcrumb, hint),
+      get: () => this.breadcrumbStore?.get() ?? [],
+      clear: () => this.breadcrumbStore?.clear(),
     };
   }
 
@@ -360,7 +380,12 @@ export default class Catcher {
   }
 
   /**
-   * Format and send an error
+   * Process and sends error message.
+   *
+   * Returns early without sending either if
+   * - error was already processed,
+   * - message processor drops it
+   * - {@link beforeSend} hook rejects it
    *
    * @param error - error to send
    * @param integrationAddons - addons spoiled by Integration
@@ -384,105 +409,123 @@ export default class Catcher {
         markErrorAsProcessed(error);
       }
 
-      const errorFormatted = await this.prepareErrorFormatted(error, context);
+      const snapshot = {
+        error,
+        breadcrumbs: this.breadcrumbStore?.get()
+      };
+      let processingPayload = await this.buildBasePayload(error, context);
+
+      for (const processor of this.messageProcessors) {
+        const result = processor.apply(processingPayload, snapshot);
+
+        if (result === null) {
+          return;
+        }
+
+        processingPayload = result;
+      }
+
+      const payload = processingPayload as CatcherMessagePayload<typeof Catcher.type>;
 
-      /**
-       * If this event caught by integration (Vue or other), it can pass extra addons
-       */
       if (integrationAddons) {
-        this.appendIntegrationAddons(errorFormatted, Sanitizer.sanitize(integrationAddons));
+        payload.addons = {
+          ...(payload.addons ?? {}),
+          ...Sanitizer.sanitize(integrationAddons),
+        };
       }
 
-      this.sendErrorFormatted(errorFormatted);
-    } catch (e) {
-      if (e instanceof EventRejectedError) {
-        /**
-         * Event was rejected by user using the beforeSend method
-         */
+      const payloadPostBeforeSend = this.applyBeforeSendHook(payload);
+
+      if (payloadPostBeforeSend === null) {
+        // Event was rejected by user using the beforeSend method
         return;
       }
 
+      this.sendMessage({
+        token: this.token,
+        catcherType: Catcher.type,
+        payload: payloadPostBeforeSend,
+      } as CatcherMessage<typeof Catcher.type>);
+    } catch (e) {
       log('Unable to send error. Seems like it is Hawk internal bug. Please, report it here: https://github.com/codex-team/hawk.javascript/issues/new', 'warn', e);
     }
   }
 
   /**
-   * Sends formatted HawkEvent to the Collector
+   * Builds base event payload with basic fields (title, type, backtrace, user, context, release).
    *
-   * @param errorFormatted - formatted error to send
+   * @param error - caught error or string reason
+   * @param context - per-call context to merge with instance-level context
+   * @returns base payload with core data
    */
-  private sendErrorFormatted(errorFormatted: CatcherMessage<typeof Catcher.type>): void {
-    this.transport.send(errorFormatted)
-      .catch((sendingError) => {
-        log('WebSocket sending error', 'error', sendingError);
-      });
-  }
-
-  /**
-   * Formats the event
-   *
-   * @param error - error to format
-   * @param context - any additional data passed by user
-   */
-  private async prepareErrorFormatted(error: Error | string, context?: EventContext): Promise<CatcherMessage<typeof Catcher.type>> {
-    let payload: HawkJavaScriptEvent = {
+  private async buildBasePayload(
+    error: Error | string,
+    context?: EventContext
+  ): Promise<ProcessingPayload<typeof Catcher.type>> {
+    return {
       title: this.getTitle(error),
       type: this.getType(error),
       release: this.getRelease(),
-      breadcrumbs: this.getBreadcrumbsForEvent(),
       context: this.getContext(context),
       user: this.getUser(),
-      addons: this.getAddons(error),
       backtrace: await this.getBacktrace(error),
       catcherVersion: this.version,
+      addons: {},
     };
+  }
 
-    /**
-     * Filter sensitive data
-     */
-    if (typeof this.beforeSend === 'function') {
-      let eventPayloadClone: HawkJavaScriptEvent;
+  /**
+   * Clones {@link payload} and applies user-supplied {@link beforeSend} hook against it.
+   *
+   * @param payload - processed event message payload
+   * @returns possibly modified payload, or null if the event should be dropped
+   */
+  private applyBeforeSendHook(
+    payload: CatcherMessagePayload<typeof Catcher.type>
+  ): CatcherMessagePayload<typeof Catcher.type> | null {
+    if (typeof this.beforeSend !== 'function') {
+      return payload;
+    }
 
-      try {
-        eventPayloadClone = structuredClone(payload);
-      } catch {
-        /**
-         * structuredClone may fail on non-cloneable values (functions, DOM nodes, etc.)
-         * Fall back to passing the original — hook may mutate it, but at least reporting won't crash
-         */
-        eventPayloadClone = payload;
-      }
+    let clone: CatcherMessagePayload<typeof Catcher.type>;
 
-      const result = this.beforeSend(eventPayloadClone);
+    try {
+      clone = structuredClone(payload);
+    } catch {
+      // structuredClone may fail on non-cloneable values (functions, DOM nodes, etc.)
+      // Fall back to passing the original — hook may mutate it, but at least reporting won't crash
+      clone = payload;
+    }
 
-      /**
-       * false → drop event
-       */
-      if (result === false) {
-        throw new EventRejectedError('Event rejected by beforeSend method.');
-      }
+    const result = this.beforeSend(clone);
 
-      /**
-       * Valid event payload → use it instead of original
-       */
-      if (isValidEventPayload(result)) {
-        payload = result as HawkJavaScriptEvent;
-      } else {
-        /**
-         * Anything else is invalid — warn, payload stays untouched (hook only received a clone)
-         */
-        log(
-          'Invalid beforeSend value. It should return event or false. Event is sent without changes.',
-          'warn'
-        );
-      }
+    // false → drop event
+    if (result === false) {
+      return null;
     }
 
-    return {
-      token: this.token,
-      catcherType: Catcher.type,
-      payload,
-    };
+    // Valid event payload → use it instead of original
+    if (isValidEventPayload(result)) {
+      return result as CatcherMessagePayload<typeof Catcher.type>;
+    }
+
+    // Anything else is invalid — warn, payload stays untouched (hook only received a clone)
+    log(
+      'Invalid beforeSend value. It should return event or false. Event is sent without changes.',
+      'warn'
+    );
+
+    return payload;
+  }
+
+  /**
+   * Dispatches assembled message over configured transport.
+   *
+   * @param message - fully assembled catcher message ready to send
+   */
+  private sendMessage(message: CatcherMessage<typeof Catcher.type>): void {
+    this.transport.send(message)
+      .catch((e) => log('Transport sending error', 'error', e));
   }
 
   /**
@@ -574,39 +617,6 @@ export default class Catcher {
     return this.userManager.getUser();
   }
 
-  /**
-   * Get breadcrumbs for event payload
-   */
-  private getBreadcrumbsForEvent(): HawkJavaScriptEvent['breadcrumbs'] {
-    const breadcrumbs = this.breadcrumbManager?.getBreadcrumbs();
-
-    return breadcrumbs && breadcrumbs.length > 0 ? breadcrumbs : undefined;
-  }
-
-  /**
-   * Get parameters
-   */
-  private getGetParams(): Json | null {
-    const searchString = window.location.search.substr(1);
-
-    if (!searchString) {
-      return null;
-    }
-
-    /**
-     * Create object from get-params string
-     */
-    const pairs = searchString.split('&');
-
-    return pairs.reduce((accumulator, pair) => {
-      const [key, value] = pair.split('=');
-
-      accumulator[key] = value;
-
-      return accumulator;
-    }, {});
-  }
-
   /**
    * Return parsed backtrace information
    *
@@ -631,70 +641,4 @@ export default class Catcher {
       return undefined;
     }
   }
-
-  /**
-   * Return some details
-   *
-   * @param {Error|string} error — caught error
-   */
-  private getAddons(error: Error | string): HawkJavaScriptEvent['addons'] {
-    const { innerWidth, innerHeight } = window;
-    const userAgent = window.navigator.userAgent;
-    const location = window.location.href;
-    const getParams = this.getGetParams();
-    const consoleLogs = this.consoleTracking && this.consoleCatcher?.getConsoleLogStack();
-
-    const addons: JavaScriptAddons = {
-      window: {
-        innerWidth,
-        innerHeight,
-      },
-      userAgent,
-      url: location,
-    };
-
-    if (getParams) {
-      addons.get = getParams;
-    }
-
-    if (this.debug) {
-      addons.RAW_EVENT_DATA = this.getRawData(error);
-    }
-
-    if (consoleLogs && consoleLogs.length > 0) {
-      addons.consoleOutput = consoleLogs;
-    }
-
-    return addons;
-  }
-
-  /**
-   * Compose raw data object
-   *
-   * @param {Error|string} error — caught error
-   */
-  private getRawData(error: Error | string): Json | undefined {
-    if (!(error instanceof Error)) {
-      return;
-    }
-
-    const stack = error.stack !== null && error.stack !== undefined ? error.stack : '';
-
-    return {
-      name: error.name,
-      message: error.message,
-      stack,
-    };
-  }
-
-  /**
-   * Extend addons object with addons spoiled by integration
-   * This method mutates original event
-   *
-   * @param errorFormatted - Hawk event prepared for sending
-   * @param integrationAddons - extra addons
-   */
-  private appendIntegrationAddons(errorFormatted: CatcherMessage<typeof Catcher.type>, integrationAddons: JavaScriptCatcherIntegrations): void {
-    Object.assign(errorFormatted.payload.addons, integrationAddons);
-  }
 }
diff --git a/packages/javascript/src/messages/browser-addon-message-processor.ts b/packages/javascript/src/messages/browser-addon-message-processor.ts
new file mode 100644
index 00000000..28f66902
--- /dev/null
+++ b/packages/javascript/src/messages/browser-addon-message-processor.ts
@@ -0,0 +1,61 @@
+import type { MessageProcessor, ProcessingPayload } from '@hawk.so/core';
+import { type Json } from '@hawk.so/types';
+
+/**
+ * Enriches payload with browser environment data:
+ * viewport dimensions, user agent, current URL, and GET parameters.
+ */
+export class BrowserAddonMessageProcessor implements MessageProcessor<'errors/javascript'> {
+  /**
+   * Reads current browser state (window dimensions, user agent, URL, GET params) and
+   * merges it into `payload.addons`, preserving any addons already set.
+   *
+   * @param payload - event message payload to enrich
+   * @returns modified payload with browser addons merged in
+   */
+  public apply(
+    payload: ProcessingPayload<'errors/javascript'>
+  ): ProcessingPayload<'errors/javascript'> | null {
+    const { innerWidth, innerHeight } = window;
+    const userAgent = window.navigator.userAgent;
+    const url = window.location.href;
+    const get = this.parseGetParams();
+
+    payload.addons = {
+      ...payload.addons,
+      window: {
+        innerWidth,
+        innerHeight,
+      },
+      userAgent,
+      url,
+      get,
+    };
+
+    return payload;
+  }
+
+  /**
+   * Parses `window.location.search` into plain key-value object.
+   *
+   * @returns parsed GET parameters, or `undefined` if URL has no query string
+   */
+  private parseGetParams(): Json | undefined {
+    const searchString = window.location.search.substring(1);
+
+    if (!searchString) {
+      return undefined;
+    }
+
+    // Create object from get-params string
+    const pairs = searchString.split('&');
+
+    return pairs.reduce((accumulator, pair) => {
+      const [key, value] = pair.split('=');
+
+      accumulator[key] = value;
+
+      return accumulator;
+    }, {});
+  }
+}
diff --git a/packages/javascript/src/messages/console-output-addon-message-processor.ts b/packages/javascript/src/messages/console-output-addon-message-processor.ts
new file mode 100644
index 00000000..36e1e937
--- /dev/null
+++ b/packages/javascript/src/messages/console-output-addon-message-processor.ts
@@ -0,0 +1,38 @@
+import type { MessageProcessor, ProcessingPayload } from '@hawk.so/core';
+import type { ConsoleCatcher } from '../addons/consoleCatcher';
+
+/**
+ * Attaches captured console output to payload addons.
+ */
+export class ConsoleOutputAddonMessageProcessor implements MessageProcessor<'errors/javascript'> {
+  private readonly consoleCatcher: ConsoleCatcher;
+
+  /**
+   * Stores catcher reference and starts console interception.
+   *
+   * @param consoleCatcher - console catcher instance to read logs from
+   */
+  constructor(consoleCatcher: ConsoleCatcher) {
+    this.consoleCatcher = consoleCatcher;
+    this.consoleCatcher.init();
+  }
+
+  /**
+   * Attaches current console log stack to `payload.addons.consoleOutput`.
+   * Skips if log stack is empty.
+   *
+   * @param payload - event message payload to enrich
+   * @returns modified payload with console logs attached, or original payload unchanged
+   */
+  public apply(
+    payload: ProcessingPayload<'errors/javascript'>
+  ): ProcessingPayload<'errors/javascript'> | null {
+    const logs = this.consoleCatcher?.getConsoleLogStack();
+
+    if (logs && logs.length > 0) {
+      payload.addons.consoleOutput = logs;
+    }
+
+    return payload;
+  }
+}
diff --git a/packages/javascript/src/messages/debug-addon-message-processor.ts b/packages/javascript/src/messages/debug-addon-message-processor.ts
new file mode 100644
index 00000000..1aab6779
--- /dev/null
+++ b/packages/javascript/src/messages/debug-addon-message-processor.ts
@@ -0,0 +1,31 @@
+import type { ErrorSnapshot, MessageProcessor, ProcessingPayload } from '@hawk.so/core';
+
+/**
+ * Appends `RAW_EVENT_DATA` to the event addons for debug purposes.
+ */
+export class DebugAddonMessageProcessor implements MessageProcessor<'errors/javascript'> {
+  /**
+   * Writes name, message, and stack from `snapshot.error` into `payload.addons.RAW_EVENT_DATA`.
+   * Skips if snapshot error is missing or not Error instance.
+   *
+   * @param payload - event message payload to enrich
+   * @param snapshot - snapshot carrying original caught error
+   * @returns modified payload with RAW_EVENT_DATA set, or original payload unchanged
+   */
+  public apply(
+    payload: ProcessingPayload<'errors/javascript'>,
+    snapshot?: ErrorSnapshot
+  ): ProcessingPayload<'errors/javascript'> | null {
+    if (!(snapshot?.error instanceof Error)) {
+      return payload;
+    }
+
+    payload.addons.RAW_EVENT_DATA = {
+      name: snapshot.error.name,
+      message: snapshot.error.message,
+      stack: snapshot.error.stack ?? '',
+    };
+
+    return payload;
+  }
+}
diff --git a/packages/javascript/src/types/breadcrumbs-api.ts b/packages/javascript/src/types/breadcrumbs-api.ts
deleted file mode 100644
index 777dcdf3..00000000
--- a/packages/javascript/src/types/breadcrumbs-api.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import type { Breadcrumb } from '@hawk.so/types';
-import type { BreadcrumbInput, BreadcrumbHint } from '../addons/breadcrumbs';
-
-/**
- * Breadcrumbs API interface
- */
-export interface BreadcrumbsAPI {
-  add: (breadcrumb: BreadcrumbInput, hint?: BreadcrumbHint) => void;
-  get: () => Breadcrumb[];
-  clear: () => void;
-}
diff --git a/packages/javascript/src/types/hawk-initial-settings.ts b/packages/javascript/src/types/hawk-initial-settings.ts
index 7293826f..cf60fed6 100644
--- a/packages/javascript/src/types/hawk-initial-settings.ts
+++ b/packages/javascript/src/types/hawk-initial-settings.ts
@@ -1,6 +1,6 @@
 import type { AffectedUser, EventContext } from '@hawk.so/types';
 import type { HawkJavaScriptEvent } from './event';
-import type { Transport } from '@hawk.so/core';
+import type { MessageProcessor, Transport } from '@hawk.so/core';
 import type { BreadcrumbsOptions } from '../addons/breadcrumbs';
 
 /**
@@ -98,4 +98,11 @@ export interface HawkInitialSettings {
    * If not provided, default WebSocket transport is used.
    */
   transport?: Transport;
+
+  /**
+   * Custom message processors.
+   * Used to prepare event message before send.
+   * May modify original event payload or return null to drop it.
+   */
+  messageProcessors?: MessageProcessor<'errors/javascript'>[];
 }
diff --git a/packages/javascript/src/types/index.ts b/packages/javascript/src/types/index.ts
index f2829160..5cf529ad 100644
--- a/packages/javascript/src/types/index.ts
+++ b/packages/javascript/src/types/index.ts
@@ -1,9 +1,14 @@
 import type { CatcherMessage } from './catcher-message';
 import type { HawkInitialSettings } from './hawk-initial-settings';
 import type { Transport } from '@hawk.so/core';
+import type { BreadcrumbsAPI, BreadcrumbStore } from '@hawk.so/core';
 import type { HawkJavaScriptEvent } from './event';
-import type { VueIntegrationData, NuxtIntegrationData, NuxtIntegrationAddons, JavaScriptCatcherIntegrations } from './integrations';
-import type { BreadcrumbsAPI } from './breadcrumbs-api';
+import type {
+  JavaScriptCatcherIntegrations,
+  NuxtIntegrationAddons,
+  NuxtIntegrationData,
+  VueIntegrationData
+} from './integrations';
 
 export type {
   CatcherMessage,
@@ -14,5 +19,6 @@ export type {
   NuxtIntegrationData,
   NuxtIntegrationAddons,
   JavaScriptCatcherIntegrations,
+  BreadcrumbStore,
   BreadcrumbsAPI
 };
diff --git a/packages/javascript/tests/breadcrumbs.test.ts b/packages/javascript/tests/breadcrumbs.test.ts
index 7afec05c..9147e81d 100644
--- a/packages/javascript/tests/breadcrumbs.test.ts
+++ b/packages/javascript/tests/breadcrumbs.test.ts
@@ -1,14 +1,14 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { BreadcrumbManager } from '../src/addons/breadcrumbs';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs';
 import type { Breadcrumb } from '@hawk.so/types';
 import * as core from '@hawk.so/core';
 
 function resetManager(): void {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  (BreadcrumbManager as any).instance = null;
+  (BrowserBreadcrumbStore as any).instance?.destroy();
 }
 
-describe('BreadcrumbManager', () => {
+describe('BrowserBreadcrumbStore', () => {
   let logSpy: ReturnType<typeof vi.spyOn>;
 
   beforeEach(() => {
@@ -21,19 +21,19 @@ describe('BreadcrumbManager', () => {
   });
 
   it('should return empty array when no breadcrumbs added', () => {
-    const m = BreadcrumbManager.getInstance();
+    const m = BrowserBreadcrumbStore.getInstance();
 
     m.init();
-    expect(m.getBreadcrumbs()).toEqual([]);
+    expect(m.get()).toEqual([]);
   });
 
   it('should store breadcrumb with auto-generated timestamp', () => {
-    const m = BreadcrumbManager.getInstance();
+    const m = BrowserBreadcrumbStore.getInstance();
 
     m.init();
-    m.addBreadcrumb({ type: 'default', message: 'test', level: 'info' });
+    m.add({ type: 'default', message: 'test', level: 'info' });
 
-    const crumbs = m.getBreadcrumbs();
+    const crumbs = m.get();
 
     expect(crumbs).toHaveLength(1);
     expect(crumbs[0].message).toBe('test');
@@ -41,24 +41,24 @@ describe('BreadcrumbManager', () => {
   });
 
   it('should keep explicit timestamp as-is', () => {
-    const m = BreadcrumbManager.getInstance();
+    const m = BrowserBreadcrumbStore.getInstance();
 
     m.init();
-    m.addBreadcrumb({ type: 'default', message: 'test', level: 'info', timestamp: 12345 });
+    m.add({ type: 'default', message: 'test', level: 'info', timestamp: 12345 });
 
-    expect(m.getBreadcrumbs()[0].timestamp).toBe(12345);
+    expect(m.get()[0].timestamp).toBe(12345);
   });
 
   it('should drop oldest breadcrumbs when buffer overflows (FIFO)', () => {
-    const m = BreadcrumbManager.getInstance();
+    const m = BrowserBreadcrumbStore.getInstance();
 
     m.init({ maxBreadcrumbs: 3 });
 
     for (let i = 0; i < 5; i++) {
-      m.addBreadcrumb({ type: 'default', message: `msg-${i}`, level: 'info' });
+      m.add({ type: 'default', message: `msg-${i}`, level: 'info' });
     }
 
-    const crumbs = m.getBreadcrumbs();
+    const crumbs = m.get();
 
     expect(crumbs).toHaveLength(3);
     expect(crumbs[0].message).toBe('msg-2');
@@ -66,55 +66,55 @@ describe('BreadcrumbManager', () => {
   });
 
   it('should store max 15 breadcrumbs by default', () => {
-    const m = BreadcrumbManager.getInstance();
+    const m = BrowserBreadcrumbStore.getInstance();
 
     m.init();
 
     for (let i = 0; i < 20; i++) {
-      m.addBreadcrumb({ type: 'default', message: `msg-${i}`, level: 'info' });
+      m.add({ type: 'default', message: `msg-${i}`, level: 'info' });
     }
 
-    expect(m.getBreadcrumbs()).toHaveLength(15);
+    expect(m.get()).toHaveLength(15);
   });
 
   it('should empty buffer on clear', () => {
-    const m = BreadcrumbManager.getInstance();
+    const m = BrowserBreadcrumbStore.getInstance();
 
     m.init();
-    m.addBreadcrumb({ type: 'default', message: 'test', level: 'info' });
-    m.clearBreadcrumbs();
+    m.add({ type: 'default', message: 'test', level: 'info' });
+    m.clear();
 
-    expect(m.getBreadcrumbs()).toEqual([]);
+    expect(m.get()).toEqual([]);
   });
 
   it('should return a copy, not the internal array', () => {
-    const m = BreadcrumbManager.getInstance();
+    const m = BrowserBreadcrumbStore.getInstance();
 
     m.init();
-    m.addBreadcrumb({ type: 'default', message: 'test', level: 'info' });
+    m.add({ type: 'default', message: 'test', level: 'info' });
 
-    const first = m.getBreadcrumbs();
-    const second = m.getBreadcrumbs();
+    const first = m.get();
+    const second = m.get();
 
     expect(first).not.toBe(second);
     expect(first).toEqual(second);
 
     first.push({ type: 'default', message: 'injected', level: 'info', timestamp: 0 } as Breadcrumb);
 
-    expect(m.getBreadcrumbs()).toHaveLength(1);
+    expect(m.get()).toHaveLength(1);
   });
 
   it('should ignore second init call', () => {
-    const m = BreadcrumbManager.getInstance();
+    const m = BrowserBreadcrumbStore.getInstance();
 
     m.init({ maxBreadcrumbs: 5 });
     m.init({ maxBreadcrumbs: 100 });
 
     for (let i = 0; i < 10; i++) {
-      m.addBreadcrumb({ type: 'default', message: `msg-${i}`, level: 'info' });
+      m.add({ type: 'default', message: `msg-${i}`, level: 'info' });
     }
 
-    expect(m.getBreadcrumbs()).toHaveLength(5);
+    expect(m.get()).toHaveLength(5);
   });
 });
 
@@ -132,7 +132,7 @@ describe('beforeBreadcrumb', () => {
 
   it('should store modified breadcrumb when hook returns changed object', () => {
     // Arrange
-    const m = BreadcrumbManager.getInstance();
+    const m = BrowserBreadcrumbStore.getInstance();
 
     m.init({
       beforeBreadcrumb(bc) {
@@ -143,25 +143,25 @@ describe('beforeBreadcrumb', () => {
     });
 
     // Act
-    m.addBreadcrumb({ type: 'default', message: 'original', level: 'info' });
+    m.add({ type: 'default', message: 'original', level: 'info' });
 
     // Assert
-    expect(m.getBreadcrumbs()[0].message).toBe('MODIFIED');
+    expect(m.get()[0].message).toBe('MODIFIED');
   });
 
   it('should not store breadcrumb when hook returns false', () => {
     // Arrange
-    const m = BreadcrumbManager.getInstance();
+    const m = BrowserBreadcrumbStore.getInstance();
 
     m.init({
       beforeBreadcrumb: () => false,
     });
 
     // Act
-    m.addBreadcrumb({ type: 'default', message: 'drop', level: 'info' });
+    m.add({ type: 'default', message: 'drop', level: 'info' });
 
     // Assert
-    expect(m.getBreadcrumbs()).toHaveLength(0);
+    expect(m.get()).toHaveLength(0);
   });
 
   it.each([
@@ -172,7 +172,7 @@ describe('beforeBreadcrumb', () => {
     { label: 'true', value: true },
   ])('should store original breadcrumb and warn when hook returns $label', ({ value }) => {
     // Arrange
-    const m = BreadcrumbManager.getInstance();
+    const m = BrowserBreadcrumbStore.getInstance();
 
     m.init({
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -180,10 +180,10 @@ describe('beforeBreadcrumb', () => {
     });
 
     // Act
-    m.addBreadcrumb({ type: 'default', message: 'original', level: 'info' });
+    m.add({ type: 'default', message: 'original', level: 'info' });
 
     // Assert
-    expect(m.getBreadcrumbs()[0].message).toBe('original');
+    expect(m.get()[0].message).toBe('original');
     expect(logSpy).toHaveBeenCalledWith(
       expect.stringContaining('Invalid beforeBreadcrumb value'),
       'warn'
@@ -192,7 +192,7 @@ describe('beforeBreadcrumb', () => {
 
   it('should store original breadcrumb and warn when hook deletes required field (message)', () => {
     // Arrange
-    const m = BreadcrumbManager.getInstance();
+    const m = BrowserBreadcrumbStore.getInstance();
 
     m.init({
       beforeBreadcrumb(bc) {
@@ -204,15 +204,15 @@ describe('beforeBreadcrumb', () => {
     });
 
     // Act
-    m.addBreadcrumb({ type: 'default', message: 'keep-me', level: 'info' });
+    m.add({ type: 'default', message: 'keep-me', level: 'info' });
 
     // Assert — fallback to original, message preserved
-    expect(m.getBreadcrumbs()[0].message).toBe('keep-me');
+    expect(m.get()[0].message).toBe('keep-me');
   });
 
   it('should filter breadcrumbs by category using hook', () => {
     // Arrange
-    const m = BreadcrumbManager.getInstance();
+    const m = BrowserBreadcrumbStore.getInstance();
 
     m.init({
       beforeBreadcrumb(bc) {
@@ -221,11 +221,11 @@ describe('beforeBreadcrumb', () => {
     });
 
     // Act
-    m.addBreadcrumb({ type: 'default', message: 'public', level: 'info', category: 'public' });
-    m.addBreadcrumb({ type: 'default', message: 'secret', level: 'info', category: 'secret' });
+    m.add({ type: 'default', message: 'public', level: 'info', category: 'public' });
+    m.add({ type: 'default', message: 'secret', level: 'info', category: 'secret' });
 
     // Assert
-    const crumbs = m.getBreadcrumbs();
+    const crumbs = m.get();
 
     expect(crumbs).toHaveLength(1);
     expect(crumbs[0].message).toBe('public');
diff --git a/packages/javascript/tests/catcher.addons.test.ts b/packages/javascript/tests/catcher.addons.test.ts
index ff8c5689..a4681e57 100644
--- a/packages/javascript/tests/catcher.addons.test.ts
+++ b/packages/javascript/tests/catcher.addons.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { BreadcrumbManager } from '../src/addons/breadcrumbs';
+import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs';
 import { wait, createTransport, getLastPayload, createCatcher } from './catcher.helpers';
 
 const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([]));
@@ -11,7 +11,7 @@ describe('Catcher', () => {
   beforeEach(() => {
     localStorage.clear();
     mockParse.mockResolvedValue([]);
-    (BreadcrumbManager as any).instance = null;
+    (BrowserBreadcrumbStore as any).instance?.destroy();
   });
 
   // ── Environment addons ────────────────────────────────────────────────────
diff --git a/packages/javascript/tests/catcher.breadcrumbs.test.ts b/packages/javascript/tests/catcher.breadcrumbs.test.ts
index 45cd450a..b0d28245 100644
--- a/packages/javascript/tests/catcher.breadcrumbs.test.ts
+++ b/packages/javascript/tests/catcher.breadcrumbs.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { BreadcrumbManager } from '../src/addons/breadcrumbs';
+import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs';
 import { wait, createTransport, getLastPayload, createCatcher } from './catcher.helpers';
 
 const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([]));
@@ -11,7 +11,7 @@ describe('Catcher', () => {
   beforeEach(() => {
     localStorage.clear();
     mockParse.mockResolvedValue([]);
-    (BreadcrumbManager as any).instance = null;
+    (BrowserBreadcrumbStore as any).instance?.destroy();
   });
 
   // ── Breadcrumbs trail ─────────────────────────────────────────────────────
diff --git a/packages/javascript/tests/catcher.context.test.ts b/packages/javascript/tests/catcher.context.test.ts
index 231b653c..5e71579f 100644
--- a/packages/javascript/tests/catcher.context.test.ts
+++ b/packages/javascript/tests/catcher.context.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { BreadcrumbManager } from '../src/addons/breadcrumbs';
+import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs';
 import { wait, createTransport, getLastPayload, createCatcher } from './catcher.helpers';
 
 const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([]));
@@ -11,7 +11,7 @@ describe('Catcher', () => {
   beforeEach(() => {
     localStorage.clear();
     mockParse.mockResolvedValue([]);
-    (BreadcrumbManager as any).instance = null;
+    (BrowserBreadcrumbStore as any).instance?.destroy();
   });
 
   // ── Context enrichment ────────────────────────────────────────────────────
diff --git a/packages/javascript/tests/catcher.global-handlers.test.ts b/packages/javascript/tests/catcher.global-handlers.test.ts
index 34c18108..b897e3e7 100644
--- a/packages/javascript/tests/catcher.global-handlers.test.ts
+++ b/packages/javascript/tests/catcher.global-handlers.test.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import Catcher from '../src/catcher';
-import { BreadcrumbManager } from '../src/addons/breadcrumbs';
+import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs';
 import { TEST_TOKEN, wait, createTransport, getLastPayload } from './catcher.helpers';
 
 const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([]));
@@ -12,7 +12,7 @@ describe('Catcher', () => {
   beforeEach(() => {
     localStorage.clear();
     mockParse.mockResolvedValue([]);
-    (BreadcrumbManager as any).instance = null;
+    (BrowserBreadcrumbStore as any).instance?.destroy();
   });
 
   // ── Global error handlers ─────────────────────────────────────────────────
diff --git a/packages/javascript/tests/catcher.message-processor.ts b/packages/javascript/tests/catcher.message-processor.ts
new file mode 100644
index 00000000..2cd25e71
--- /dev/null
+++ b/packages/javascript/tests/catcher.message-processor.ts
@@ -0,0 +1,60 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createCatcher, createTransport, getLastPayload, wait } from './catcher.helpers';
+import { MessageProcessor, ProcessingPayload } from '@hawk.so/core';
+
+const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([]));
+vi.mock('../src/modules/stackParser', () => ({
+  default: class {
+    parse = mockParse;
+  }
+}));
+
+describe('Catcher', () => {
+  describe('message processor', () => {
+    it('should send original message when processor does not modify it', async () => {
+      const { sendSpy, transport } = createTransport();
+      const applySpy = vi.fn((payload: ProcessingPayload<'errors/javascript'>) => payload);
+      const processor: MessageProcessor<'errors/javascript'> = { apply: applySpy };
+      const hawk = createCatcher(transport, { messageProcessors: [processor] });
+
+      hawk.send('original message');
+      await wait();
+
+      expect(applySpy).toHaveBeenCalledTimes(1);
+      expect(sendSpy).toHaveBeenCalledTimes(1);
+      expect(getLastPayload(sendSpy).message).toBe('original message');
+    });
+
+    it('should send modified message when processor modify it', async () => {
+      const { sendSpy, transport } = createTransport();
+      const applySpy = vi.fn((payload: ProcessingPayload<'errors/javascript'>) => {
+        return {
+          ...payload,
+          message: 'modified message',
+        };
+      });
+      const processor: MessageProcessor<'errors/javascript'> = { apply: applySpy, };
+      const hawk = createCatcher(transport, { messageProcessors: [processor], });
+
+      hawk.send('original message');
+      await wait();
+
+      expect(applySpy).toHaveBeenCalledTimes(1);
+      expect(sendSpy).toHaveBeenCalledTimes(1);
+      expect(getLastPayload(sendSpy).message).toBe('modified message');
+    });
+
+    it('should drop message when processor returns null', async () => {
+      const { sendSpy, transport } = createTransport();
+      const applySpy = vi.fn(() => null);
+      const processor: MessageProcessor<'errors/javascript'> = { apply: applySpy, };
+      const hawk = createCatcher(transport, { messageProcessors: [processor], });
+
+      hawk.send('test error');
+      await wait();
+
+      expect(applySpy).toHaveBeenCalledTimes(1);
+      expect(sendSpy).not.toHaveBeenCalled();
+    });
+  });
+});
diff --git a/packages/javascript/tests/catcher.test.ts b/packages/javascript/tests/catcher.test.ts
index 25a363a7..55046574 100644
--- a/packages/javascript/tests/catcher.test.ts
+++ b/packages/javascript/tests/catcher.test.ts
@@ -1,7 +1,7 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import Catcher from '../src/catcher';
-import { BreadcrumbManager } from '../src/addons/breadcrumbs';
-import { TEST_TOKEN, wait, createTransport, getLastPayload, createCatcher } from './catcher.helpers';
+import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs';
+import { createCatcher, createTransport, getLastPayload, TEST_TOKEN, wait } from './catcher.helpers';
 
 // StackParser is mocked to prevent real network calls to source files in the jsdom environment.
 const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([]));
@@ -17,7 +17,7 @@ describe('Catcher', () => {
   beforeEach(() => {
     localStorage.clear();
     mockParse.mockResolvedValue([]);
-    (BreadcrumbManager as any).instance = null;
+    (BrowserBreadcrumbStore as any).instance?.destroy();
   });
 
   // ── Constructor variants ──────────────────────────────────────────────────
diff --git a/packages/javascript/tests/catcher.transport.test.ts b/packages/javascript/tests/catcher.transport.test.ts
index a59f4b1e..2e7c7e3b 100644
--- a/packages/javascript/tests/catcher.transport.test.ts
+++ b/packages/javascript/tests/catcher.transport.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { BreadcrumbManager } from '../src/addons/breadcrumbs';
+import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs';
 import type { Transport } from '../src';
 import { wait, createCatcher, createTransport } from './catcher.helpers';
 
@@ -12,7 +12,7 @@ describe('Catcher', () => {
   beforeEach(() => {
     localStorage.clear();
     mockParse.mockResolvedValue([]);
-    (BreadcrumbManager as any).instance = null;
+    (BrowserBreadcrumbStore as any).instance?.destroy();
   });
 
   describe('transport failure', () => {
diff --git a/packages/javascript/tests/catcher.user.test.ts b/packages/javascript/tests/catcher.user.test.ts
index 6f2d29a8..28043ced 100644
--- a/packages/javascript/tests/catcher.user.test.ts
+++ b/packages/javascript/tests/catcher.user.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { BreadcrumbManager } from '../src/addons/breadcrumbs';
+import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs';
 import { wait, createTransport, getLastPayload, createCatcher } from './catcher.helpers';
 
 const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([]));
@@ -11,7 +11,7 @@ describe('Catcher', () => {
   beforeEach(() => {
     localStorage.clear();
     mockParse.mockResolvedValue([]);
-    (BreadcrumbManager as any).instance = null;
+    (BrowserBreadcrumbStore as any).instance?.destroy();
   });
 
   // ── User identity ─────────────────────────────────────────────────────────
diff --git a/packages/javascript/tests/messages/breadcrumbs-message-processor.test.ts b/packages/javascript/tests/messages/breadcrumbs-message-processor.test.ts
new file mode 100644
index 00000000..a7244196
--- /dev/null
+++ b/packages/javascript/tests/messages/breadcrumbs-message-processor.test.ts
@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { BreadcrumbsMessageProcessor } from '@hawk.so/core';
+import { makePayload } from './message-processor.helpers';
+
+describe('BreadcrumbsMessageProcessor', () => {
+  const processor = new BreadcrumbsMessageProcessor();
+
+  it('should attach breadcrumbs from snapshot to payload', () => {
+    const breadcrumbs = [{ message: 'click', timestamp: 1 }];
+
+    const result = processor.apply(makePayload(), { breadcrumbs });
+
+    expect(result?.breadcrumbs).toEqual(breadcrumbs);
+  });
+
+  it('should not set payload breadcrumbs when snapshot has empty array', () => {
+    const result = processor.apply(makePayload(), { breadcrumbs: [] });
+
+    expect(result?.breadcrumbs).toBeUndefined();
+  });
+
+  it('should not set payload breadcrumbs when snapshot is absent', () => {
+    const result = processor.apply(makePayload());
+
+    expect(result?.breadcrumbs).toBeUndefined();
+  });
+});
diff --git a/packages/javascript/tests/messages/browser-message-processor.test.ts b/packages/javascript/tests/messages/browser-message-processor.test.ts
new file mode 100644
index 00000000..9eff0202
--- /dev/null
+++ b/packages/javascript/tests/messages/browser-message-processor.test.ts
@@ -0,0 +1,48 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { BrowserAddonMessageProcessor } from '../../src/messages/browser-addon-message-processor';
+import { makePayload } from './message-processor.helpers';
+
+describe('BrowserMessageProcessor', () => {
+  beforeEach(() => {
+    vi.stubGlobal('location', { href: 'http://localhost/', search: '' });
+    vi.stubGlobal('navigator', { userAgent: 'test-agent' });
+    vi.stubGlobal('innerWidth', 1280);
+    vi.stubGlobal('innerHeight', 720);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('should set window dimensions, userAgent, and url', () => {
+    const result = new BrowserAddonMessageProcessor().apply(makePayload());
+
+    expect(result?.addons).toMatchObject({
+      window: { innerWidth: 1280, innerHeight: 720 },
+      userAgent: 'test-agent',
+      url: 'http://localhost/',
+    });
+  });
+
+  it('should parse GET parameters from the URL', () => {
+    vi.stubGlobal('location', { href: 'http://localhost/?foo=bar&baz=qux', search: '?foo=bar&baz=qux' });
+
+    const result = new BrowserAddonMessageProcessor().apply(makePayload());
+
+    expect(result?.addons?.get).toEqual({ foo: 'bar', baz: 'qux' });
+  });
+
+  it('should omit get when URL has no query string', () => {
+    const result = new BrowserAddonMessageProcessor().apply(makePayload());
+
+    expect(result?.addons?.get).toBeUndefined();
+  });
+
+  it('should merge with existing payload addons', () => {
+    const payload = makePayload({ addons: { consoleOutput: [{ message: 'log' }] } });
+    const result = new BrowserAddonMessageProcessor().apply(payload);
+
+    expect(result?.addons?.consoleOutput).toBeDefined();
+    expect(result?.addons?.userAgent).toBeDefined();
+  });
+});
diff --git a/packages/javascript/tests/messages/console-catcher-message-processor.test.ts b/packages/javascript/tests/messages/console-catcher-message-processor.test.ts
new file mode 100644
index 00000000..c7abea43
--- /dev/null
+++ b/packages/javascript/tests/messages/console-catcher-message-processor.test.ts
@@ -0,0 +1,28 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ConsoleOutputAddonMessageProcessor } from '../../src/messages/console-output-addon-message-processor';
+import { makePayload } from './message-processor.helpers';
+
+const makeConsoleCatcher = (logs: any[]) => ({
+  init: vi.fn(),
+  getConsoleLogStack: vi.fn().mockReturnValue(logs),
+  addErrorEvent: vi.fn(),
+});
+
+describe('ConsoleCatcherMessageProcessor', () => {
+  it('should attach console logs to payload addons', () => {
+    const logs = [{ message: 'hello', type: 'log' }];
+    const processor = new ConsoleOutputAddonMessageProcessor(makeConsoleCatcher(logs) as any);
+
+    const result = processor.apply(makePayload());
+
+    expect(result?.addons?.consoleOutput).toEqual(logs);
+  });
+
+  it('should not add consoleOutput when log stack is empty', () => {
+    const processor = new ConsoleOutputAddonMessageProcessor(makeConsoleCatcher([]) as any);
+
+    const result = processor.apply(makePayload());
+
+    expect(result?.addons?.consoleOutput).toBeUndefined();
+  });
+});
diff --git a/packages/javascript/tests/messages/debug-message-processor.test.ts b/packages/javascript/tests/messages/debug-message-processor.test.ts
new file mode 100644
index 00000000..44de960a
--- /dev/null
+++ b/packages/javascript/tests/messages/debug-message-processor.test.ts
@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { DebugAddonMessageProcessor } from '../../src/messages/debug-addon-message-processor';
+import { makePayload } from './message-processor.helpers';
+
+describe('DebugMessageProcessor', () => {
+  const processor = new DebugAddonMessageProcessor();
+
+  it('should add RAW_EVENT_DATA when hint.error is an Error instance', () => {
+    const error = new TypeError('boom');
+
+    const result = processor.apply(makePayload(), { error });
+
+    expect(result?.addons?.RAW_EVENT_DATA).toMatchObject({
+      name: 'TypeError',
+      message: 'boom',
+      stack: expect.any(String),
+    });
+  });
+
+  it('should not add RAW_EVENT_DATA when hint.error is a string', () => {
+    const result = processor.apply(makePayload(), { error: 'string reason' });
+
+    expect(result?.addons?.RAW_EVENT_DATA).toBeUndefined();
+  });
+
+  it('should not add RAW_EVENT_DATA when hint is absent', () => {
+    const result = processor.apply(makePayload());
+
+    expect(result?.addons?.RAW_EVENT_DATA).toBeUndefined();
+  });
+});
diff --git a/packages/javascript/tests/messages/message-processor.helpers.ts b/packages/javascript/tests/messages/message-processor.helpers.ts
new file mode 100644
index 00000000..7e401687
--- /dev/null
+++ b/packages/javascript/tests/messages/message-processor.helpers.ts
@@ -0,0 +1,7 @@
+import type { ProcessingPayload } from '@hawk.so/core';
+
+export function makePayload(
+  overrides: Partial<ProcessingPayload<'errors/javascript'>> = {}
+): ProcessingPayload<'errors/javascript'> {
+  return { title: 'Test error', catcherVersion: '0.0.0', addons: {}, ...overrides };
+}
\ No newline at end of file