@fedify/sqlite 2.1.0-dev.405 → 2.1.0-dev.408

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/sqlite",
-  "version": "2.1.0-dev.405+f4e278ae",
+  "version": "2.1.0-dev.408+5c3c9d78",
   "license": "MIT",
   "exports": {
     ".": "./src/mod.ts",

package/dist/adapter.d.cts

@@ -1,44 +1,44 @@
 //#region src/adapter.d.ts
 /**
- * SQLite database adapter.
- *
- * An abstract interface for SQLite database for different runtime environments.
- */
+* SQLite database adapter.
+*
+* An abstract interface for SQLite database for different runtime environments.
+*/
 interface SqliteDatabaseAdapter {
   /**
-   * Prepares a SQL statement.
-   * @param sql - The SQL statement to prepare.
-   */
+  * Prepares a SQL statement.
+  * @param sql - The SQL statement to prepare.
+  */
   prepare(sql: string): SqliteStatementAdapter;
   /**
-   * Executes a SQL statement.
-   * @param sql - The SQL statement to execute.
-   */
+  * Executes a SQL statement.
+  * @param sql - The SQL statement to execute.
+  */
   exec(sql: string): void;
   /**
-   * Closes the database connection.
-   */
+  * Closes the database connection.
+  */
   close(): void;
 }
 interface SqliteStatementAdapter {
   /**
-   * Executes a SQL statement and returns the number of changes made to the database.
-   * @param params - The parameters to bind to the SQL statement.
-   */
+  * Executes a SQL statement and returns the number of changes made to the database.
+  * @param params - The parameters to bind to the SQL statement.
+  */
   run(...params: unknown[]): {
     changes: number;
     lastInsertRowid: number;
   };
   /**
-   * Executes a SQL statement and returns the first row of the result set.
-   * @param params - The parameters to bind to the SQL statement.
-   * @returns The first row of the result set, or `undefined` if the result set is empty.
-   */
+  * Executes a SQL statement and returns the first row of the result set.
+  * @param params - The parameters to bind to the SQL statement.
+  * @returns The first row of the result set, or `undefined` if the result set is empty.
+  */
   get(...params: unknown[]): unknown | undefined;
   /**
-   * Executes a SQL statement and returns all rows of the result set.
-   * @param params - The parameters to bind to the SQL statement.
-   */
+  * Executes a SQL statement and returns all rows of the result set.
+  * @param params - The parameters to bind to the SQL statement.
+  */
   all(...params: unknown[]): unknown[];
 }
 //#endregion

package/dist/adapter.d.ts

@@ -3,45 +3,45 @@ import { Temporal } from "@js-temporal/polyfill";
 //#region src/adapter.d.ts
 
 /**
- * SQLite database adapter.
- *
- * An abstract interface for SQLite database for different runtime environments.
- */
+* SQLite database adapter.
+*
+* An abstract interface for SQLite database for different runtime environments.
+*/
 interface SqliteDatabaseAdapter {
   /**
-   * Prepares a SQL statement.
-   * @param sql - The SQL statement to prepare.
-   */
+  * Prepares a SQL statement.
+  * @param sql - The SQL statement to prepare.
+  */
   prepare(sql: string): SqliteStatementAdapter;
   /**
-   * Executes a SQL statement.
-   * @param sql - The SQL statement to execute.
-   */
+  * Executes a SQL statement.
+  * @param sql - The SQL statement to execute.
+  */
   exec(sql: string): void;
   /**
-   * Closes the database connection.
-   */
+  * Closes the database connection.
+  */
   close(): void;
 }
 interface SqliteStatementAdapter {
   /**
-   * Executes a SQL statement and returns the number of changes made to the database.
-   * @param params - The parameters to bind to the SQL statement.
-   */
+  * Executes a SQL statement and returns the number of changes made to the database.
+  * @param params - The parameters to bind to the SQL statement.
+  */
   run(...params: unknown[]): {
     changes: number;
     lastInsertRowid: number;
   };
   /**
-   * Executes a SQL statement and returns the first row of the result set.
-   * @param params - The parameters to bind to the SQL statement.
-   * @returns The first row of the result set, or `undefined` if the result set is empty.
-   */
+  * Executes a SQL statement and returns the first row of the result set.
+  * @param params - The parameters to bind to the SQL statement.
+  * @returns The first row of the result set, or `undefined` if the result set is empty.
+  */
   get(...params: unknown[]): unknown | undefined;
   /**
-   * Executes a SQL statement and returns all rows of the result set.
-   * @param params - The parameters to bind to the SQL statement.
-   */
+  * Executes a SQL statement and returns all rows of the result set.
+  * @param params - The parameters to bind to the SQL statement.
+  */
   all(...params: unknown[]): unknown[];
 }
 //#endregion

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

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

package/dist/kv.d.cts

@@ -1,80 +1,84 @@
-import { PlatformDatabase } from "#sqlite";
+import { DatabaseSync } from "./dist/sqlite.node.cjs";
 import { KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions } from "@fedify/fedify";
 
 //#region src/kv.d.ts
 /**
- * Options for the SQLite key–value store.
- */
+* Options for the SQLite key–value store.
+*/
 interface SqliteKvStoreOptions {
   /**
-   * The table name to use for the key–value store.
-   * Only letters, digits, and underscores are allowed.
-   * `"fedify_kv"` by default.
-   * @default `"fedify_kv"`
-   */
+  * The table name to use for the key–value store.
+  * Only letters, digits, and underscores are allowed.
+  * `"fedify_kv"` by default.
+  * @default `"fedify_kv"`
+  */
   readonly tableName?: string;
   /**
-   * Whether the table has been initialized.  `false` by default.
-   * @default `false`
-   */
+  * Whether the table has been initialized.  `false` by default.
+  * @default `false`
+  */
   readonly initialized?: boolean;
 }
 /**
- * A key–value store that uses SQLite as the underlying storage.
- *
- * @example
- * ```ts
- * import { createFederation } from "@fedify/fedify";
- * import { SqliteKvStore } from "@fedify/sqlite";
- * import { DatabaseSync } from "node:sqlite";
- *
- * const db = new DatabaseSync(":memory:");
- * const federation = createFederation({
- *   // ...
- *   kv: new SqliteKvStore(db),
- * });
- * ```
- */
+* A key–value store that uses SQLite as the underlying storage.
+*
+* @example
+* ```ts
+* import { createFederation } from "@fedify/fedify";
+* import { SqliteKvStore } from "@fedify/sqlite";
+* import { DatabaseSync } from "node:sqlite";
+*
+* const db = new DatabaseSync(":memory:");
+* const federation = createFederation({
+*   // ...
+*   kv: new SqliteKvStore(db),
+* });
+* ```
+*/
 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);
+  * 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: DatabaseSync, options?: SqliteKvStoreOptions);
   /**
-   * {@inheritDoc KvStore.get}
-   */
+  * {@inheritDoc KvStore.get}
+  */
+  // deno-lint-ignore require-await
   get<T = unknown>(key: KvKey): Promise<T | undefined>;
   /**
-   * {@inheritDoc KvStore.set}
-   */
+  * {@inheritDoc KvStore.set}
+  */
+  // deno-lint-ignore require-await
   set(key: KvKey, value: unknown, options?: KvStoreSetOptions): Promise<void>;
   /**
-   * {@inheritDoc KvStore.delete}
-   */
+  * {@inheritDoc KvStore.delete}
+  */
+  // deno-lint-ignore require-await
   delete(key: KvKey): Promise<void>;
   /**
-   * {@inheritDoc KvStore.cas}
-   */
+  * {@inheritDoc KvStore.cas}
+  */
+  // deno-lint-ignore require-await
   cas(key: KvKey, expectedValue: unknown, newValue: unknown, options?: KvStoreSetOptions): Promise<boolean>;
   /**
-   * {@inheritDoc KvStore.list}
-   * @since 1.10.0
-   */
+  * {@inheritDoc KvStore.list}
+  * @since 1.10.0
+  */
   list(prefix?: KvKey): AsyncIterable<KvStoreListEntry>;
   /**
-   * Creates the table used by the key–value store if it does not already exist.
-   * Does nothing if the table already exists.
-   */
+  * Creates the table used by the key–value store if it does not already exist.
+  * Does nothing if the table already exists.
+  */
   initialize(): void;
   /**
-   * Drops the table used by the key–value store.  Does nothing if the table
-   * does not exist.
-   */
+  * Drops the table used by the key–value store.  Does nothing if the table
+  * does not exist.
+  */
   drop(): void;
 }
 //#endregion

package/dist/kv.d.ts

@@ -4,78 +4,82 @@ import { KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions } from "@fedify/fed
 
 //#region src/kv.d.ts
 /**
- * Options for the SQLite key–value store.
- */
+* Options for the SQLite key–value store.
+*/
 interface SqliteKvStoreOptions {
   /**
-   * The table name to use for the key–value store.
-   * Only letters, digits, and underscores are allowed.
-   * `"fedify_kv"` by default.
-   * @default `"fedify_kv"`
-   */
+  * The table name to use for the key–value store.
+  * Only letters, digits, and underscores are allowed.
+  * `"fedify_kv"` by default.
+  * @default `"fedify_kv"`
+  */
   readonly tableName?: string;
   /**
-   * Whether the table has been initialized.  `false` by default.
-   * @default `false`
-   */
+  * Whether the table has been initialized.  `false` by default.
+  * @default `false`
+  */
   readonly initialized?: boolean;
 }
 /**
- * A key–value store that uses SQLite as the underlying storage.
- *
- * @example
- * ```ts
- * import { createFederation } from "@fedify/fedify";
- * import { SqliteKvStore } from "@fedify/sqlite";
- * import { DatabaseSync } from "node:sqlite";
- *
- * const db = new DatabaseSync(":memory:");
- * const federation = createFederation({
- *   // ...
- *   kv: new SqliteKvStore(db),
- * });
- * ```
- */
+* A key–value store that uses SQLite as the underlying storage.
+*
+* @example
+* ```ts
+* import { createFederation } from "@fedify/fedify";
+* import { SqliteKvStore } from "@fedify/sqlite";
+* import { DatabaseSync } from "node:sqlite";
+*
+* const db = new DatabaseSync(":memory:");
+* const federation = createFederation({
+*   // ...
+*   kv: new SqliteKvStore(db),
+* });
+* ```
+*/
 declare class SqliteKvStore implements KvStore {
   #private;
   readonly db: PlatformDatabase;
   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.
-   */
+  * 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);
   /**
-   * {@inheritDoc KvStore.get}
-   */
+  * {@inheritDoc KvStore.get}
+  */
+  // deno-lint-ignore require-await
   get<T = unknown>(key: KvKey): Promise<T | undefined>;
   /**
-   * {@inheritDoc KvStore.set}
-   */
+  * {@inheritDoc KvStore.set}
+  */
+  // deno-lint-ignore require-await
   set(key: KvKey, value: unknown, options?: KvStoreSetOptions): Promise<void>;
   /**
-   * {@inheritDoc KvStore.delete}
-   */
+  * {@inheritDoc KvStore.delete}
+  */
+  // deno-lint-ignore require-await
   delete(key: KvKey): Promise<void>;
   /**
-   * {@inheritDoc KvStore.cas}
-   */
+  * {@inheritDoc KvStore.cas}
+  */
+  // deno-lint-ignore require-await
   cas(key: KvKey, expectedValue: unknown, newValue: unknown, options?: KvStoreSetOptions): Promise<boolean>;
   /**
-   * {@inheritDoc KvStore.list}
-   * @since 1.10.0
-   */
+  * {@inheritDoc KvStore.list}
+  * @since 1.10.0
+  */
   list(prefix?: KvKey): AsyncIterable<KvStoreListEntry>;
   /**
-   * Creates the table used by the key–value store if it does not already exist.
-   * Does nothing if the table already exists.
-   */
+  * Creates the table used by the key–value store if it does not already exist.
+  * Does nothing if the table already exists.
+  */
   initialize(): void;
   /**
-   * Drops the table used by the key–value store.  Does nothing if the table
-   * does not exist.
-   */
+  * Drops the table used by the key–value store.  Does nothing if the table
+  * does not exist.
+  */
   drop(): void;
 }
 //#endregion

package/dist/mq.d.cts

@@ -1,111 +1,111 @@
-import { PlatformDatabase } from "#sqlite";
+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.
- */
+* 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"`
-   */
+  * 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`
-   */
+  * Whether the table has been initialized.  `false` by default.
+  * @default `false`
+  */
   initialized?: boolean;
   /**
-   * The poll interval for the message queue.
-   * @default `{ seconds: 5 }`
-   */
+  * 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`
-   */
+  * 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`
-   */
+  * 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"`
-   */
+  * 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),
- * });
- * ```
- */
+* 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 db: DatabaseSync;
   readonly options: SqliteMessageQueueOptions;
   /**
-   * SQLite message queue does not provide native retry mechanisms.
-   */
-  readonly nativeRetrial = false;
+  * 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);
+  * 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}
-   */
+  * {@inheritDoc MessageQueue.enqueue}
+  */
   enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
   /**
-   * {@inheritDoc MessageQueue.enqueueMany}
-   */
+  * {@inheritDoc MessageQueue.enqueueMany}
+  */
   enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
   /**
-   * {@inheritDoc MessageQueue.listen}
-   */
+  * {@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.
-   */
+  * 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 tables used by the message queue.  Does nothing if the tables
-   * do not exist.
-   */
+  * Drops the tables used by the message queue.  Does nothing if the tables
+  * do not exist.
+  */
   drop(): void;
   /**
-   * Closes the database connection.
-   */
+  * Closes the database connection.
+  */
   [Symbol.dispose](): void;
 }
 //#endregion

package/dist/mq.d.ts

@@ -4,109 +4,109 @@ import { MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } f
 
 //#region src/mq.d.ts
 /**
- * Options for the SQLite message queue.
- */
+* 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"`
-   */
+  * 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`
-   */
+  * Whether the table has been initialized.  `false` by default.
+  * @default `false`
+  */
   initialized?: boolean;
   /**
-   * The poll interval for the message queue.
-   * @default `{ seconds: 5 }`
-   */
+  * 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`
-   */
+  * 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`
-   */
+  * 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"`
-   */
+  * 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),
- * });
- * ```
- */
+* 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;
+  * 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.
-   */
+  * 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}
-   */
+  * {@inheritDoc MessageQueue.enqueue}
+  */
   enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
   /**
-   * {@inheritDoc MessageQueue.enqueueMany}
-   */
+  * {@inheritDoc MessageQueue.enqueueMany}
+  */
   enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
   /**
-   * {@inheritDoc MessageQueue.listen}
-   */
+  * {@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.
-   */
+  * 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 tables used by the message queue.  Does nothing if the tables
-   * do not exist.
-   */
+  * Drops the tables used by the message queue.  Does nothing if the tables
+  * do not exist.
+  */
   drop(): void;
   /**
-   * Closes the database connection.
-   */
+  * Closes the database connection.
+  */
   [Symbol.dispose](): void;
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/sqlite",
-  "version": "2.1.0-dev.405+f4e278ae",
+  "version": "2.1.0-dev.408+5c3c9d78",
   "description": "SQLite drivers for Fedify",
   "keywords": [
     "fedify",
@@ -72,13 +72,13 @@
     "es-toolkit": "^1.31.0"
   },
   "peerDependencies": {
-    "@fedify/fedify": "^2.1.0-dev.405+f4e278ae"
+    "@fedify/fedify": "^2.1.0-dev.408+5c3c9d78"
   },
   "devDependencies": {
     "@std/async": "npm:@jsr/std__async@^1.0.13",
     "tsdown": "^0.12.9",
     "typescript": "^5.9.3",
-    "@fedify/testing": "^2.1.0-dev.405+f4e278ae"
+    "@fedify/testing": "^2.1.0-dev.408+5c3c9d78"
   },
   "scripts": {
     "build:self": "tsdown",

package/src/kv.ts

@@ -266,7 +266,7 @@ export class SqliteKvStore implements KvStore {
    * Creates the table used by the key–value store if it does not already exist.
    * Does nothing if the table already exists.
    */
-  initialize() {
+  initialize(): void {
     if (this.#initialized) {
       return;
     }
@@ -309,7 +309,7 @@ export class SqliteKvStore implements KvStore {
    * Drops the table used by the key–value store.  Does nothing if the table
    * does not exist.
    */
-  drop() {
+  drop(): void {
     this.#db.exec(`DROP TABLE IF EXISTS "${this.#tableName}"`);
     this.#initialized = false;
   }

package/tsdown.config.ts

@@ -8,7 +8,7 @@ export default defineConfig({
     "src/sqlite.node.ts",
     "src/sqlite.bun.ts",
   ],
-  dts: true,
+  dts: { compilerOptions: { isolatedDeclarations: true, declaration: true } },
   unbundle: true,
   format: ["esm", "cjs"],
   platform: "node",