@dexto/core 1.2.6 → 1.4.0

package/dist/session/history/database.js

@@ -1,48 +1,59 @@
-import "../../chunk-C6A6W6XS.js";
+import "../../chunk-PTJYTZNU.js";
 import { DextoLogComponent } from "../../logger/v2/types.js";
 import { SessionError } from "../errors.js";
 class DatabaseHistoryProvider {
+  // Debounce window for batching updates
   constructor(sessionId, database, logger) {
     this.sessionId = sessionId;
     this.database = database;
     this.logger = logger.createChild(DextoLogComponent.SESSION);
   }
   logger;
+  // Cache state
+  cache = null;
+  dirty = false;
+  flushTimer = null;
+  flushPromise = null;
+  // Flush configuration
+  static FLUSH_DELAY_MS = 100;
   async getHistory() {
-    const key = this.getMessagesKey();
-    try {
-      const messages = await this.database.getRange(key, 0, 1e3);
-      this.logger.debug(
-        `DatabaseHistoryProvider: Retrieved ${messages.length} messages for session ${this.sessionId}`
-      );
-      return messages;
-    } catch (error) {
-      this.logger.error(
-        `DatabaseHistoryProvider: Error retrieving messages for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return [];
+    if (this.cache === null) {
+      const key = this.getMessagesKey();
+      try {
+        this.cache = await this.database.getRange(key, 0, 1e4);
+        this.logger.debug(
+          `DatabaseHistoryProvider: Loaded ${this.cache.length} messages from DB for session ${this.sessionId}`
+        );
+      } catch (error) {
+        this.logger.error(
+          `DatabaseHistoryProvider: Error loading messages for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        throw SessionError.storageFailed(
+          this.sessionId,
+          "load history",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
     }
+    return [...this.cache];
   }
   async saveMessage(message) {
     const key = this.getMessagesKey();
+    if (this.cache === null) {
+      await this.getHistory();
+    }
+    this.cache.push(message);
     try {
       await this.database.append(key, message);
-      let contentPreview = "[no content]";
-      if (message.content) {
-        if (typeof message.content === "string") {
-          contentPreview = message.content.length > 100 ? `${message.content.substring(0, 100)}...` : message.content;
-        } else if (Array.isArray(message.content)) {
-          contentPreview = `[${message.content.length} parts]`;
-        }
-      }
       this.logger.debug(
         `DatabaseHistoryProvider: Saved message for session ${this.sessionId}`,
         {
           role: message.role,
-          content: contentPreview
+          id: message.id
         }
       );
     } catch (error) {
+      this.cache.pop();
       this.logger.error(
         `DatabaseHistoryProvider: Error saving message for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
       );
@@ -53,7 +64,34 @@ class DatabaseHistoryProvider {
       );
     }
   }
+  async updateMessage(message) {
+    if (!message.id) {
+      this.logger.warn(
+        `DatabaseHistoryProvider: Ignoring update for message without id in session ${this.sessionId}`
+      );
+      return;
+    }
+    if (this.cache === null) {
+      await this.getHistory();
+    }
+    const index = this.cache.findIndex((m) => m.id === message.id);
+    if (index !== -1) {
+      this.cache[index] = message;
+      this.dirty = true;
+      this.scheduleFlush();
+      this.logger.debug(
+        `DatabaseHistoryProvider: Updated message ${message.id} in cache for session ${this.sessionId}`
+      );
+    } else {
+      this.logger.warn(
+        `DatabaseHistoryProvider: Message ${message.id} not found for update in session ${this.sessionId}`
+      );
+    }
+  }
   async clearHistory() {
+    this.cancelPendingFlush();
+    this.cache = [];
+    this.dirty = false;
     const key = this.getMessagesKey();
     try {
       await this.database.delete(key);
@@ -70,6 +108,81 @@ class DatabaseHistoryProvider {
       );
     }
   }
+  /**
+   * Flush any pending updates to the database.
+   * Should be called at turn boundaries to ensure durability.
+   */
+  async flush() {
+    if (this.flushPromise) {
+      await this.flushPromise;
+      return;
+    }
+    this.cancelPendingFlush();
+    if (!this.dirty || !this.cache) {
+      return;
+    }
+    this.flushPromise = this.doFlush();
+    try {
+      await this.flushPromise;
+    } finally {
+      this.flushPromise = null;
+    }
+  }
+  /**
+   * Internal flush implementation.
+   * Writes entire cache to DB (delete + re-append all).
+   */
+  async doFlush() {
+    if (!this.dirty || !this.cache) {
+      return;
+    }
+    const key = this.getMessagesKey();
+    const messageCount = this.cache.length;
+    try {
+      await this.database.delete(key);
+      for (const msg of this.cache) {
+        await this.database.append(key, msg);
+      }
+      if (!this.flushTimer) {
+        this.dirty = false;
+      }
+      this.logger.debug(
+        `DatabaseHistoryProvider: Flushed ${messageCount} messages to DB for session ${this.sessionId}`
+      );
+    } catch (error) {
+      this.logger.error(
+        `DatabaseHistoryProvider: Error flushing messages for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw SessionError.storageFailed(
+        this.sessionId,
+        "flush messages",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Schedule a debounced flush.
+   * Batches rapid updateMessage() calls into a single DB write.
+   */
+  scheduleFlush() {
+    if (this.flushTimer) {
+      return;
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      this.doFlush().catch(() => {
+      });
+    }, DatabaseHistoryProvider.FLUSH_DELAY_MS);
+  }
+  /**
+   * Cancel any pending scheduled flush.
+   */
+  cancelPendingFlush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
   getMessagesKey() {
     return `messages:${this.sessionId}`;
   }

package/dist/session/history/factory.js

@@ -1,4 +1,4 @@
-import "../../chunk-C6A6W6XS.js";
+import "../../chunk-PTJYTZNU.js";
 import { DatabaseHistoryProvider } from "./database.js";
 function createDatabaseHistoryProvider(database, sessionId, logger) {
   return new DatabaseHistoryProvider(sessionId, database, logger);

package/dist/session/history/memory.cjs

@@ -22,6 +22,9 @@ __export(memory_exports, {
 });
 module.exports = __toCommonJS(memory_exports);
 class MemoryHistoryProvider {
+  constructor(logger) {
+    this.logger = logger;
+  }
   messages = [];
   async getHistory() {
     return [...this.messages];
@@ -29,9 +32,24 @@ class MemoryHistoryProvider {
   async saveMessage(message) {
     this.messages.push(message);
   }
+  async updateMessage(message) {
+    if (!message.id) {
+      this.logger.warn("MemoryHistoryProvider: Ignoring update for message without id");
+      return;
+    }
+    const index = this.messages.findIndex((m) => m.id === message.id);
+    if (index !== -1) {
+      this.messages[index] = message;
+    }
+  }
   async clearHistory() {
     this.messages = [];
   }
+  /**
+   * No-op for in-memory provider - all operations are already "flushed".
+   */
+  async flush() {
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/session/history/memory.d.ts

@@ -1,14 +1,22 @@
 import type { InternalMessage } from '../../context/types.js';
 import type { IConversationHistoryProvider } from './types.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
 /**
  * Lightweight in-memory history provider for ephemeral, isolated LLM calls.
  * Used to run background tasks (e.g., title generation) without touching
  * the real session history or emitting history-related side effects.
  */
 export declare class MemoryHistoryProvider implements IConversationHistoryProvider {
+    private logger;
     private messages;
+    constructor(logger: IDextoLogger);
     getHistory(): Promise<InternalMessage[]>;
     saveMessage(message: InternalMessage): Promise<void>;
+    updateMessage(message: InternalMessage): Promise<void>;
     clearHistory(): Promise<void>;
+    /**
+     * No-op for in-memory provider - all operations are already "flushed".
+     */
+    flush(): Promise<void>;
 }
 //# sourceMappingURL=memory.d.ts.map

package/dist/session/history/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/session/history/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAE/D;;;;GAIG;AACH,qBAAa,qBAAsB,YAAW,4BAA4B;IACtE,OAAO,CAAC,QAAQ,CAAyB;IAEnC,UAAU,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAKxC,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpD,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;CAGtC"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/session/history/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;GAIG;AACH,qBAAa,qBAAsB,YAAW,4BAA4B;IAG1D,OAAO,CAAC,MAAM;IAF1B,OAAO,CAAC,QAAQ,CAAyB;gBAErB,MAAM,EAAE,YAAY;IAElC,UAAU,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAKxC,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpD,aAAa,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAYtD,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAInC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}

package/dist/session/history/memory.js

@@ -1,5 +1,8 @@
-import "../../chunk-C6A6W6XS.js";
+import "../../chunk-PTJYTZNU.js";
 class MemoryHistoryProvider {
+  constructor(logger) {
+    this.logger = logger;
+  }
   messages = [];
   async getHistory() {
     return [...this.messages];
@@ -7,9 +10,24 @@ class MemoryHistoryProvider {
   async saveMessage(message) {
     this.messages.push(message);
   }
+  async updateMessage(message) {
+    if (!message.id) {
+      this.logger.warn("MemoryHistoryProvider: Ignoring update for message without id");
+      return;
+    }
+    const index = this.messages.findIndex((m) => m.id === message.id);
+    if (index !== -1) {
+      this.messages[index] = message;
+    }
+  }
   async clearHistory() {
     this.messages = [];
   }
+  /**
+   * No-op for in-memory provider - all operations are already "flushed".
+   */
+  async flush() {
+  }
 }
 export {
   MemoryHistoryProvider

package/dist/session/history/types.d.ts

@@ -2,13 +2,25 @@ import type { InternalMessage } from '../../context/types.js';
 /**
  * Session-scoped conversation history provider.
  * Each instance is tied to a specific session and manages only that session's messages.
+ *
+ * Implementations may use caching to optimize read performance. If caching is used,
+ * the flush() method should be called at turn boundaries to ensure all updates
+ * are persisted to durable storage.
  */
 export interface IConversationHistoryProvider {
     /** Load the full message history for this session */
     getHistory(): Promise<InternalMessage[]>;
-    /** Append a message to this session's history */
+    /** Append a message to this session's history (must be durable immediately) */
     saveMessage(message: InternalMessage): Promise<void>;
+    /** Update an existing message in this session's history (may be cached/batched) */
+    updateMessage(message: InternalMessage): Promise<void>;
     /** Clear all messages for this session */
     clearHistory(): Promise<void>;
+    /**
+     * Flush any pending updates to durable storage.
+     * Called at turn boundaries to ensure data durability.
+     * Implementations without caching can make this a no-op.
+     */
+    flush(): Promise<void>;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/session/history/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/session/history/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;;GAGG;AACH,MAAM,WAAW,4BAA4B;IACzC,qDAAqD;IACrD,UAAU,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IAEzC,iDAAiD;IACjD,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAErD,0CAA0C;IAC1C,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/session/history/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;;;;;;GAOG;AACH,MAAM,WAAW,4BAA4B;IACzC,qDAAqD;IACrD,UAAU,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IAEzC,+EAA+E;IAC/E,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAErD,mFAAmF;IACnF,aAAa,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvD,0CAA0C;IAC1C,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9B;;;;OAIG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B"}

package/dist/session/index.cjs

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var session_exports = {};
 __export(session_exports, {
   ChatSession: () => import_chat_session.ChatSession,
+  MessageQueueService: () => import_message_queue.MessageQueueService,
   SessionError: () => import_errors.SessionError,
   SessionErrorCode: () => import_error_codes.SessionErrorCode,
   SessionManager: () => import_session_manager.SessionManager
@@ -28,9 +29,11 @@ var import_chat_session = require("./chat-session.js");
 var import_session_manager = require("./session-manager.js");
 var import_error_codes = require("./error-codes.js");
 var import_errors = require("./errors.js");
+var import_message_queue = require("./message-queue.js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ChatSession,
+  MessageQueueService,
   SessionError,
   SessionErrorCode,
   SessionManager

package/dist/session/index.d.ts

@@ -3,4 +3,7 @@ export { SessionManager } from './session-manager.js';
 export type { SessionMetadata } from './session-manager.js';
 export { SessionErrorCode } from './error-codes.js';
 export { SessionError } from './errors.js';
+export { MessageQueueService } from './message-queue.js';
+export type { UserMessageInput } from './message-queue.js';
+export type { QueuedMessage, CoalescedMessage } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/session/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/session/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/session/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC"}

package/dist/session/index.js

@@ -1,10 +1,12 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 import { ChatSession } from "./chat-session.js";
 import { SessionManager } from "./session-manager.js";
 import { SessionErrorCode } from "./error-codes.js";
 import { SessionError } from "./errors.js";
+import { MessageQueueService } from "./message-queue.js";
 export {
   ChatSession,
+  MessageQueueService,
   SessionError,
   SessionErrorCode,
   SessionManager

package/dist/session/message-queue.cjs

@@ -0,0 +1,201 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var message_queue_exports = {};
+__export(message_queue_exports, {
+  MessageQueueService: () => MessageQueueService
+});
+module.exports = __toCommonJS(message_queue_exports);
+function generateId() {
+  return `msg_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+class MessageQueueService {
+  constructor(eventBus, logger) {
+    this.eventBus = eventBus;
+    this.logger = logger;
+  }
+  queue = [];
+  /**
+   * Add a message to the queue.
+   * Called by API endpoint - returns immediately with queue position.
+   *
+   * @param message The user message to queue
+   * @returns Queue position and message ID
+   */
+  enqueue(message) {
+    const queuedMsg = {
+      id: generateId(),
+      content: message.content,
+      queuedAt: Date.now(),
+      ...message.metadata !== void 0 && { metadata: message.metadata }
+    };
+    this.queue.push(queuedMsg);
+    this.logger.debug(`Message queued: ${queuedMsg.id}, position: ${this.queue.length}`);
+    this.eventBus.emit("message:queued", {
+      position: this.queue.length,
+      id: queuedMsg.id
+    });
+    return {
+      queued: true,
+      position: this.queue.length,
+      id: queuedMsg.id
+    };
+  }
+  /**
+   * Dequeue ALL pending messages and coalesce into single injection.
+   * Called by executor between steps.
+   *
+   * Multiple queued messages become ONE combined message to the LLM.
+   *
+   * @example
+   * If 3 messages are queued: "stop", "try X instead", "also check Y"
+   * They become:
+   * ```
+   * [1]: stop
+   *
+   * [2]: try X instead
+   *
+   * [3]: also check Y
+   * ```
+   *
+   * @returns Coalesced message or null if queue is empty
+   */
+  dequeueAll() {
+    if (this.queue.length === 0) return null;
+    const messages = [...this.queue];
+    this.queue = [];
+    const combined = this.coalesce(messages);
+    this.logger.debug(
+      `Dequeued ${messages.length} message(s): ${messages.map((m) => m.id).join(", ")}`
+    );
+    this.eventBus.emit("message:dequeued", {
+      count: messages.length,
+      ids: messages.map((m) => m.id),
+      coalesced: messages.length > 1,
+      content: combined.combinedContent
+    });
+    return combined;
+  }
+  /**
+   * Coalesce multiple messages into one (multimodal-aware).
+   * Strategy: Combine with numbered separators, preserve all media.
+   */
+  coalesce(messages) {
+    if (messages.length === 1) {
+      const firstMsg = messages[0];
+      if (!firstMsg) {
+        throw new Error("Unexpected empty messages array");
+      }
+      return {
+        messages,
+        combinedContent: firstMsg.content,
+        firstQueuedAt: firstMsg.queuedAt,
+        lastQueuedAt: firstMsg.queuedAt
+      };
+    }
+    const combinedContent = [];
+    for (const [i, msg] of messages.entries()) {
+      const prefix = messages.length === 2 ? i === 0 ? "First" : "Also" : `[${i + 1}]`;
+      let prefixText = `${prefix}: `;
+      for (const part of msg.content) {
+        if (part.type === "text") {
+          if (prefixText) {
+            combinedContent.push({ type: "text", text: prefixText + part.text });
+            prefixText = "";
+          } else {
+            combinedContent.push(part);
+          }
+        } else {
+          if (prefixText) {
+            combinedContent.push({ type: "text", text: prefixText });
+            prefixText = "";
+          }
+          combinedContent.push(part);
+        }
+      }
+      if (prefixText && msg.content.length === 0) {
+        combinedContent.push({ type: "text", text: prefixText + "[empty message]" });
+      }
+      if (i < messages.length - 1) {
+        combinedContent.push({ type: "text", text: "\n\n" });
+      }
+    }
+    const firstMessage = messages[0];
+    const lastMessage = messages[messages.length - 1];
+    if (!firstMessage || !lastMessage) {
+      throw new Error("Unexpected undefined message in non-empty array");
+    }
+    return {
+      messages,
+      combinedContent,
+      firstQueuedAt: firstMessage.queuedAt,
+      lastQueuedAt: lastMessage.queuedAt
+    };
+  }
+  /**
+   * Check if there are pending messages in the queue.
+   */
+  hasPending() {
+    return this.queue.length > 0;
+  }
+  /**
+   * Get the number of pending messages.
+   */
+  pendingCount() {
+    return this.queue.length;
+  }
+  /**
+   * Clear all pending messages without processing.
+   * Used during cleanup/abort.
+   */
+  clear() {
+    this.queue = [];
+  }
+  /**
+   * Get all queued messages (for UI display).
+   * Returns a shallow copy to prevent external mutation.
+   */
+  getAll() {
+    return [...this.queue];
+  }
+  /**
+   * Get a single queued message by ID.
+   */
+  get(id) {
+    return this.queue.find((m) => m.id === id);
+  }
+  /**
+   * Remove a single queued message by ID.
+   * @returns true if message was found and removed; false otherwise
+   */
+  remove(id) {
+    const index = this.queue.findIndex((m) => m.id === id);
+    if (index === -1) {
+      this.logger.debug(`Remove failed: message ${id} not found in queue`);
+      return false;
+    }
+    this.queue.splice(index, 1);
+    this.logger.debug(`Message removed: ${id}, remaining: ${this.queue.length}`);
+    this.eventBus.emit("message:removed", { id });
+    return true;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MessageQueueService
+});