@event-driven-io/dumbo 0.13.0-beta.45 → 0.13.0-beta.47

package/dist/sqlite3.cjs

@@ -32,7 +32,6 @@ ansis = __toESM(ansis, 1);
 let sqlite3 = require("sqlite3");
 sqlite3 = __toESM(sqlite3, 1);
 let os = require("os");
-let node_async_hooks = require("node:async_hooks");
 
 //#region src/core/errors/index.ts
 const isNumber = (val) => typeof val === "number" && val === val;
@@ -205,6 +204,420 @@ var InvalidOperationError = class InvalidOperationError extends DumboError {
 	}
 };
 
+//#endregion
+//#region src/core/taskProcessing/abort.ts
+const never = { signal: new AbortController().signal };
+const from = (options) => options?.abort ?? never;
+const getSignal = (abort) => "signal" in abort ? abort.signal : abort;
+const reason = (abort) => {
+	const signal = getSignal(abort);
+	return signal.reason instanceof Error ? signal.reason : new DumboError(typeof signal.reason === "string" ? signal.reason : "Operation aborted");
+};
+const scope = (parent, onAbort) => {
+	const controller = new AbortController();
+	return {
+		abort: (reason) => controller.abort(reason),
+		dispose: onAbortSignal(parent, (reason) => {
+			controller.abort(reason);
+			onAbort?.(reason);
+		}),
+		signal: controller.signal
+	};
+};
+const execute = (operation, options) => {
+	const abort = options?.abort;
+	if (!abort) return operation();
+	const signal = abort.signal;
+	if (signal.aborted) return Promise.reject(reason(abort));
+	return new Promise((resolve, reject) => {
+		let finished = false;
+		const rejectOnAbort = () => {
+			if (finished) return;
+			finished = true;
+			reject(reason(abort));
+		};
+		signal.addEventListener("abort", rejectOnAbort, { once: true });
+		let operationPromise;
+		try {
+			operationPromise = operation();
+		} catch (error) {
+			finished = true;
+			signal.removeEventListener("abort", rejectOnAbort);
+			reject(error);
+			return;
+		}
+		operationPromise.then((result) => {
+			if (finished) return;
+			finished = true;
+			signal.removeEventListener("abort", rejectOnAbort);
+			resolve(result);
+		}).catch((error) => {
+			if (finished) return;
+			finished = true;
+			signal.removeEventListener("abort", rejectOnAbort);
+			reject(error);
+		});
+	});
+};
+const throwIfAborted = (options) => {
+	const abort = options?.abort;
+	if (abort?.signal.aborted) throw reason(abort);
+};
+const rejectIfAborted = (options) => {
+	const abort = options?.abort;
+	return abort?.signal.aborted ? Promise.reject(reason(abort)) : void 0;
+};
+const onAbortSignal = (abort, handle) => {
+	if (!abort) return () => {};
+	const signal = abort.signal;
+	if (signal.aborted) {
+		handle(reason(abort));
+		return () => {};
+	}
+	const abortListener = () => handle(reason(abort));
+	signal.addEventListener("abort", abortListener, { once: true });
+	return () => signal.removeEventListener("abort", abortListener);
+};
+const Abort = {
+	execute,
+	from,
+	never,
+	onAbort: onAbortSignal,
+	reason,
+	rejectIfAborted,
+	scope,
+	throwIfAborted
+};
+
+//#endregion
+//#region src/core/taskProcessing/taskProcessor.ts
+var TaskProcessor = class {
+	queue = [];
+	isProcessing = false;
+	activeTasks = 0;
+	activeGroups = /* @__PURE__ */ new Set();
+	options;
+	stopped = false;
+	idleWaiters = [];
+	activeTaskAbortCallbacks = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.options = options;
+	}
+	enqueue(task, options) {
+		if (options?.abort?.signal.aborted) return Promise.reject(Abort.reason(options.abort.signal));
+		if (this.stopped) return Promise.reject(new DumboError("TaskProcessor has been stopped"));
+		if (this.queue.length >= this.options.maxQueueSize) return Promise.reject(new TransientDatabaseError("Too many pending connections. Please try again later."));
+		return this.schedule(task, options);
+	}
+	waitForEndOfProcessing() {
+		if (this.activeTasks === 0 && this.queue.length === 0) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.idleWaiters.push(resolve);
+		});
+	}
+	async stop(options) {
+		if (this.stopped) return;
+		this.stopped = true;
+		const stoppedError = new DumboError("TaskProcessor has been stopped");
+		for (const item of this.queue.splice(0)) {
+			item.abort(stoppedError);
+			item.reject(stoppedError);
+		}
+		this.activeGroups.clear();
+		if (options?.force) for (const abort of this.activeTaskAbortCallbacks) abort(stoppedError);
+		if (options?.force) return;
+		if (options?.closeDeadline === void 0) {
+			await this.waitForEndOfProcessing();
+			return;
+		}
+		if (!await waitForProcessingOrDeadline(this.waitForEndOfProcessing(), options.closeDeadline)) for (const abort of this.activeTaskAbortCallbacks) abort(stoppedError);
+	}
+	schedule(task, options) {
+		return new Promise((resolve, reject) => {
+			let didQueueTimeout = false;
+			let didAbortBeforeStart = false;
+			let didStart = false;
+			let queueWaitTimer = noopQueueWaitTimer;
+			const abortScope = Abort.scope(options?.abort, (reason) => {
+				queueWaitTimer.cancel();
+				didAbortBeforeStart = !didStart;
+				reject(reason);
+			});
+			queueWaitTimer = createQueueWaitTimer(this.options.maxTaskIdleTime, (reason) => {
+				didQueueTimeout = true;
+				abortScope.abort(reason);
+				abortScope.dispose();
+				reject(reason);
+			});
+			const taskWithContext = () => {
+				return new Promise((resolveTask) => {
+					if (didQueueTimeout || didAbortBeforeStart) {
+						resolveTask();
+						return;
+					}
+					let taskPromise;
+					try {
+						taskPromise = task({
+							ack: resolveTask,
+							abort: abortScope
+						});
+					} catch (err) {
+						abortScope.dispose();
+						resolveTask();
+						reject(err);
+						return;
+					}
+					taskPromise.then((result) => {
+						abortScope.dispose();
+						resolve(result);
+					}).catch((err) => {
+						abortScope.dispose();
+						resolveTask();
+						reject(err);
+					});
+				});
+			};
+			this.queue.push({
+				task: taskWithContext,
+				options,
+				reject: (reason) => {
+					queueWaitTimer.cancel();
+					abortScope.dispose();
+					reject(reason);
+				},
+				markStarted: () => {
+					didStart = true;
+					queueWaitTimer.cancel();
+				},
+				abort: (reason) => {
+					abortScope.dispose();
+					abortScope.abort(reason);
+				}
+			});
+			if (!this.isProcessing) this.ensureProcessing();
+		});
+	}
+	ensureProcessing() {
+		if (this.isProcessing) return;
+		this.isProcessing = true;
+		this.processQueue();
+	}
+	processQueue() {
+		try {
+			while (this.activeTasks < this.options.maxActiveTasks && this.queue.length > 0) {
+				const item = this.takeFirstAvailableItem();
+				if (item === null) return;
+				const groupId = item.options?.taskGroupId;
+				if (groupId) this.activeGroups.add(groupId);
+				this.activeTasks++;
+				this.executeItem(item);
+			}
+		} catch (error) {
+			console.error(error);
+			throw error;
+		} finally {
+			this.isProcessing = false;
+			if (this.hasItemsToProcess() && this.activeTasks < this.options.maxActiveTasks) this.ensureProcessing();
+		}
+	}
+	async executeItem({ task, options, markStarted, abort }) {
+		markStarted();
+		this.activeTaskAbortCallbacks.add(abort);
+		try {
+			await task();
+		} finally {
+			this.activeTaskAbortCallbacks.delete(abort);
+			this.activeTasks--;
+			if (options && options.taskGroupId) this.activeGroups.delete(options.taskGroupId);
+			this.resolveIdleWaiters();
+			this.ensureProcessing();
+		}
+	}
+	takeFirstAvailableItem = () => {
+		const taskIndex = this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId));
+		if (taskIndex === -1) return null;
+		const [item] = this.queue.splice(taskIndex, 1);
+		return item ?? null;
+	};
+	hasItemsToProcess = () => this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId)) !== -1;
+	resolveIdleWaiters = () => {
+		if (this.activeTasks > 0 || this.queue.length > 0) return;
+		const waiters = this.idleWaiters.splice(0);
+		for (const resolve of waiters) resolve();
+	};
+};
+const noopQueueWaitTimer = { cancel: () => {} };
+const createQueueWaitTimer = (timeoutMs, reject) => {
+	if (timeoutMs === void 0) return noopQueueWaitTimer;
+	let timeoutId = setTimeout(() => {
+		reject(/* @__PURE__ */ new Error("Task was not started within the maximum waiting time"));
+	}, timeoutMs);
+	timeoutId.unref();
+	return { cancel: () => {
+		if (!timeoutId) return;
+		clearTimeout(timeoutId);
+		timeoutId = null;
+	} };
+};
+const waitForProcessingOrDeadline = async (processing, closeDeadline) => {
+	let timeoutId = null;
+	try {
+		return await Promise.race([processing.then(() => true), new Promise((resolve) => {
+			timeoutId = setTimeout(() => resolve(false), closeDeadline);
+			timeoutId.unref();
+		})]);
+	} finally {
+		if (timeoutId) clearTimeout(timeoutId);
+	}
+};
+
+//#endregion
+//#region src/core/taskProcessing/executionGuards.ts
+const guardExclusiveAccess = (options) => {
+	const taskProcessor = new TaskProcessor({
+		maxActiveTasks: 1,
+		maxQueueSize: options?.maxQueueSize ?? 1e3,
+		...options?.maxTaskIdleTime !== void 0 ? { maxTaskIdleTime: options.maxTaskIdleTime } : {}
+	});
+	return {
+		execute: (operation, options) => taskProcessor.enqueue(async (context) => {
+			try {
+				return await operation(context);
+			} finally {
+				context.ack();
+			}
+		}, options),
+		waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
+		stop: (options) => taskProcessor.stop(options)
+	};
+};
+const guardConcurrentAccess = (options) => {
+	const taskProcessor = new TaskProcessor({
+		maxActiveTasks: options?.maxActiveTasks ?? Number.MAX_SAFE_INTEGER,
+		maxQueueSize: options?.maxQueueSize ?? Number.MAX_SAFE_INTEGER,
+		...options?.maxTaskIdleTime !== void 0 ? { maxTaskIdleTime: options.maxTaskIdleTime } : {}
+	});
+	return {
+		execute: (operation, options) => taskProcessor.enqueue(async (context) => {
+			try {
+				return await operation({ abort: context.abort });
+			} finally {
+				context.ack();
+			}
+		}, options),
+		waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
+		stop: (options) => taskProcessor.stop(options)
+	};
+};
+const guardBoundedAccess = (getResource, options) => {
+	let isStopped = false;
+	const taskProcessor = new TaskProcessor({
+		maxActiveTasks: options.maxResources,
+		maxQueueSize: options.maxQueueSize ?? 1e3
+	});
+	const resourcePool = [];
+	const allResources = /* @__PURE__ */ new Set();
+	const activeResourceContexts = /* @__PURE__ */ new Map();
+	const acquireResource = async (taskContext) => {
+		try {
+			let resource;
+			if (options.reuseResources) resource = resourcePool.pop();
+			if (!resource) {
+				resource = await getResource({ abort: taskContext.abort });
+				allResources.add(resource);
+			}
+			activeResourceContexts.set(resource, {
+				ack: taskContext.ack,
+				taskContext
+			});
+			return resource;
+		} catch (e) {
+			taskContext.ack();
+			throw e;
+		}
+	};
+	const acquire = async (operationOptions) => taskProcessor.enqueue((taskContext) => acquireResource(taskContext), operationOptions);
+	const getActiveResourceContext = (resource) => {
+		const activeResourceContext = activeResourceContexts.get(resource);
+		if (!activeResourceContext) throw new Error("Acquired resource is not active");
+		return activeResourceContext;
+	};
+	const release = (resource) => {
+		const activeResourceContext = activeResourceContexts.get(resource);
+		if (activeResourceContext) {
+			activeResourceContexts.delete(resource);
+			if (options.reuseResources) resourcePool.push(resource);
+			activeResourceContext.ack();
+		}
+	};
+	const execute = async (operation, operationOptions) => {
+		return taskProcessor.enqueue(async (taskContext) => {
+			const resource = await acquireResource(taskContext);
+			const activeResourceContext = getActiveResourceContext(resource);
+			try {
+				return await operation(resource, { abort: activeResourceContext.taskContext.abort });
+			} finally {
+				release(resource);
+			}
+		}, operationOptions);
+	};
+	return {
+		acquire,
+		release,
+		execute,
+		waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
+		stop: async (stopOptions) => {
+			if (isStopped) return;
+			isStopped = true;
+			await taskProcessor.stop(stopOptions);
+			if (options?.closeResource) {
+				const resources = [...allResources];
+				allResources.clear();
+				resourcePool.length = 0;
+				await Promise.all(resources.map(async (resource) => await options.closeResource(resource)));
+			}
+		}
+	};
+};
+const guardInitializedOnce = (initialize, options) => {
+	let initPromise = null;
+	const taskProcessor = new TaskProcessor({
+		maxActiveTasks: 1,
+		maxQueueSize: options?.maxQueueSize ?? 1e3
+	});
+	const ensureInitialized = async (operationOptions, retryCount = 0) => {
+		if (initPromise !== null) return initPromise;
+		return taskProcessor.enqueue(async ({ abort, ack }) => {
+			if (initPromise !== null) {
+				ack();
+				return initPromise;
+			}
+			try {
+				const promise = initialize({ abort });
+				initPromise = promise;
+				const result = await promise;
+				ack();
+				return result;
+			} catch (error) {
+				initPromise = null;
+				ack();
+				if (retryCount < (options?.maxRetries ?? 3)) return ensureInitialized(operationOptions, retryCount + 1);
+				throw error;
+			}
+		}, {
+			...operationOptions,
+			taskGroupId: (0, uuid.v7)()
+		});
+	};
+	return {
+		ensureInitialized,
+		reset: () => {
+			initPromise = null;
+		},
+		stop: (options) => taskProcessor.stop(options)
+	};
+};
+
 //#endregion
 //#region src/core/execute/execute.ts
 const mapSQLQueryResult = (result, mapping) => {
@@ -229,26 +642,63 @@ var BatchCommandNoChangesError = class BatchCommandNoChangesError extends DumboE
 	}
 };
 const sqlExecutor = (sqlExecutor, options) => ({
-	query: (sql, queryOptions) => executeInNewDbClient((client) => sqlExecutor.query(client, sql, queryOptions), options),
-	batchQuery: (sqls, queryOptions) => executeInNewDbClient((client) => sqlExecutor.batchQuery(client, sqls, queryOptions), options),
-	command: (sql, commandOptions) => executeInNewDbClient((client) => sqlExecutor.command(client, sql, commandOptions), options),
-	batchCommand: (sqls, commandOptions) => executeInNewDbClient((client) => sqlExecutor.batchCommand(client, sqls, commandOptions), options)
+	query: (sql, queryOptions) => executeInNewDbClient((client) => sqlExecutor.query(client, sql, queryOptions), {
+		...options,
+		...queryOptions
+	}),
+	batchQuery: (sqls, queryOptions) => executeInNewDbClient((client) => sqlExecutor.batchQuery(client, sqls, queryOptions), {
+		...options,
+		...queryOptions
+	}),
+	command: (sql, commandOptions) => executeInNewDbClient((client) => sqlExecutor.command(client, sql, commandOptions), {
+		...options,
+		...commandOptions
+	}),
+	batchCommand: (sqls, commandOptions) => executeInNewDbClient((client) => sqlExecutor.batchCommand(client, sqls, commandOptions), {
+		...options,
+		...commandOptions
+	})
 });
 const sqlExecutorInNewConnection = (options) => ({
-	query: (sql, queryOptions) => executeInNewConnection((connection) => connection.execute.query(sql, queryOptions), options),
-	batchQuery: (sqls, queryOptions) => executeInNewConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), options),
-	command: (sql, commandOptions) => executeInNewConnection((connection) => connection.execute.command(sql, commandOptions), options),
-	batchCommand: (sqls, commandOptions) => executeInNewConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), options)
+	query: (sql, queryOptions) => executeInNewConnection((connection) => connection.execute.query(sql, queryOptions), {
+		...options,
+		...queryOptions
+	}),
+	batchQuery: (sqls, queryOptions) => executeInNewConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), {
+		...options,
+		...queryOptions
+	}),
+	command: (sql, commandOptions) => executeInNewConnection((connection) => connection.execute.command(sql, commandOptions), {
+		...options,
+		...commandOptions
+	}),
+	batchCommand: (sqls, commandOptions) => executeInNewConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), {
+		...options,
+		...commandOptions
+	})
 });
 const sqlExecutorInAmbientConnection = (options) => ({
-	query: (sql, queryOptions) => executeInAmbientConnection((connection) => connection.execute.query(sql, queryOptions), options),
-	batchQuery: (sqls, queryOptions) => executeInAmbientConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), options),
-	command: (sql, commandOptions) => executeInAmbientConnection((connection) => connection.execute.command(sql, commandOptions), options),
-	batchCommand: (sqls, commandOptions) => executeInAmbientConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), options)
+	query: (sql, queryOptions) => executeInAmbientConnection((connection) => connection.execute.query(sql, queryOptions), {
+		...options,
+		...queryOptions
+	}),
+	batchQuery: (sqls, queryOptions) => executeInAmbientConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), {
+		...options,
+		...queryOptions
+	}),
+	command: (sql, commandOptions) => executeInAmbientConnection((connection) => connection.execute.command(sql, commandOptions), {
+		...options,
+		...commandOptions
+	}),
+	batchCommand: (sqls, commandOptions) => executeInAmbientConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), {
+		...options,
+		...commandOptions
+	})
 });
 const executeInNewDbClient = async (handle, options) => {
+	Abort.throwIfAborted(options);
 	const { connect, close } = options;
-	const client = await connect();
+	const client = await connect({ abort: Abort.from(options) });
 	try {
 		return await handle(client);
 	} catch (error) {
@@ -257,7 +707,8 @@ const executeInNewDbClient = async (handle, options) => {
 	}
 };
 const executeInNewConnection = async (handle, options) => {
-	const connection = await options.connection();
+	Abort.throwIfAborted(options);
+	const connection = await options.connection({ abort: Abort.from(options) });
 	try {
 		return await handle(connection);
 	} finally {
@@ -265,10 +716,8 @@ const executeInNewConnection = async (handle, options) => {
 	}
 };
 const executeInAmbientConnection = async (handle, options) => {
-	const connection = await options.connection();
-	try {
-		return await handle(connection);
-	} finally {}
+	Abort.throwIfAborted(options);
+	return handle(await options.connection({ abort: Abort.from(options) }));
 };
 
 //#endregion
@@ -336,10 +785,10 @@ const toTransactionResult = (transactionResult) => transactionResult !== void 0
 	success: true,
 	result: transactionResult
 };
-const executeInTransaction = async (transaction, handle) => {
+const executeInTransaction = async (transaction, handle, context = { abort: Abort.never }) => {
 	await transaction.begin();
 	try {
-		const { success, result } = toTransactionResult(await handle(transaction));
+		const { success, result } = toTransactionResult(await handle(transaction, context));
 		if (success) await transaction.commit();
 		else await transaction.rollback();
 		return result;
@@ -348,18 +797,32 @@ const executeInTransaction = async (transaction, handle) => {
 		throw e;
 	}
 };
+const executeInNestedTransaction = async (transaction, handle, options, context) => {
+	Abort.throwIfAborted(options);
+	if (!(options?.allowNestedTransactions ?? transaction._transactionOptions.allowNestedTransactions ?? false)) throw new InvalidOperationError("Cannot start a nested transaction: allowNestedTransactions is false. Set transactionOptions: { allowNestedTransactions: true } on your pool or connection.");
+	return executeInTransaction(transaction, handle, context);
+};
 const transactionFactoryWithDbClient = (connect, initTransaction) => {
 	let currentTransaction = void 0;
-	const getOrInitCurrentTransaction = (options) => currentTransaction ?? (currentTransaction = initTransaction(connect(), {
-		close: () => {
-			currentTransaction = void 0;
-			return Promise.resolve();
-		},
-		...options ?? {}
-	}));
+	const getOrInitCurrentTransaction = (options) => {
+		Abort.throwIfAborted(options);
+		if (currentTransaction) return currentTransaction;
+		currentTransaction = initTransaction(connect({ abort: Abort.from(options) }), {
+			close: () => {
+				currentTransaction = void 0;
+				return Promise.resolve();
+			},
+			...options ?? {}
+		});
+		return currentTransaction;
+	};
 	return {
 		transaction: getOrInitCurrentTransaction,
-		withTransaction: (handle, options) => executeInTransaction(getOrInitCurrentTransaction(options), handle)
+		withTransaction: (handle, options) => {
+			const abortRejection = Abort.rejectIfAborted(options);
+			if (abortRejection) return abortRejection;
+			return executeInTransaction(getOrInitCurrentTransaction(options), handle, { abort: Abort.from(options) });
+		}
 	};
 };
 const wrapInConnectionClosure = async (connection, handle) => {
@@ -371,7 +834,8 @@ const wrapInConnectionClosure = async (connection, handle) => {
 };
 const transactionFactoryWithNewConnection = (connect) => ({
 	transaction: (options) => {
-		const connection = connect();
+		Abort.throwIfAborted(options);
+		const connection = connect({ abort: Abort.from(options) });
 		const transaction = connection.transaction(options);
 		return {
 			...transaction,
@@ -380,7 +844,9 @@ const transactionFactoryWithNewConnection = (connect) => ({
 		};
 	},
 	withTransaction: (handle, options) => {
-		const connection = connect();
+		const abortRejection = Abort.rejectIfAborted(options);
+		if (abortRejection) return abortRejection;
+		const connection = connect({ abort: Abort.from(options) });
 		const withTx = connection.withTransaction;
 		return wrapInConnectionClosure(connection, () => withTx(handle, options));
 	}
@@ -389,19 +855,21 @@ const transactionFactoryWithAsyncAmbientConnection = (driverType, connect, close
 	close ??= () => Promise.resolve();
 	return {
 		transaction: (options) => {
+			Abort.throwIfAborted(options);
 			let conn = null;
 			let innerTx = null;
 			let connectingPromise = null;
 			const ensureConnection = async () => {
 				if (conn) return innerTx;
 				if (!connectingPromise) connectingPromise = (async () => {
-					conn = await connect();
+					Abort.throwIfAborted(options);
+					conn = await connect({ abort: Abort.from(options) });
 					innerTx = conn.transaction(options);
 				})();
 				await connectingPromise;
 				return innerTx;
 			};
-			return {
+			const tx = {
 				driverType,
 				get connection() {
 					if (!conn) throw new Error("Transaction not started - call begin() first");
@@ -443,11 +911,14 @@ const transactionFactoryWithAsyncAmbientConnection = (driverType, connect, close
 						if (conn) await close(conn);
 					}
 				},
-				_transactionOptions: void 0
+				withTransaction: (handle, options) => executeInNestedTransaction(tx, handle, options, { abort: Abort.from(options) }),
+				_transactionOptions: options ?? {}
 			};
+			return tx;
 		},
 		withTransaction: async (handle, options) => {
-			const conn = await connect();
+			Abort.throwIfAborted(options);
+			const conn = await connect({ abort: Abort.from(options) });
 			try {
 				const withTx = conn.withTransaction;
 				return await withTx(handle, options);
@@ -464,7 +935,10 @@ const createAmbientConnection = (options) => {
 	const { driverType, client, executor, initTransaction, serializer } = options;
 	const clientPromise = Promise.resolve(client);
 	const closePromise = Promise.resolve();
-	const open = () => clientPromise;
+	const open = (context) => {
+		Abort.throwIfAborted(context);
+		return clientPromise;
+	};
 	const close = () => closePromise;
 	const typedConnection = {
 		driverType,
@@ -480,9 +954,10 @@ const createConnection = (options) => {
 	const { driverType, connect, close, initTransaction, executor, serializer } = options;
 	let client = null;
 	let connectPromise = null;
-	const getClient = async () => {
+	const getClient = async (context) => {
+		Abort.throwIfAborted(context);
 		if (client) return client;
-		if (!connectPromise) connectPromise = connect().then((c) => {
+		if (!connectPromise) connectPromise = connect(context ?? { abort: Abort.never }).then((c) => {
 			client = c;
 			return c;
 		});
@@ -499,209 +974,6 @@ const createConnection = (options) => {
 	return typedConnection;
 };
 
-//#endregion
-//#region src/core/taskProcessing/taskProcessor.ts
-var TaskProcessor = class {
-	queue = [];
-	isProcessing = false;
-	activeTasks = 0;
-	activeGroups = /* @__PURE__ */ new Set();
-	options;
-	stopped = false;
-	constructor(options) {
-		this.options = options;
-	}
-	enqueue(task, options) {
-		if (this.stopped) return Promise.reject(new DumboError("TaskProcessor has been stopped"));
-		if (this.queue.length >= this.options.maxQueueSize) return Promise.reject(new TransientDatabaseError("Too many pending connections. Please try again later."));
-		return this.schedule(task, options);
-	}
-	waitForEndOfProcessing() {
-		return this.schedule(({ ack }) => Promise.resolve(ack()));
-	}
-	async stop(options) {
-		if (this.stopped) return;
-		this.stopped = true;
-		this.queue.length = 0;
-		this.activeGroups.clear();
-		if (!options?.force) await this.waitForEndOfProcessing();
-	}
-	schedule(task, options) {
-		return promiseWithDeadline((resolve, reject) => {
-			const taskWithContext = () => {
-				return new Promise((resolveTask, failTask) => {
-					task({ ack: resolveTask }).then(resolve).catch((err) => {
-						failTask(err);
-						reject(err);
-					});
-				});
-			};
-			this.queue.push({
-				task: taskWithContext,
-				options
-			});
-			if (!this.isProcessing) this.ensureProcessing();
-		}, { deadline: this.options.maxTaskIdleTime });
-	}
-	ensureProcessing() {
-		if (this.isProcessing) return;
-		this.isProcessing = true;
-		this.processQueue();
-	}
-	processQueue() {
-		try {
-			while (this.activeTasks < this.options.maxActiveTasks && this.queue.length > 0) {
-				const item = this.takeFirstAvailableItem();
-				if (item === null) return;
-				const groupId = item.options?.taskGroupId;
-				if (groupId) this.activeGroups.add(groupId);
-				this.activeTasks++;
-				this.executeItem(item);
-			}
-		} catch (error) {
-			console.error(error);
-			throw error;
-		} finally {
-			this.isProcessing = false;
-			if (this.hasItemsToProcess() && this.activeTasks < this.options.maxActiveTasks) this.ensureProcessing();
-		}
-	}
-	async executeItem({ task, options }) {
-		try {
-			await task();
-		} finally {
-			this.activeTasks--;
-			if (options && options.taskGroupId) this.activeGroups.delete(options.taskGroupId);
-			this.ensureProcessing();
-		}
-	}
-	takeFirstAvailableItem = () => {
-		const taskIndex = this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId));
-		if (taskIndex === -1) return null;
-		const [item] = this.queue.splice(taskIndex, 1);
-		return item ?? null;
-	};
-	hasItemsToProcess = () => this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId)) !== -1;
-};
-const DEFAULT_PROMISE_DEADLINE = 2147483647;
-const promiseWithDeadline = (executor, options) => {
-	return new Promise((resolve, reject) => {
-		let taskStarted = false;
-		let timeoutId = null;
-		const deadline = options.deadline ?? DEFAULT_PROMISE_DEADLINE;
-		timeoutId = setTimeout(() => {
-			if (!taskStarted) reject(/* @__PURE__ */ new Error("Task was not started within the maximum waiting time"));
-		}, deadline);
-		timeoutId.unref();
-		executor((value) => {
-			taskStarted = true;
-			if (timeoutId) clearTimeout(timeoutId);
-			timeoutId = null;
-			resolve(value);
-		}, (reason) => {
-			if (timeoutId) clearTimeout(timeoutId);
-			timeoutId = null;
-			reject(reason);
-		});
-	});
-};
-
-//#endregion
-//#region src/core/taskProcessing/executionGuards.ts
-const guardBoundedAccess = (getResource, options) => {
-	let isStopped = false;
-	const taskProcessor = new TaskProcessor({
-		maxActiveTasks: options.maxResources,
-		maxQueueSize: options.maxQueueSize ?? 1e3
-	});
-	const resourcePool = [];
-	const allResources = /* @__PURE__ */ new Set();
-	const ackCallbacks = /* @__PURE__ */ new Map();
-	const acquire = async () => taskProcessor.enqueue(async ({ ack }) => {
-		try {
-			let resource;
-			if (options.reuseResources) resource = resourcePool.pop();
-			if (!resource) {
-				resource = await getResource();
-				allResources.add(resource);
-			}
-			ackCallbacks.set(resource, ack);
-			return resource;
-		} catch (e) {
-			ack();
-			throw e;
-		}
-	});
-	const release = (resource) => {
-		const ack = ackCallbacks.get(resource);
-		if (ack) {
-			ackCallbacks.delete(resource);
-			if (options.reuseResources) resourcePool.push(resource);
-			ack();
-		}
-	};
-	const execute = async (operation) => {
-		const resource = await acquire();
-		try {
-			return await operation(resource);
-		} finally {
-			release(resource);
-		}
-	};
-	return {
-		acquire,
-		release,
-		execute,
-		waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
-		stop: async (stopOptions) => {
-			if (isStopped) return;
-			isStopped = true;
-			if (options?.closeResource) {
-				const resources = [...allResources];
-				allResources.clear();
-				resourcePool.length = 0;
-				await Promise.all(resources.map(async (resource) => await options.closeResource(resource)));
-			}
-			await taskProcessor.stop(stopOptions);
-		}
-	};
-};
-const guardInitializedOnce = (initialize, options) => {
-	let initPromise = null;
-	const taskProcessor = new TaskProcessor({
-		maxActiveTasks: 1,
-		maxQueueSize: options?.maxQueueSize ?? 1e3
-	});
-	const ensureInitialized = async (retryCount = 0) => {
-		if (initPromise !== null) return initPromise;
-		return taskProcessor.enqueue(async ({ ack }) => {
-			if (initPromise !== null) {
-				ack();
-				return initPromise;
-			}
-			try {
-				const promise = initialize();
-				initPromise = promise;
-				const result = await promise;
-				ack();
-				return result;
-			} catch (error) {
-				initPromise = null;
-				ack();
-				if (retryCount < (options?.maxRetries ?? 3)) return ensureInitialized(retryCount + 1);
-				throw error;
-			}
-		}, { taskGroupId: (0, uuid.v7)() });
-	};
-	return {
-		ensureInitialized,
-		reset: () => {
-			initPromise = null;
-		},
-		stop: (options) => taskProcessor.stop(options)
-	};
-};
-
 //#endregion
 //#region src/core/connections/pool.ts
 const wrapPooledConnection = (conn, onClose) => ({
@@ -715,7 +987,10 @@ const createAmbientConnectionPool = (options) => {
 		getConnection: () => connection,
 		execute: connection.execute,
 		transaction: (options) => connection.transaction(options),
-		withConnection: (handle, _options) => handle(connection),
+		withConnection: (handle, options) => {
+			Abort.throwIfAborted(options);
+			return handle(connection, { abort: Abort.from(options) });
+		},
 		withTransaction: (handle, options) => {
 			const withTx = connection.withTransaction;
 			return withTx(handle, options);
@@ -726,48 +1001,45 @@ const createSingletonConnectionPool = (options) => {
 	const { driverType, getConnection } = options;
 	let connectionPromise = null;
 	let closed = false;
-	const activeOperations = /* @__PURE__ */ new Set();
+	const operationGuard = guardConcurrentAccess();
 	const closedError = () => /* @__PURE__ */ new Error("Singleton connection pool has been closed");
-	const run = async (operation) => {
+	const executeIfOpen = async (operation, operationOptions) => {
 		if (closed) throw closedError();
-		const activeOperation = operation();
-		activeOperations.add(activeOperation);
-		try {
-			return await activeOperation;
-		} finally {
-			activeOperations.delete(activeOperation);
-		}
+		return operationGuard.execute(operation, operationOptions);
 	};
-	const getExistingOrNewConnection = () => {
-		if (!connectionPromise) connectionPromise ??= Promise.resolve(getConnection());
+	const getExistingOrNewConnection = (context) => {
+		if (!connectionPromise) connectionPromise ??= Promise.resolve(getConnection(context));
 		return connectionPromise;
 	};
 	const innerTransactionFactory = transactionFactoryWithAsyncAmbientConnection(options.driverType, getExistingOrNewConnection, options.closeConnection);
 	return {
 		driverType,
-		connection: () => run(() => getExistingOrNewConnection().then((conn) => wrapPooledConnection(conn, () => Promise.resolve()))),
+		connection: (connectionOptions) => executeIfOpen((context) => getExistingOrNewConnection(context).then((conn) => wrapPooledConnection(conn, () => Promise.resolve())), connectionOptions),
 		execute: (() => {
 			const ambientExecutor = sqlExecutorInAmbientConnection({
 				driverType,
 				connection: getExistingOrNewConnection
 			});
 			return {
-				query: (sql, opts) => run(() => ambientExecutor.query(sql, opts)),
-				batchQuery: (sqls, opts) => run(() => ambientExecutor.batchQuery(sqls, opts)),
-				command: (sql, opts) => run(() => ambientExecutor.command(sql, opts)),
-				batchCommand: (sqls, opts) => run(() => ambientExecutor.batchCommand(sqls, opts))
+				query: (sql, opts) => executeIfOpen(() => ambientExecutor.query(sql, opts), opts),
+				batchQuery: (sqls, opts) => executeIfOpen(() => ambientExecutor.batchQuery(sqls, opts), opts),
+				command: (sql, opts) => executeIfOpen(() => ambientExecutor.command(sql, opts), opts),
+				batchCommand: (sqls, opts) => executeIfOpen(() => ambientExecutor.batchCommand(sqls, opts), opts)
 			};
 		})(),
-		withConnection: (handle, _options) => run(() => executeInAmbientConnection(handle, { connection: getExistingOrNewConnection })),
+		withConnection: (handle, options) => executeIfOpen((context) => executeInAmbientConnection((connection) => handle(connection, context), {
+			connection: getExistingOrNewConnection,
+			...options
+		}), options),
 		transaction: (transactionOptions) => {
 			if (closed) throw closedError();
 			return innerTransactionFactory.transaction(transactionOptions);
 		},
-		withTransaction: (handle, transactionOptions) => run(() => innerTransactionFactory.withTransaction(handle, transactionOptions)),
+		withTransaction: (handle, transactionOptions) => executeIfOpen((context) => innerTransactionFactory.withTransaction((tx) => handle(tx, context), transactionOptions), transactionOptions),
 		close: async (closeOptions) => {
 			if (closed) return;
 			closed = true;
-			if (!closeOptions?.force) await Promise.allSettled([...activeOperations]);
+			await operationGuard.stop(closeOptions);
 			if (!connectionPromise) return;
 			const connection = await connectionPromise;
 			connectionPromise = null;
@@ -777,63 +1049,49 @@ const createSingletonConnectionPool = (options) => {
 };
 const createBoundedConnectionPool = (options) => {
 	const { driverType, maxConnections } = options;
-	const allConnections = /* @__PURE__ */ new Set();
-	const getTrackedConnection = async () => {
-		const connection = await options.getConnection();
-		allConnections.add(connection);
-		return connection;
-	};
-	const guardMaxConnections = guardBoundedAccess(getTrackedConnection, {
+	const guardMaxConnections = guardBoundedAccess(options.getConnection, {
 		maxResources: maxConnections,
-		reuseResources: true
+		reuseResources: true,
+		closeResource: (connection) => connection.close()
 	});
 	let closed = false;
 	const closedError = () => /* @__PURE__ */ new Error("Bounded connection pool has been closed");
 	const ensureOpen = () => {
 		if (closed) throw closedError();
 	};
-	const closeAllConnections = async () => {
-		const connections = [...allConnections];
-		allConnections.clear();
-		await Promise.all(connections.map((conn) => conn.close()));
-	};
-	const executeWithPooling = async (operation) => {
+	const executeWithPooledConnection = async (operation, operationOptions) => {
 		ensureOpen();
-		const conn = await guardMaxConnections.acquire();
-		try {
-			return await operation(conn);
-		} finally {
-			guardMaxConnections.release(conn);
-		}
+		return guardMaxConnections.execute(operation, operationOptions);
 	};
 	return {
 		driverType,
-		connection: async () => {
+		connection: async (connectionOptions) => {
 			ensureOpen();
-			const conn = await guardMaxConnections.acquire();
+			const conn = await guardMaxConnections.acquire(connectionOptions);
 			return wrapPooledConnection(conn, () => Promise.resolve(guardMaxConnections.release(conn)));
 		},
 		execute: {
-			query: (sql, opts) => executeWithPooling((c) => c.execute.query(sql, opts)),
-			batchQuery: (sqls, opts) => executeWithPooling((c) => c.execute.batchQuery(sqls, opts)),
-			command: (sql, opts) => executeWithPooling((c) => c.execute.command(sql, opts)),
-			batchCommand: (sqls, opts) => executeWithPooling((c) => c.execute.batchCommand(sqls, opts))
+			query: (sql, opts) => executeWithPooledConnection((c) => c.execute.query(sql, opts), opts),
+			batchQuery: (sqls, opts) => executeWithPooledConnection((c) => c.execute.batchQuery(sqls, opts), opts),
+			command: (sql, opts) => executeWithPooledConnection((c) => c.execute.command(sql, opts), opts),
+			batchCommand: (sqls, opts) => executeWithPooledConnection((c) => c.execute.batchCommand(sqls, opts), opts)
 		},
-		withConnection: executeWithPooling,
+		withConnection: executeWithPooledConnection,
 		transaction: (transactionOptions) => {
 			ensureOpen();
-			return transactionFactoryWithAsyncAmbientConnection(driverType, guardMaxConnections.acquire, guardMaxConnections.release).transaction(transactionOptions);
+			return transactionFactoryWithAsyncAmbientConnection(driverType, (context) => guardMaxConnections.acquire({
+				...transactionOptions,
+				abort: context.abort
+			}), guardMaxConnections.release).transaction(transactionOptions);
 		},
-		withTransaction: (handle, transactionOptions) => executeWithPooling((conn) => {
+		withTransaction: (handle, transactionOptions) => executeWithPooledConnection((conn, context) => {
 			const withTx = conn.withTransaction;
-			return withTx(handle, transactionOptions);
-		}),
+			return withTx((tx) => handle(tx, context), transactionOptions);
+		}, transactionOptions),
 		close: async (closeOptions) => {
 			if (closed) return;
 			closed = true;
-			if (!closeOptions?.force) await guardMaxConnections.waitForIdle();
-			await guardMaxConnections.stop({ force: true });
-			await closeAllConnections();
+			await guardMaxConnections.stop(closeOptions);
 		}
 	};
 };
@@ -841,16 +1099,22 @@ const createAlwaysNewConnectionPool = (options) => {
 	const { driverType, getConnection, connectionOptions } = options;
 	return createConnectionPool({
 		driverType,
-		getConnection: () => connectionOptions ? getConnection(connectionOptions) : getConnection()
+		getConnection: (context) => connectionOptions ? getConnection(connectionOptions, context) : getConnection(context)
 	});
 };
 const createConnectionPool = (pool) => {
 	const { driverType, getConnection } = pool;
-	const connection = "connection" in pool ? pool.connection : () => Promise.resolve(getConnection());
+	const connection = "connection" in pool ? pool.connection : (options) => {
+		Abort.throwIfAborted(options);
+		return Promise.resolve(getConnection({ abort: Abort.from(options) }));
+	};
 	return {
 		driverType,
 		connection,
-		withConnection: "withConnection" in pool ? pool.withConnection : (handle, _options) => executeInNewConnection(handle, { connection }),
+		withConnection: "withConnection" in pool ? pool.withConnection : (handle, options) => executeInNewConnection((connection) => handle(connection, { abort: Abort.from(options) }), {
+			connection,
+			...options
+		}),
 		close: "close" in pool ? pool.close : () => Promise.resolve(),
 		execute: "execute" in pool ? pool.execute : sqlExecutorInNewConnection({
 			driverType,
@@ -2190,9 +2454,9 @@ const sqliteSQLExecutor = (driverType, serializer, formatter, errorMapper) => ({
 
 //#endregion
 //#region src/storage/sqlite/core/transactions/index.ts
-const sqliteTransaction = (driverType, connection, allowNestedTransactions, serializer, defaultTransactionMode) => (getClient, options) => {
-	allowNestedTransactions = options?.allowNestedTransactions ?? allowNestedTransactions;
-	const useSavepoints = options?.useSavepoints ?? false;
+const sqliteTransaction = (driverType, connection, defaultOptions, serializer, defaultTransactionMode) => (getClient, options) => {
+	const defaultTransactionOptions = typeof defaultOptions === "boolean" ? { allowNestedTransactions: defaultOptions } : defaultOptions;
+	const allowNestedTransactions = options?.allowNestedTransactions ?? defaultTransactionOptions.allowNestedTransactions ?? false;
 	const tx = databaseTransaction({
 		begin: async () => {
 			const client = await getClient;
@@ -2220,23 +2484,28 @@ const sqliteTransaction = (driverType, connection, allowNestedTransactions, seri
 		},
 		releaseSavepoint: async (level) => {
 			await (await getClient).command(SQL`RELEASE transaction${SQL.plain(level.toString())}`);
+		},
+		rollbackToSavepoint: async (level) => {
+			await (await getClient).command(SQL`ROLLBACK TO transaction${SQL.plain(level.toString())}`);
 		}
 	}, {
 		allowNestedTransactions,
-		useSavepoints
+		useSavepoints: options?.useSavepoints ?? defaultTransactionOptions.useSavepoints ?? false
 	});
-	return {
+	const transaction = {
 		connection: connection(),
 		driverType,
 		begin: tx.begin,
 		commit: tx.commit,
 		rollback: tx.rollback,
 		execute: sqlExecutor(sqliteSQLExecutor(driverType, serializer), { connect: () => getClient }),
+		withTransaction: (handle, options) => executeInNestedTransaction(transaction, handle, options),
 		_transactionOptions: {
 			...options,
 			allowNestedTransactions
 		}
 	};
+	return transaction;
 };
 
 //#endregion
@@ -2281,7 +2550,7 @@ const sqliteAmbientClientConnection = (options) => {
 	return createAmbientConnection({
 		driverType,
 		client,
-		initTransaction: initTransaction ?? ((connection) => sqliteTransaction(driverType, connection, allowNestedTransactions ?? false, serializer, defaultTransactionMode)),
+		initTransaction: initTransaction ?? ((connection) => sqliteTransaction(driverType, connection, { allowNestedTransactions: allowNestedTransactions ?? false }, serializer, defaultTransactionMode)),
 		executor: ({ serializer }) => sqliteSQLExecutor(driverType, serializer, void 0, errorMapper),
 		serializer
 	});
@@ -2306,7 +2575,7 @@ const sqliteClientConnection = (options) => {
 			if (client && "close" in client && typeof client.close === "function") await client.close();
 			else if (client && "release" in client && typeof client.release === "function") client.release();
 		},
-		initTransaction: (connection) => sqliteTransaction(options.driverType, connection, connectionOptions.transactionOptions?.allowNestedTransactions ?? false, serializer, connectionOptions.defaultTransactionMode),
+		initTransaction: (connection) => sqliteTransaction(options.driverType, connection, connectionOptions.transactionOptions ?? {}, serializer, connectionOptions.defaultTransactionMode),
 		executor: ({ serializer }) => sqliteSQLExecutor(options.driverType, serializer),
 		serializer
 	});
@@ -2328,7 +2597,7 @@ const sqlitePoolClientConnection = (options) => {
 		driverType: options.driverType,
 		connect,
 		close: () => client !== null ? Promise.resolve(client.release()) : Promise.resolve(),
-		initTransaction: (connection) => sqliteTransaction(options.driverType, connection, connectionOptions.transactionOptions?.allowNestedTransactions ?? false, serializer, connectionOptions.defaultTransactionMode),
+		initTransaction: (connection) => sqliteTransaction(options.driverType, connection, connectionOptions.transactionOptions ?? {}, serializer, connectionOptions.defaultTransactionMode),
 		executor: ({ serializer }) => sqliteSQLExecutor(options.driverType, serializer),
 		serializer
 	});
@@ -2702,43 +2971,67 @@ const sqlite3Connection = (options) => sqliteConnection({
 //#endregion
 //#region src/storage/sqlite/sqlite3/pool/singletonPool.ts
 const DEFAULT_SQLITE_MAX_TASK_IDLE_TIME_MS = 3e4;
+const createSQLiteTransactionContext = () => {
+	if (typeof process === "undefined") return void 0;
+	const asyncHooks = process.getBuiltinModule?.("node:async_hooks");
+	if (!asyncHooks) return void 0;
+	const context = new asyncHooks.AsyncLocalStorage();
+	return {
+		current: () => context.getStore(),
+		run: (active, handle) => context.run(active, handle)
+	};
+};
 const sqlite3SingletonPool = (options) => {
-	const maxTaskIdleTime = options.maxTaskIdleTime ?? 3e4;
 	const inner = createSingletonConnectionPool({
 		driverType: options.driverType,
 		getConnection: options.getConnection,
 		...options.closeConnection ? { closeConnection: options.closeConnection } : {}
 	});
-	const taskProcessor = new TaskProcessor({
-		maxActiveTasks: 1,
+	const writerGuard = guardExclusiveAccess({
 		maxQueueSize: options.maxQueueSize ?? 1e3,
-		maxTaskIdleTime
+		maxTaskIdleTime: options.maxTaskIdleTime ?? 3e4
 	});
-	const insideWriterTask = new node_async_hooks.AsyncLocalStorage();
-	const enqueue = (op) => {
-		if (insideWriterTask.getStore() === true) return op();
-		return taskProcessor.enqueue(({ ack }) => insideWriterTask.run(true, async () => {
-			try {
-				return await op();
-			} finally {
-				ack();
-			}
-		}));
+	const transactionContext = options.transactionContext ?? createSQLiteTransactionContext();
+	const activeConnection = () => transactionContext?.current()?.connection;
+	const runInTransactionContext = (connection, operation) => transactionContext ? transactionContext.run({ connection }, operation) : operation();
+	const transactionAwareConnection = (connection) => transactionContext ? {
+		...connection,
+		withTransaction: (handle, transactionOptions) => runInTransactionContext(connection, () => connection.withTransaction(handle, transactionOptions))
+	} : connection;
+	const runConnectionTransaction = (connection, handle, context, transactionOptions) => {
+		const withTransaction = connection.withTransaction;
+		return withTransaction((transaction) => handle(transaction, context), transactionOptions);
+	};
+	const runOnWriterConnection = (handle, options) => {
+		const connection = activeConnection();
+		if (connection) return inner.withConnection((_connection, context) => handle(connection, context), options);
+		return writerGuard.execute((context) => inner.withConnection((connection) => handle(connection, context), options), options);
 	};
+	const withWriterConnection = (handle, options) => runOnWriterConnection((connection, context) => handle(transactionAwareConnection(connection), context), options);
 	return {
 		driverType: inner.driverType,
 		connection: inner.connection.bind(inner),
 		transaction: inner.transaction.bind(inner),
-		withConnection: (handle, connectionOptions) => enqueue(() => inner.withConnection(handle, connectionOptions)),
-		withTransaction: (handle, transactionOptions) => enqueue(() => inner.withTransaction(handle, transactionOptions)),
+		withConnection: (handle, connectionOptions) => activeConnection() || !connectionOptions?.readonly ? withWriterConnection(handle, connectionOptions) : inner.withConnection(handle, connectionOptions),
+		withTransaction: (handle, transactionOptions) => {
+			const connection = activeConnection();
+			if (connection) return inner.withConnection((_connection, context) => runConnectionTransaction(connection, handle, context, transactionOptions), transactionOptions);
+			return runOnWriterConnection((connection, context) => runInTransactionContext(connection, () => runConnectionTransaction(connection, handle, context, transactionOptions)), transactionOptions);
+		},
 		execute: {
-			query: (sql, queryOptions) => enqueue(() => inner.execute.query(sql, queryOptions)),
-			batchQuery: (sqls, queryOptions) => enqueue(() => inner.execute.batchQuery(sqls, queryOptions)),
-			command: (sql, commandOptions) => enqueue(() => inner.execute.command(sql, commandOptions)),
-			batchCommand: (sqls, commandOptions) => enqueue(() => inner.execute.batchCommand(sqls, commandOptions))
+			query: (sql, queryOptions) => {
+				const connection = activeConnection();
+				return connection ? connection.execute.query(sql, queryOptions) : inner.execute.query(sql, queryOptions);
+			},
+			batchQuery: (sqls, queryOptions) => {
+				const connection = activeConnection();
+				return connection ? connection.execute.batchQuery(sqls, queryOptions) : inner.execute.batchQuery(sqls, queryOptions);
+			},
+			command: (sql, commandOptions) => runOnWriterConnection((connection) => connection.execute.command(sql, commandOptions), commandOptions),
+			batchCommand: (sqls, commandOptions) => runOnWriterConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), commandOptions)
 		},
 		close: async (closeOptions) => {
-			await taskProcessor.stop({ ...closeOptions?.force ? { force: true } : {} });
+			await writerGuard.stop(closeOptions);
 			await inner.close(closeOptions);
 		}
 	};
@@ -2749,15 +3042,16 @@ const sqlite3SingletonPool = (options) => {
 const sqliteDualConnectionPool = (options) => {
 	const { sqliteConnectionFactory, connectionOptions } = options;
 	const readerPoolSize = options.readerPoolSize ?? Math.max(4, (0, os.cpus)().length);
+	const transactionContext = createSQLiteTransactionContext();
 	let databaseInitPromise = null;
-	const guardSingleConnection = guardInitializedOnce(async () => {
+	const guardSingleConnection = guardInitializedOnce(async (context) => {
 		if (databaseInitPromise !== null) return databaseInitPromise;
 		const initConnection = sqliteConnectionFactory({
 			...connectionOptions,
 			skipDatabasePragmas: false,
 			readonly: false
 		});
-		const initPromise = initConnection.open();
+		const initPromise = initConnection.open(context);
 		databaseInitPromise = initPromise;
 		try {
 			await initPromise;
@@ -2768,45 +3062,47 @@ const sqliteDualConnectionPool = (options) => {
 			throw mapSqliteError(error);
 		}
 	});
-	const ensureDatabaseInitialized = async () => {
+	const ensureDatabaseInitialized = async (context) => {
 		if (databaseInitPromise !== null) return databaseInitPromise;
-		return guardSingleConnection.ensureInitialized();
+		return guardSingleConnection.ensureInitialized({ abort: context.abort });
 	};
-	const wrappedConnectionFactory = async (readonly, connectionOptions) => {
-		await ensureDatabaseInitialized();
+	const wrappedConnectionFactory = async (readonly, connectionOptions, context) => {
+		await ensureDatabaseInitialized(context);
 		const connection = sqliteConnectionFactory({
 			...connectionOptions,
 			skipDatabasePragmas: true,
 			readonly
 		});
-		await connection.open();
+		await connection.open(context);
 		return connection;
 	};
 	const writerPool = sqlite3SingletonPool({
 		driverType: options.driverType,
-		getConnection: () => wrappedConnectionFactory(false, connectionOptions),
+		getConnection: (context) => wrappedConnectionFactory(false, connectionOptions, context),
+		...transactionContext ? { transactionContext } : {},
 		...options.maxTaskIdleTime !== void 0 ? { maxTaskIdleTime: options.maxTaskIdleTime } : {}
 	});
 	const readerPool = createBoundedConnectionPool({
 		driverType: options.driverType,
-		getConnection: () => wrappedConnectionFactory(true, connectionOptions),
+		getConnection: (context) => wrappedConnectionFactory(true, connectionOptions, context),
 		maxConnections: readerPoolSize
 	});
+	const hasActiveTransaction = () => !!transactionContext?.current();
 	return {
 		driverType: options.driverType,
-		connection: (connectionOptions) => connectionOptions?.readonly ? readerPool.connection(connectionOptions) : writerPool.connection(connectionOptions),
+		connection: (connectionOptions) => connectionOptions?.readonly && !hasActiveTransaction() ? readerPool.connection(connectionOptions) : writerPool.connection(connectionOptions),
 		execute: {
-			query: (...args) => readerPool.execute.query(...args),
-			batchQuery: (...args) => readerPool.execute.batchQuery(...args),
+			query: (...args) => hasActiveTransaction() ? writerPool.execute.query(...args) : readerPool.execute.query(...args),
+			batchQuery: (...args) => hasActiveTransaction() ? writerPool.execute.batchQuery(...args) : readerPool.execute.batchQuery(...args),
 			command: (...args) => writerPool.execute.command(...args),
 			batchCommand: (...args) => writerPool.execute.batchCommand(...args)
 		},
-		withConnection: (handle, connectionOptions) => connectionOptions?.readonly ? readerPool.withConnection(handle, connectionOptions) : writerPool.withConnection(handle, connectionOptions),
+		withConnection: (handle, connectionOptions) => connectionOptions?.readonly && !hasActiveTransaction() ? readerPool.withConnection(handle, connectionOptions) : writerPool.withConnection(handle, connectionOptions),
 		transaction: writerPool.transaction,
 		withTransaction: writerPool.withTransaction,
-		close: async () => {
-			await guardSingleConnection.stop();
-			await Promise.all([writerPool.close(), readerPool.close()]);
+		close: async (closeOptions) => {
+			await guardSingleConnection.stop(closeOptions);
+			await Promise.all([writerPool.close(closeOptions), readerPool.close(closeOptions)]);
 		}
 	};
 };