@fedify/sqlite 2.0.0-dev.215 → 2.0.0-dev.226

package/deno.json

@@ -1,10 +1,11 @@
 {
   "name": "@fedify/sqlite",
-  "version": "2.0.0-dev.215+84aa16bb",
+  "version": "2.0.0-dev.226+c28b813d",
   "license": "MIT",
   "exports": {
     ".": "./src/mod.ts",
-    "./kv": "./src/kv.ts"
+    "./kv": "./src/kv.ts",
+    "./mq": "./src/mq.ts"
   },
   "imports": {
     "#sqlite": "./src/sqlite.node.ts"
@@ -22,6 +23,6 @@
   },
   "tasks": {
     "check": "deno fmt --check && deno lint && deno check",
-    "test": "deno test --allow-net --allow-env --doc --no-check=leaks"
+    "test": "deno test --allow-net --allow-env --allow-read --allow-write --doc --no-check=leaks"
   }
 }

package/dist/dist/sqlite.node.d.cts

@@ -0,0 +1,2 @@
+import { DatabaseSync } from "node:sqlite";
+export { DatabaseSync };

package/dist/kv.d.cts

@@ -1,4 +1,4 @@
-import { PlatformDatabase } from "#sqlite";
+import { DatabaseSync } from "./dist/sqlite.node.cjs";
 import { KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions } from "@fedify/fedify";
 
 //#region src/kv.d.ts
@@ -37,14 +37,14 @@ interface SqliteKvStoreOptions {
  */
 declare class SqliteKvStore implements KvStore {
   #private;
-  readonly db: PlatformDatabase;
+  readonly db: DatabaseSync;
   readonly options: SqliteKvStoreOptions;
   /**
    * Creates a new SQLite key–value store.
    * @param db The SQLite database to use. Supports `node:sqlite` and `bun:sqlite`.
    * @param options The options for the key–value store.
    */
-  constructor(db: PlatformDatabase, options?: SqliteKvStoreOptions);
+  constructor(db: DatabaseSync, options?: SqliteKvStoreOptions);
   /**
    * {@inheritDoc KvStore.get}
    */

package/dist/mod.cjs

@@ -2,5 +2,7 @@
         const { Temporal } = require("@js-temporal/polyfill");
       
 const require_kv = require('./kv.cjs');
+const require_mq = require('./mq.cjs');
 
-exports.SqliteKvStore = require_kv.SqliteKvStore;
+exports.SqliteKvStore = require_kv.SqliteKvStore;
+exports.SqliteMessageQueue = require_mq.SqliteMessageQueue;

package/dist/mod.d.cts

@@ -1,2 +1,3 @@
 import { SqliteKvStore } from "./kv.cjs";
-export { SqliteKvStore };
+import { SqliteMessageQueue } from "./mq.cjs";
+export { SqliteKvStore, SqliteMessageQueue };

package/dist/mod.d.ts

@@ -1,3 +1,4 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { SqliteKvStore } from "./kv.js";
-export { SqliteKvStore };
+import { SqliteMessageQueue } from "./mq.js";
+export { SqliteKvStore, SqliteMessageQueue };

package/dist/mod.js

@@ -2,5 +2,6 @@
         import { Temporal } from "@js-temporal/polyfill";
       
 import { SqliteKvStore } from "./kv.js";
+import { SqliteMessageQueue } from "./mq.js";
 
-export { SqliteKvStore };
+export { SqliteKvStore, SqliteMessageQueue };

package/dist/mq.cjs

@@ -0,0 +1,369 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const __sqlite = require_rolldown_runtime.__toESM(require("#sqlite"));
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+
+//#region src/mq.ts
+const logger = (0, __logtape_logtape.getLogger)([
+	"fedify",
+	"sqlite",
+	"mq"
+]);
+var EnqueueEvent = class extends Event {
+	delayMs;
+	constructor(delayMs) {
+		super("enqueue");
+		this.delayMs = delayMs;
+	}
+};
+/**
+* A message queue that uses SQLite as the underlying storage.
+*
+* This implementation is designed for single-node deployments and uses
+* polling to check for new messages. It is not suitable for high-throughput
+* scenarios or distributed environments.
+*
+* @example
+* ```ts ignore
+* import { createFederation } from "@fedify/fedify";
+* import { SqliteMessageQueue } from "@fedify/sqlite";
+* import { DatabaseSync } from "node:sqlite";
+*
+* const db = new DatabaseSync(":memory:");
+* const federation = createFederation({
+*   // ...
+*   queue: new SqliteMessageQueue(db),
+* });
+* ```
+*/
+var SqliteMessageQueue = class SqliteMessageQueue {
+	static #defaultTableName = "fedify_message";
+	static #tableNameRegex = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+	static #notifyChannels = /* @__PURE__ */ new Map();
+	static #activeInstances = /* @__PURE__ */ new Map();
+	static #getNotifyChannel(tableName) {
+		let channel = SqliteMessageQueue.#notifyChannels.get(tableName);
+		if (channel == null) {
+			channel = new EventTarget();
+			SqliteMessageQueue.#notifyChannels.set(tableName, channel);
+		}
+		return channel;
+	}
+	#db;
+	#tableName;
+	#pollIntervalMs;
+	#instanceId;
+	#maxRetries;
+	#retryDelayMs;
+	#journalMode;
+	#initialized;
+	/**
+	* SQLite message queue does not provide native retry mechanisms.
+	*/
+	nativeRetrial = false;
+	/**
+	* Creates a new SQLite message queue.
+	* @param db The SQLite database to use. Supports `node:sqlite`, `bun:sqlite`.
+	* @param options The options for the message queue.
+	*/
+	constructor(db, options = {}) {
+		this.db = db;
+		this.options = options;
+		this.#db = new __sqlite.SqliteDatabase(db);
+		this.#initialized = options.initialized ?? false;
+		this.#tableName = options.tableName ?? SqliteMessageQueue.#defaultTableName;
+		this.#instanceId = crypto.randomUUID();
+		this.#pollIntervalMs = Temporal.Duration.from(options.pollInterval ?? { seconds: 5 }).total("millisecond");
+		this.#maxRetries = options.maxRetries ?? 5;
+		this.#retryDelayMs = options.retryDelayMs ?? 100;
+		this.#journalMode = options.journalMode ?? "WAL";
+		if (!SqliteMessageQueue.#tableNameRegex.test(this.#tableName)) throw new Error(`Invalid table name for the message queue: ${this.#tableName}.\
+ Only letters, digits, and underscores are allowed.`);
+		this.#registerInstance();
+	}
+	#registerInstance() {
+		let instances = SqliteMessageQueue.#activeInstances.get(this.#tableName);
+		if (instances == null) {
+			instances = /* @__PURE__ */ new Set();
+			SqliteMessageQueue.#activeInstances.set(this.#tableName, instances);
+		}
+		instances.add(this.#instanceId);
+	}
+	/**
+	* {@inheritDoc MessageQueue.enqueue}
+	*/
+	enqueue(message, options) {
+		this.initialize();
+		const id = crypto.randomUUID();
+		const encodedMessage = this.#encodeMessage(message);
+		const now = Temporal.Now.instant().epochMilliseconds;
+		const delay = options?.delay ?? Temporal.Duration.from({ seconds: 0 });
+		const scheduled = now + delay.total({ unit: "milliseconds" });
+		if (options?.delay) logger.debug("Enqueuing a message with a delay of {delay}...", {
+			delay,
+			message
+		});
+		else logger.debug("Enqueuing a message...", { message });
+		return this.#retryOnBusy(() => {
+			this.#db.prepare(`INSERT INTO "${this.#tableName}" (id, message, created, scheduled)
+          VALUES (?, ?, ?, ?)`).run(id, encodedMessage, now, scheduled);
+			logger.debug("Enqueued a message.", { message });
+			const delayMs = delay.total("millisecond");
+			SqliteMessageQueue.#getNotifyChannel(this.#tableName).dispatchEvent(new EnqueueEvent(delayMs));
+		});
+	}
+	/**
+	* {@inheritDoc MessageQueue.enqueueMany}
+	*/
+	enqueueMany(messages, options) {
+		if (messages.length === 0) return Promise.resolve();
+		this.initialize();
+		const now = Temporal.Now.instant().epochMilliseconds;
+		const delay = options?.delay ?? Temporal.Duration.from({ seconds: 0 });
+		const scheduled = now + delay.total({ unit: "milliseconds" });
+		if (options?.delay) logger.debug("Enqueuing messages with a delay of {delay}...", {
+			delay,
+			messages
+		});
+		else logger.debug("Enqueuing messages...", { messages });
+		return this.#withTransactionRetries(() => {
+			const stmt = this.#db.prepare(`INSERT INTO "${this.#tableName}" (id, message, created, scheduled)
+        VALUES (?, ?, ?, ?)`);
+			for (const message of messages) {
+				const id = crypto.randomUUID();
+				const encodedMessage = this.#encodeMessage(message);
+				stmt.run(id, encodedMessage, now, scheduled);
+			}
+			logger.debug("Enqueued messages.", { messages });
+			const delayMs = delay.total("millisecond");
+			SqliteMessageQueue.#getNotifyChannel(this.#tableName).dispatchEvent(new EnqueueEvent(delayMs));
+		}).catch((error) => {
+			logger.error("Failed to enqueue messages to table {tableName}: {error}", {
+				tableName: this.#tableName,
+				messageCount: messages.length,
+				error
+			});
+			throw error;
+		});
+	}
+	/**
+	* {@inheritDoc MessageQueue.listen}
+	*/
+	async listen(handler, options) {
+		this.initialize();
+		const { signal } = options ?? {};
+		logger.debug("Starting to listen for messages on table {tableName}...", { tableName: this.#tableName });
+		const channel = SqliteMessageQueue.#getNotifyChannel(this.#tableName);
+		const timeouts = /* @__PURE__ */ new Set();
+		const poll = async () => {
+			while (signal == null || !signal.aborted) {
+				const now = Temporal.Now.instant().epochMilliseconds;
+				const result = await this.#withTransactionRetries(() => {
+					return this.#db.prepare(`DELETE FROM "${this.#tableName}"
+              WHERE id = (
+                SELECT id FROM "${this.#tableName}"
+                WHERE scheduled <= ?
+                ORDER BY scheduled
+                LIMIT 1
+              )
+              RETURNING id, message`).get(now);
+				});
+				if (result) {
+					const message = this.#decodeMessage(result.message);
+					logger.debug("Processing message {id}...", {
+						id: result.id,
+						message
+					});
+					try {
+						await handler(message);
+						logger.debug("Processed message {id}.", { id: result.id });
+					} catch (error) {
+						logger.error("Failed to process message {id} from table {tableName}: {error}", {
+							id: result.id,
+							tableName: this.#tableName,
+							message,
+							error
+						});
+					}
+					continue;
+				}
+				break;
+			}
+		};
+		const onEnqueue = (event) => {
+			const delayMs = event.delayMs;
+			if (delayMs < 1) poll();
+			else timeouts.add(setTimeout(poll, delayMs));
+		};
+		channel.addEventListener("enqueue", onEnqueue);
+		signal?.addEventListener("abort", () => {
+			channel.removeEventListener("enqueue", onEnqueue);
+			for (const timeout of timeouts) clearTimeout(timeout);
+		});
+		await poll();
+		while (signal == null || !signal.aborted) {
+			let timeout;
+			await new Promise((resolve) => {
+				const onAbort = () => {
+					signal?.removeEventListener("abort", onAbort);
+					resolve(void 0);
+				};
+				signal?.addEventListener("abort", onAbort);
+				timeout = setTimeout(() => {
+					signal?.removeEventListener("abort", onAbort);
+					resolve(0);
+				}, this.#pollIntervalMs);
+				timeouts.add(timeout);
+			});
+			if (timeout != null) timeouts.delete(timeout);
+			await poll();
+		}
+		logger.debug("Stopped listening for messages on table {tableName}.", { tableName: this.#tableName });
+	}
+	/**
+	* Creates the message queue table if it does not already exist.
+	* Does nothing if the table already exists.
+	*
+	* This method also configures the SQLite journal mode for better concurrency.
+	* WAL (Write-Ahead Logging) mode is enabled by default to improve
+	* concurrent access in multi-process environments.
+	*/
+	initialize() {
+		if (this.#initialized) return;
+		logger.debug("Initializing the message queue table {tableName}...", { tableName: this.#tableName });
+		this.#db.exec(`PRAGMA journal_mode=${this.#journalMode}`);
+		this.#withTransaction(() => {
+			this.#db.exec(`
+        CREATE TABLE IF NOT EXISTS "${this.#tableName}" (
+          id TEXT PRIMARY KEY,
+          message TEXT NOT NULL,
+          created INTEGER NOT NULL,
+          scheduled INTEGER NOT NULL
+        )
+      `);
+			this.#db.exec(`
+        CREATE INDEX IF NOT EXISTS "idx_${this.#tableName}_scheduled"
+        ON "${this.#tableName}" (scheduled)
+      `);
+		});
+		this.#initialized = true;
+		logger.debug("Initialized the message queue table {tableName}.", { tableName: this.#tableName });
+	}
+	/**
+	* Drops the table used by the message queue.  Does nothing if the table
+	* does not exist.
+	*/
+	drop() {
+		this.#db.exec(`DROP TABLE IF EXISTS "${this.#tableName}"`);
+		this.#initialized = false;
+	}
+	/**
+	* Closes the database connection.
+	*/
+	[Symbol.dispose]() {
+		try {
+			this.#db.close();
+			this.#unregisterInstance();
+		} catch (error) {
+			logger.error("Failed to close the database connection for table {tableName}: {error}", {
+				tableName: this.#tableName,
+				error
+			});
+		}
+	}
+	#unregisterInstance() {
+		const instances = SqliteMessageQueue.#activeInstances.get(this.#tableName);
+		if (instances == null) return;
+		instances.delete(this.#instanceId);
+		if (instances.size === 0) {
+			SqliteMessageQueue.#activeInstances.delete(this.#tableName);
+			SqliteMessageQueue.#notifyChannels.delete(this.#tableName);
+		}
+	}
+	/**
+	* Checks if an error is a SQLITE_BUSY error or transaction conflict.
+	* Handles different error formats from node:sqlite and bun:sqlite.
+	*/
+	#isBusyError(error) {
+		if (!(error instanceof Error)) return false;
+		if (error.message.includes("SQLITE_BUSY") || error.message.includes("database is locked") || error.message.includes("transaction within a transaction")) return true;
+		const errorWithCode = error;
+		if (errorWithCode.code === "SQLITE_BUSY") return true;
+		const errorWithErrno = error;
+		if (errorWithErrno.errno === 5) return true;
+		return false;
+	}
+	/**
+	* Retries a database operation with exponential backoff on SQLITE_BUSY errors.
+	*/
+	async #retryOnBusy(operation) {
+		let lastError;
+		for (let attempt = 0; attempt <= this.#maxRetries; attempt++) try {
+			return operation();
+		} catch (error) {
+			lastError = error;
+			if (!this.#isBusyError(error)) {
+				logger.error("Database operation failed on table {tableName}: {error}", {
+					tableName: this.#tableName,
+					error
+				});
+				throw error;
+			}
+			if (attempt === this.#maxRetries) {
+				logger.error("Max retries ({maxRetries}) reached for SQLITE_BUSY error on table {tableName}.", {
+					maxRetries: this.#maxRetries,
+					tableName: this.#tableName,
+					error
+				});
+				throw error;
+			}
+			const delayMs = this.#retryDelayMs * Math.pow(2, attempt);
+			logger.debug("SQLITE_BUSY error on table {tableName}, retrying in {delayMs}ms (attempt {attempt}/{maxRetries})...", {
+				tableName: this.#tableName,
+				delayMs,
+				attempt: attempt + 1,
+				maxRetries: this.#maxRetries
+			});
+			await new Promise((resolve) => setTimeout(resolve, delayMs));
+		}
+		throw lastError;
+	}
+	/**
+	* Executes a database operation within a transaction.
+	* Automatically handles BEGIN IMMEDIATE, COMMIT, and ROLLBACK.
+	*/
+	#withTransaction(operation) {
+		let transactionStarted = false;
+		try {
+			this.#db.exec("BEGIN IMMEDIATE");
+			transactionStarted = true;
+			const result = operation();
+			this.#db.exec("COMMIT");
+			return result;
+		} catch (error) {
+			if (transactionStarted) try {
+				this.#db.exec("ROLLBACK");
+			} catch {}
+			throw error;
+		}
+	}
+	/**
+	* Executes a database operation within a transaction with retry logic.
+	* Automatically handles BEGIN IMMEDIATE, COMMIT, and ROLLBACK.
+	* Retries on SQLITE_BUSY errors with exponential backoff.
+	*/
+	async #withTransactionRetries(operation) {
+		return await this.#retryOnBusy(() => this.#withTransaction(operation));
+	}
+	#encodeMessage(message) {
+		return JSON.stringify(message);
+	}
+	#decodeMessage(message) {
+		return JSON.parse(message);
+	}
+};
+
+//#endregion
+exports.SqliteMessageQueue = SqliteMessageQueue;

package/dist/mq.d.cts

@@ -0,0 +1,112 @@
+import { DatabaseSync } from "./dist/sqlite.node.cjs";
+import { MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify";
+
+//#region src/mq.d.ts
+/**
+ * Options for the SQLite message queue.
+ */
+interface SqliteMessageQueueOptions {
+  /**
+   * The table name to use for the message queue.
+   * Only letters, digits, and underscores are allowed.
+   * `"fedify_message"` by default.
+   * @default `"fedify_message"`
+   */
+  tableName?: string;
+  /**
+   * Whether the table has been initialized.  `false` by default.
+   * @default `false`
+   */
+  initialized?: boolean;
+  /**
+   * The poll interval for the message queue.
+   * @default `{ seconds: 5 }`
+   */
+  pollInterval?: Temporal.Duration | Temporal.DurationLike;
+  /**
+   * Maximum number of retries for SQLITE_BUSY errors.
+   * @default `5`
+   */
+  maxRetries?: number;
+  /**
+   * Initial retry delay in milliseconds for SQLITE_BUSY errors.
+   * Uses exponential backoff.
+   * @default `100`
+   */
+  retryDelayMs?: number;
+  /**
+   * SQLite journal mode to use.
+   * WAL (Write-Ahead Logging) mode is recommended for better concurrency
+   * in multi-process environments.
+   * Note: WAL mode is persistent per database file, not per connection.
+   * @default `"WAL"`
+   */
+  journalMode?: "WAL" | "DELETE" | "TRUNCATE" | "PERSIST" | "MEMORY";
+}
+/**
+ * A message queue that uses SQLite as the underlying storage.
+ *
+ * This implementation is designed for single-node deployments and uses
+ * polling to check for new messages. It is not suitable for high-throughput
+ * scenarios or distributed environments.
+ *
+ * @example
+ * ```ts ignore
+ * import { createFederation } from "@fedify/fedify";
+ * import { SqliteMessageQueue } from "@fedify/sqlite";
+ * import { DatabaseSync } from "node:sqlite";
+ *
+ * const db = new DatabaseSync(":memory:");
+ * const federation = createFederation({
+ *   // ...
+ *   queue: new SqliteMessageQueue(db),
+ * });
+ * ```
+ */
+declare class SqliteMessageQueue implements MessageQueue, Disposable {
+  #private;
+  readonly db: DatabaseSync;
+  readonly options: SqliteMessageQueueOptions;
+  /**
+   * SQLite message queue does not provide native retry mechanisms.
+   */
+  readonly nativeRetrial = false;
+  /**
+   * Creates a new SQLite message queue.
+   * @param db The SQLite database to use. Supports `node:sqlite`, `bun:sqlite`.
+   * @param options The options for the message queue.
+   */
+  constructor(db: DatabaseSync, options?: SqliteMessageQueueOptions);
+  /**
+   * {@inheritDoc MessageQueue.enqueue}
+   */
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  /**
+   * {@inheritDoc MessageQueue.enqueueMany}
+   */
+  enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  /**
+   * {@inheritDoc MessageQueue.listen}
+   */
+  listen(handler: (message: any) => Promise<void> | void, options?: MessageQueueListenOptions): Promise<void>;
+  /**
+   * Creates the message queue table if it does not already exist.
+   * Does nothing if the table already exists.
+   *
+   * This method also configures the SQLite journal mode for better concurrency.
+   * WAL (Write-Ahead Logging) mode is enabled by default to improve
+   * concurrent access in multi-process environments.
+   */
+  initialize(): void;
+  /**
+   * Drops the table used by the message queue.  Does nothing if the table
+   * does not exist.
+   */
+  drop(): void;
+  /**
+   * Closes the database connection.
+   */
+  [Symbol.dispose](): void;
+}
+//#endregion
+export { SqliteMessageQueue, SqliteMessageQueueOptions };

package/dist/mq.d.ts

@@ -0,0 +1,113 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { PlatformDatabase } from "#sqlite";
+import { MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify";
+
+//#region src/mq.d.ts
+/**
+ * Options for the SQLite message queue.
+ */
+interface SqliteMessageQueueOptions {
+  /**
+   * The table name to use for the message queue.
+   * Only letters, digits, and underscores are allowed.
+   * `"fedify_message"` by default.
+   * @default `"fedify_message"`
+   */
+  tableName?: string;
+  /**
+   * Whether the table has been initialized.  `false` by default.
+   * @default `false`
+   */
+  initialized?: boolean;
+  /**
+   * The poll interval for the message queue.
+   * @default `{ seconds: 5 }`
+   */
+  pollInterval?: Temporal.Duration | Temporal.DurationLike;
+  /**
+   * Maximum number of retries for SQLITE_BUSY errors.
+   * @default `5`
+   */
+  maxRetries?: number;
+  /**
+   * Initial retry delay in milliseconds for SQLITE_BUSY errors.
+   * Uses exponential backoff.
+   * @default `100`
+   */
+  retryDelayMs?: number;
+  /**
+   * SQLite journal mode to use.
+   * WAL (Write-Ahead Logging) mode is recommended for better concurrency
+   * in multi-process environments.
+   * Note: WAL mode is persistent per database file, not per connection.
+   * @default `"WAL"`
+   */
+  journalMode?: "WAL" | "DELETE" | "TRUNCATE" | "PERSIST" | "MEMORY";
+}
+/**
+ * A message queue that uses SQLite as the underlying storage.
+ *
+ * This implementation is designed for single-node deployments and uses
+ * polling to check for new messages. It is not suitable for high-throughput
+ * scenarios or distributed environments.
+ *
+ * @example
+ * ```ts ignore
+ * import { createFederation } from "@fedify/fedify";
+ * import { SqliteMessageQueue } from "@fedify/sqlite";
+ * import { DatabaseSync } from "node:sqlite";
+ *
+ * const db = new DatabaseSync(":memory:");
+ * const federation = createFederation({
+ *   // ...
+ *   queue: new SqliteMessageQueue(db),
+ * });
+ * ```
+ */
+declare class SqliteMessageQueue implements MessageQueue, Disposable {
+  #private;
+  readonly db: PlatformDatabase;
+  readonly options: SqliteMessageQueueOptions;
+  /**
+   * SQLite message queue does not provide native retry mechanisms.
+   */
+  readonly nativeRetrial = false;
+  /**
+   * Creates a new SQLite message queue.
+   * @param db The SQLite database to use. Supports `node:sqlite`, `bun:sqlite`.
+   * @param options The options for the message queue.
+   */
+  constructor(db: PlatformDatabase, options?: SqliteMessageQueueOptions);
+  /**
+   * {@inheritDoc MessageQueue.enqueue}
+   */
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  /**
+   * {@inheritDoc MessageQueue.enqueueMany}
+   */
+  enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  /**
+   * {@inheritDoc MessageQueue.listen}
+   */
+  listen(handler: (message: any) => Promise<void> | void, options?: MessageQueueListenOptions): Promise<void>;
+  /**
+   * Creates the message queue table if it does not already exist.
+   * Does nothing if the table already exists.
+   *
+   * This method also configures the SQLite journal mode for better concurrency.
+   * WAL (Write-Ahead Logging) mode is enabled by default to improve
+   * concurrent access in multi-process environments.
+   */
+  initialize(): void;
+  /**
+   * Drops the table used by the message queue.  Does nothing if the table
+   * does not exist.
+   */
+  drop(): void;
+  /**
+   * Closes the database connection.
+   */
+  [Symbol.dispose](): void;
+}
+//#endregion
+export { SqliteMessageQueue, SqliteMessageQueueOptions };