@event-driven-io/dumbo 0.13.0-beta.42 → 0.13.0-beta.44

package/dist/sqlite3.cjs

@@ -1,17 +1,2458 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_core = require('./core-BPSzA-lq.cjs');
-const require_sqliteMetadata = require('./sqliteMetadata-Cc7Z03lm.cjs');
-const require_core$1 = require('./core-CUGYxOEQ.cjs');
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let uuid = require("uuid");
+let ansis = require("ansis");
+ansis = __toESM(ansis, 1);
 let sqlite3 = require("sqlite3");
-sqlite3 = require_core.__toESM(sqlite3, 1);
+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;
+const isString = (val) => typeof val === "string";
+var DumboError = class DumboError extends Error {
+	static ErrorCode = 500;
+	static ErrorType = "DumboError";
+	errorCode;
+	errorType;
+	innerError;
+	constructor(options) {
+		const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : DumboError.ErrorCode;
+		const errorType = options && typeof options === "object" && "errorType" in options ? options.errorType ?? DumboError.ErrorType : DumboError.ErrorType;
+		const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during DumboError processing`;
+		const innerError = options && typeof options === "object" && "innerError" in options ? options.innerError : void 0;
+		super(message, { cause: innerError });
+		this.errorCode = errorCode;
+		this.errorType = errorType;
+		this.innerError = innerError;
+		Object.setPrototypeOf(this, DumboError.prototype);
+	}
+	static isInstanceOf(error, options) {
+		if (typeof error !== "object" || error === null || !("errorCode" in error) || !isNumber(error.errorCode) || !("errorType" in error) || !isString(error.errorType)) return false;
+		if (!options) return true;
+		if (options.errorCode !== void 0 && error.errorCode !== options.errorCode) return false;
+		if (options.errorType !== void 0 && error.errorType !== options.errorType) return false;
+		return true;
+	}
+};
+var TransientDatabaseError = class TransientDatabaseError extends DumboError {
+	static ErrorCode = 503;
+	static ErrorType = "TransientDatabaseError";
+	constructor(message, innerError) {
+		super({
+			errorCode: TransientDatabaseError.ErrorCode,
+			errorType: TransientDatabaseError.ErrorType,
+			message: message ?? `A transient error occurred during database operation. Retrying the operation might succeed.`,
+			innerError
+		});
+		Object.setPrototypeOf(this, TransientDatabaseError.prototype);
+	}
+};
+var ConnectionError = class ConnectionError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "ConnectionError";
+	constructor(message, innerError) {
+		super(message ?? `A connection error occurred during database operation.`, innerError);
+		this.errorType = ConnectionError.ErrorType;
+		Object.setPrototypeOf(this, ConnectionError.prototype);
+	}
+};
+var SerializationError = class SerializationError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "SerializationError";
+	constructor(message, innerError) {
+		super(message ?? `A serialization failure occurred. The transaction can be retried.`, innerError);
+		this.errorType = SerializationError.ErrorType;
+		Object.setPrototypeOf(this, SerializationError.prototype);
+	}
+};
+var DeadlockError = class DeadlockError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "DeadlockError";
+	constructor(message, innerError) {
+		super(message ?? `A deadlock was detected. The transaction can be retried.`, innerError);
+		this.errorType = DeadlockError.ErrorType;
+		Object.setPrototypeOf(this, DeadlockError.prototype);
+	}
+};
+var LockNotAvailableError = class LockNotAvailableError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "LockNotAvailableError";
+	constructor(message, innerError) {
+		super(message ?? `The requested lock is not available.`, innerError);
+		this.errorType = LockNotAvailableError.ErrorType;
+		Object.setPrototypeOf(this, LockNotAvailableError.prototype);
+	}
+};
+var InsufficientResourcesError = class InsufficientResourcesError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "InsufficientResourcesError";
+	constructor(message, innerError) {
+		super(message ?? `Insufficient resources to complete the database operation (e.g. disk full, out of memory, too many connections).`, innerError);
+		this.errorType = InsufficientResourcesError.ErrorType;
+		Object.setPrototypeOf(this, InsufficientResourcesError.prototype);
+	}
+};
+var SystemError = class SystemError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "SystemError";
+	constructor(message, innerError) {
+		super(message ?? `A system-level error occurred (e.g. I/O error).`, innerError);
+		this.errorType = SystemError.ErrorType;
+		Object.setPrototypeOf(this, SystemError.prototype);
+	}
+};
+var IntegrityConstraintViolationError = class IntegrityConstraintViolationError extends DumboError {
+	static ErrorCode = 409;
+	static ErrorType = "IntegrityConstraintViolationError";
+	constructor(message, innerError) {
+		super({
+			errorCode: IntegrityConstraintViolationError.ErrorCode,
+			errorType: IntegrityConstraintViolationError.ErrorType,
+			message: message ?? `An integrity constraint violation occurred!`,
+			innerError
+		});
+		Object.setPrototypeOf(this, IntegrityConstraintViolationError.prototype);
+	}
+};
+var UniqueConstraintError = class UniqueConstraintError extends IntegrityConstraintViolationError {
+	static ErrorCode = 409;
+	static ErrorType = "UniqueConstraintError";
+	constructor(message, innerError) {
+		super(message ?? `Unique constraint violation occurred!`, innerError);
+		this.errorType = UniqueConstraintError.ErrorType;
+		Object.setPrototypeOf(this, UniqueConstraintError.prototype);
+	}
+};
+var ForeignKeyViolationError = class ForeignKeyViolationError extends IntegrityConstraintViolationError {
+	static ErrorCode = 409;
+	static ErrorType = "ForeignKeyViolationError";
+	constructor(message, innerError) {
+		super(message ?? `Foreign key constraint violation occurred!`, innerError);
+		this.errorType = ForeignKeyViolationError.ErrorType;
+		Object.setPrototypeOf(this, ForeignKeyViolationError.prototype);
+	}
+};
+var NotNullViolationError = class NotNullViolationError extends IntegrityConstraintViolationError {
+	static ErrorCode = 409;
+	static ErrorType = "NotNullViolationError";
+	constructor(message, innerError) {
+		super(message ?? `NOT NULL constraint violation occurred!`, innerError);
+		this.errorType = NotNullViolationError.ErrorType;
+		Object.setPrototypeOf(this, NotNullViolationError.prototype);
+	}
+};
+var CheckViolationError = class CheckViolationError extends IntegrityConstraintViolationError {
+	static ErrorCode = 409;
+	static ErrorType = "CheckViolationError";
+	constructor(message, innerError) {
+		super(message ?? `CHECK constraint violation occurred!`, innerError);
+		this.errorType = CheckViolationError.ErrorType;
+		Object.setPrototypeOf(this, CheckViolationError.prototype);
+	}
+};
+var DataError = class DataError extends DumboError {
+	static ErrorCode = 400;
+	static ErrorType = "DataError";
+	constructor(message, innerError) {
+		super({
+			errorCode: DataError.ErrorCode,
+			errorType: DataError.ErrorType,
+			message: message ?? `A data error occurred (e.g. invalid value, type mismatch).`,
+			innerError
+		});
+		Object.setPrototypeOf(this, DataError.prototype);
+	}
+};
+var InvalidOperationError = class InvalidOperationError extends DumboError {
+	static ErrorCode = 400;
+	static ErrorType = "InvalidOperationError";
+	constructor(message, innerError) {
+		super({
+			errorCode: InvalidOperationError.ErrorCode,
+			errorType: InvalidOperationError.ErrorType,
+			message: message ?? `Invalid operation (e.g. syntax error, insufficient privileges, undefined table).`,
+			innerError
+		});
+		Object.setPrototypeOf(this, InvalidOperationError.prototype);
+	}
+};
+
+//#endregion
+//#region src/core/execute/execute.ts
+const mapSQLQueryResult = (result, mapping) => {
+	if (typeof result !== "object" || result === null) return result;
+	const mappedResult = { ...result };
+	for (const column of Object.keys(mapping)) if (column in mappedResult) mappedResult[column] = mapping[column](mappedResult[column]);
+	return mappedResult;
+};
+var BatchCommandNoChangesError = class BatchCommandNoChangesError extends DumboError {
+	static ErrorCode = 409;
+	static ErrorType = "BatchCommandNoChangesError";
+	statementIndex;
+	constructor(statementIndex) {
+		super({
+			errorCode: BatchCommandNoChangesError.ErrorCode,
+			errorType: BatchCommandNoChangesError.ErrorType,
+			message: `Batch command at index ${statementIndex} affected no rows`
+		});
+		this.name = "BatchCommandNoChangesError";
+		this.statementIndex = statementIndex;
+		Object.setPrototypeOf(this, BatchCommandNoChangesError.prototype);
+	}
+};
+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)
+});
+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)
+});
+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)
+});
+const executeInNewDbClient = async (handle, options) => {
+	const { connect, close } = options;
+	const client = await connect();
+	try {
+		return await handle(client);
+	} catch (error) {
+		if (close) await close(client, error);
+		throw error;
+	}
+};
+const executeInNewConnection = async (handle, options) => {
+	const connection = await options.connection();
+	try {
+		return await handle(connection);
+	} finally {
+		await connection.close();
+	}
+};
+const executeInAmbientConnection = async (handle, options) => {
+	const connection = await options.connection();
+	try {
+		return await handle(connection);
+	} finally {}
+};
+
+//#endregion
+//#region src/core/connections/transaction.ts
+const transactionNestingCounter = () => {
+	let transactionLevel = 0;
+	return {
+		reset: () => {
+			transactionLevel = 0;
+		},
+		increment: () => {
+			transactionLevel++;
+		},
+		decrement: () => {
+			transactionLevel--;
+			if (transactionLevel < 0) throw new Error("Transaction level is out of bounds");
+		},
+		get level() {
+			return transactionLevel;
+		}
+	};
+};
+const databaseTransaction = (backend, options) => {
+	const allowNestedTransactions = options?.allowNestedTransactions ?? false;
+	const useSavepoints = options?.useSavepoints ?? false;
+	const counter = transactionNestingCounter();
+	let hasBegun = false;
+	return {
+		begin: async () => {
+			if (!allowNestedTransactions && hasBegun) throw new InvalidOperationError("Cannot start a nested transaction: allowNestedTransactions is false. Set transactionOptions: { allowNestedTransactions: true } on your pool or connection.");
+			if (allowNestedTransactions) {
+				if (counter.level >= 1) {
+					counter.increment();
+					if (useSavepoints && backend.savepoint) await backend.savepoint(counter.level);
+					return;
+				}
+				counter.increment();
+			}
+			hasBegun = true;
+			await backend.begin();
+		},
+		commit: async () => {
+			if (allowNestedTransactions && counter.level > 1) {
+				if (useSavepoints && backend.releaseSavepoint) await backend.releaseSavepoint(counter.level);
+				counter.decrement();
+				return;
+			}
+			if (allowNestedTransactions) counter.reset();
+			hasBegun = false;
+			await backend.commit();
+		},
+		rollback: async (error) => {
+			if (allowNestedTransactions && counter.level > 1) {
+				if (useSavepoints && backend.rollbackToSavepoint) await backend.rollbackToSavepoint(counter.level);
+				counter.decrement();
+				return;
+			}
+			if (allowNestedTransactions) counter.reset();
+			hasBegun = false;
+			await backend.rollback(error);
+		}
+	};
+};
+const toTransactionResult = (transactionResult) => transactionResult !== void 0 && transactionResult !== null && typeof transactionResult === "object" && "success" in transactionResult ? transactionResult : {
+	success: true,
+	result: transactionResult
+};
+const executeInTransaction = async (transaction, handle) => {
+	await transaction.begin();
+	try {
+		const { success, result } = toTransactionResult(await handle(transaction));
+		if (success) await transaction.commit();
+		else await transaction.rollback();
+		return result;
+	} catch (e) {
+		await transaction.rollback();
+		throw e;
+	}
+};
+const transactionFactoryWithDbClient = (connect, initTransaction) => {
+	let currentTransaction = void 0;
+	const getOrInitCurrentTransaction = (options) => currentTransaction ?? (currentTransaction = initTransaction(connect(), {
+		close: () => {
+			currentTransaction = void 0;
+			return Promise.resolve();
+		},
+		...options ?? {}
+	}));
+	return {
+		transaction: getOrInitCurrentTransaction,
+		withTransaction: (handle, options) => executeInTransaction(getOrInitCurrentTransaction(options), handle)
+	};
+};
+const wrapInConnectionClosure = async (connection, handle) => {
+	try {
+		return await handle();
+	} finally {
+		await connection.close();
+	}
+};
+const transactionFactoryWithNewConnection = (connect) => ({
+	transaction: (options) => {
+		const connection = connect();
+		const transaction = connection.transaction(options);
+		return {
+			...transaction,
+			commit: () => wrapInConnectionClosure(connection, () => transaction.commit()),
+			rollback: () => wrapInConnectionClosure(connection, () => transaction.rollback())
+		};
+	},
+	withTransaction: (handle, options) => {
+		const connection = connect();
+		const withTx = connection.withTransaction;
+		return wrapInConnectionClosure(connection, () => withTx(handle, options));
+	}
+});
+const transactionFactoryWithAsyncAmbientConnection = (driverType, connect, close) => {
+	close ??= () => Promise.resolve();
+	return {
+		transaction: (options) => {
+			let conn = null;
+			let innerTx = null;
+			let connectingPromise = null;
+			const ensureConnection = async () => {
+				if (conn) return innerTx;
+				if (!connectingPromise) connectingPromise = (async () => {
+					conn = await connect();
+					innerTx = conn.transaction(options);
+				})();
+				await connectingPromise;
+				return innerTx;
+			};
+			return {
+				driverType,
+				get connection() {
+					if (!conn) throw new Error("Transaction not started - call begin() first");
+					return conn;
+				},
+				execute: {
+					query: async (sql, queryOptions) => {
+						return (await ensureConnection()).execute.query(sql, queryOptions);
+					},
+					batchQuery: async (sqls, queryOptions) => {
+						return (await ensureConnection()).execute.batchQuery(sqls, queryOptions);
+					},
+					command: async (sql, commandOptions) => {
+						return (await ensureConnection()).execute.command(sql, commandOptions);
+					},
+					batchCommand: async (sqls, commandOptions) => {
+						return (await ensureConnection()).execute.batchCommand(sqls, commandOptions);
+					}
+				},
+				begin: async () => {
+					return (await ensureConnection()).begin();
+				},
+				commit: async () => {
+					if (!innerTx) throw new Error("Transaction not started");
+					try {
+						return await innerTx.commit();
+					} finally {
+						if (conn) await close(conn);
+					}
+				},
+				rollback: async (error) => {
+					if (!innerTx) {
+						if (conn) await close(conn);
+						return;
+					}
+					try {
+						return await innerTx.rollback(error);
+					} finally {
+						if (conn) await close(conn);
+					}
+				},
+				_transactionOptions: void 0
+			};
+		},
+		withTransaction: async (handle, options) => {
+			const conn = await connect();
+			try {
+				const withTx = conn.withTransaction;
+				return await withTx(handle, options);
+			} finally {
+				await close(conn);
+			}
+		}
+	};
+};
+
+//#endregion
+//#region src/core/connections/connection.ts
+const createAmbientConnection = (options) => {
+	const { driverType, client, executor, initTransaction, serializer } = options;
+	const clientPromise = Promise.resolve(client);
+	const closePromise = Promise.resolve();
+	const open = () => clientPromise;
+	const close = () => closePromise;
+	const typedConnection = {
+		driverType,
+		open,
+		close,
+		...transactionFactoryWithDbClient(open, initTransaction(() => typedConnection)),
+		execute: sqlExecutor(executor({ serializer }), { connect: open }),
+		_transactionType: void 0
+	};
+	return typedConnection;
+};
+const createConnection = (options) => {
+	const { driverType, connect, close, initTransaction, executor, serializer } = options;
+	let client = null;
+	let connectPromise = null;
+	const getClient = async () => {
+		if (client) return client;
+		if (!connectPromise) connectPromise = connect().then((c) => {
+			client = c;
+			return c;
+		});
+		return connectPromise;
+	};
+	const typedConnection = {
+		driverType,
+		open: getClient,
+		close: () => client ? close(client) : Promise.resolve(),
+		...transactionFactoryWithDbClient(getClient, initTransaction(() => typedConnection)),
+		execute: sqlExecutor(executor({ serializer }), { connect: getClient }),
+		_transactionType: void 0
+	};
+	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) => ({
+	...conn,
+	close: onClose
+});
+const createAmbientConnectionPool = (options) => {
+	const { driverType, connection } = options;
+	return createConnectionPool({
+		driverType,
+		getConnection: () => connection,
+		execute: connection.execute,
+		transaction: (options) => connection.transaction(options),
+		withConnection: (handle, _options) => handle(connection),
+		withTransaction: (handle, options) => {
+			const withTx = connection.withTransaction;
+			return withTx(handle, options);
+		}
+	});
+};
+const createSingletonConnectionPool = (options) => {
+	const { driverType, getConnection } = options;
+	let connectionPromise = null;
+	let closed = false;
+	const activeOperations = /* @__PURE__ */ new Set();
+	const closedError = () => /* @__PURE__ */ new Error("Singleton connection pool has been closed");
+	const run = async (operation) => {
+		if (closed) throw closedError();
+		const activeOperation = operation();
+		activeOperations.add(activeOperation);
+		try {
+			return await activeOperation;
+		} finally {
+			activeOperations.delete(activeOperation);
+		}
+	};
+	const getExistingOrNewConnection = () => {
+		if (!connectionPromise) connectionPromise ??= Promise.resolve(getConnection());
+		return connectionPromise;
+	};
+	const innerTransactionFactory = transactionFactoryWithAsyncAmbientConnection(options.driverType, getExistingOrNewConnection, options.closeConnection);
+	return {
+		driverType,
+		connection: () => run(() => getExistingOrNewConnection().then((conn) => wrapPooledConnection(conn, () => Promise.resolve()))),
+		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))
+			};
+		})(),
+		withConnection: (handle, _options) => run(() => executeInAmbientConnection(handle, { connection: getExistingOrNewConnection })),
+		transaction: (transactionOptions) => {
+			if (closed) throw closedError();
+			return innerTransactionFactory.transaction(transactionOptions);
+		},
+		withTransaction: (handle, transactionOptions) => run(() => innerTransactionFactory.withTransaction(handle, transactionOptions)),
+		close: async (closeOptions) => {
+			if (closed) return;
+			closed = true;
+			if (!closeOptions?.force) await Promise.allSettled([...activeOperations]);
+			if (!connectionPromise) return;
+			const connection = await connectionPromise;
+			connectionPromise = null;
+			await connection.close();
+		}
+	};
+};
+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, {
+		maxResources: maxConnections,
+		reuseResources: true
+	});
+	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) => {
+		ensureOpen();
+		const conn = await guardMaxConnections.acquire();
+		try {
+			return await operation(conn);
+		} finally {
+			guardMaxConnections.release(conn);
+		}
+	};
+	return {
+		driverType,
+		connection: async () => {
+			ensureOpen();
+			const conn = await guardMaxConnections.acquire();
+			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))
+		},
+		withConnection: executeWithPooling,
+		transaction: (transactionOptions) => {
+			ensureOpen();
+			return transactionFactoryWithAsyncAmbientConnection(driverType, guardMaxConnections.acquire, guardMaxConnections.release).transaction(transactionOptions);
+		},
+		withTransaction: (handle, transactionOptions) => executeWithPooling((conn) => {
+			const withTx = conn.withTransaction;
+			return withTx(handle, transactionOptions);
+		}),
+		close: async (closeOptions) => {
+			if (closed) return;
+			closed = true;
+			if (!closeOptions?.force) await guardMaxConnections.waitForIdle();
+			await guardMaxConnections.stop({ force: true });
+			await closeAllConnections();
+		}
+	};
+};
+const createAlwaysNewConnectionPool = (options) => {
+	const { driverType, getConnection, connectionOptions } = options;
+	return createConnectionPool({
+		driverType,
+		getConnection: () => connectionOptions ? getConnection(connectionOptions) : getConnection()
+	});
+};
+const createConnectionPool = (pool) => {
+	const { driverType, getConnection } = pool;
+	const connection = "connection" in pool ? pool.connection : () => Promise.resolve(getConnection());
+	return {
+		driverType,
+		connection,
+		withConnection: "withConnection" in pool ? pool.withConnection : (handle, _options) => executeInNewConnection(handle, { connection }),
+		close: "close" in pool ? pool.close : () => Promise.resolve(),
+		execute: "execute" in pool ? pool.execute : sqlExecutorInNewConnection({
+			driverType,
+			connection
+		}),
+		..."transaction" in pool && "withTransaction" in pool ? {
+			transaction: pool.transaction,
+			withTransaction: pool.withTransaction
+		} : transactionFactoryWithNewConnection(getConnection)
+	};
+};
+
+//#endregion
+//#region src/core/drivers/databaseDriver.ts
+const canHandleDriverWithConnectionString = (driver, tryParseConnectionString) => (options) => {
+	if ("driverType" in options) return options.driverType === driver;
+	if ("connectionString" in options && typeof options.connectionString === "string") return tryParseConnectionString(options.connectionString) !== null;
+	return false;
+};
+const DumboDatabaseDriverRegistry = () => {
+	const drivers = /* @__PURE__ */ new Map();
+	const register = (driverType, plugin) => {
+		const entry = drivers.get(driverType);
+		if (entry && (typeof entry !== "function" || typeof plugin === "function")) return;
+		drivers.set(driverType, plugin);
+	};
+	const getDriver = (options) => options.driverType ? drivers.get(options.driverType) : [...drivers.values()].find((d) => typeof d !== "function" && d.canHandle(options));
+	const tryResolve = async (options) => {
+		const driver = getDriver(options);
+		if (!driver) return null;
+		if (typeof driver !== "function") return driver;
+		const plugin = await driver();
+		register(plugin.driverType, plugin);
+		return plugin;
+	};
+	const tryGet = (options) => {
+		const driver = getDriver(options);
+		return driver && typeof driver !== "function" ? driver : null;
+	};
+	const has = (driverType) => drivers.has(driverType);
+	return {
+		register,
+		tryResolve,
+		tryGet,
+		has,
+		get databaseDriverTypes() {
+			return Array.from(drivers.keys());
+		}
+	};
+};
+const dumboDatabaseDriverRegistry = globalThis.dumboDatabaseDriverRegistry = globalThis.dumboDatabaseDriverRegistry ?? DumboDatabaseDriverRegistry();
+
+//#endregion
+//#region src/core/query/selectors.ts
+const single = async (getResult) => {
+	const result = await getResult;
+	if (result.rows.length === 0) throw new Error("Query didn't return any result");
+	if (result.rows.length > 1) throw new Error("Query had more than one result");
+	return result.rows[0];
+};
+const exists = async (getResult) => {
+	const result = await single(getResult);
+	return result.exists === true || result.exists === 1;
+};
+
+//#endregion
+//#region src/core/schema/schemaComponent.ts
+const schemaComponent = (key, options) => {
+	const componentsMap = new Map(options.components?.map((comp) => [comp.schemaComponentKey, comp]));
+	const migrations = [...options.migrations ?? []];
+	return {
+		schemaComponentKey: key,
+		components: componentsMap,
+		get migrations() {
+			return [...migrations, ...Array.from(componentsMap.values()).flatMap((c) => c.migrations)];
+		},
+		addComponent: (component) => {
+			componentsMap.set(component.schemaComponentKey, component);
+			migrations.push(...component.migrations);
+			return component;
+		},
+		addMigration: (migration) => {
+			migrations.push(migration);
+		}
+	};
+};
+const isSchemaComponentOfType = (component, prefix) => component.schemaComponentKey.startsWith(prefix);
+const mapSchemaComponentsOfType = (components, prefix, keyMapper) => new Map(Array.from(components.entries()).filter(([urn]) => urn.startsWith(prefix)).map(([urn, component]) => [keyMapper ? keyMapper(component) : urn, component]));
+
+//#endregion
+//#region src/core/schema/components/columnSchemaComponent.ts
+const ColumnURNType = "sc:dumbo:column";
+const ColumnURN = ({ name }) => `${ColumnURNType}:${name}`;
+const columnSchemaComponent = (params) => {
+	const { columnName, type, notNull, unique, primaryKey, default: defaultValue, ...schemaOptions } = params;
+	return {
+		...schemaComponent(ColumnURN({ name: columnName }), schemaOptions),
+		columnName,
+		notNull,
+		unique,
+		primaryKey,
+		defaultValue,
+		sqlTokenType: "SQL_COLUMN",
+		name: columnName,
+		type
+	};
+};
+
+//#endregion
+//#region src/core/schema/components/indexSchemaComponent.ts
+const IndexURNType = "sc:dumbo:index";
+
+//#endregion
+//#region src/core/schema/components/tableSchemaComponent.ts
+const TableURNType = "sc:dumbo:table";
+const TableURN = ({ name }) => `${TableURNType}:${name}`;
+const tableSchemaComponent = ({ tableName, columns, primaryKey, relationships, ...migrationsOrComponents }) => {
+	columns ??= {};
+	relationships ??= {};
+	const base = schemaComponent(TableURN({ name: tableName }), {
+		migrations: migrationsOrComponents.migrations ?? [],
+		components: [...migrationsOrComponents.components ?? [], ...Object.values(columns)]
+	});
+	return {
+		...base,
+		tableName,
+		primaryKey: primaryKey ?? [],
+		relationships,
+		get columns() {
+			const columnsMap = mapSchemaComponentsOfType(base.components, ColumnURNType, (c) => c.columnName);
+			return Object.assign(columnsMap, columns);
+		},
+		get indexes() {
+			return mapSchemaComponentsOfType(base.components, IndexURNType, (c) => c.indexName);
+		},
+		addColumn: (column) => base.addComponent(column),
+		addIndex: (index) => base.addComponent(index)
+	};
+};
+
+//#endregion
+//#region src/core/schema/components/databaseSchemaSchemaComponent.ts
+const DatabaseSchemaURNType = "sc:dumbo:database_schema";
+const DatabaseSchemaURN = ({ name }) => `${DatabaseSchemaURNType}:${name}`;
+const databaseSchemaSchemaComponent = ({ schemaName, tables, ...migrationsOrComponents }) => {
+	const base = schemaComponent(DatabaseSchemaURN({ name: schemaName }), {
+		migrations: migrationsOrComponents.migrations ?? [],
+		components: [...migrationsOrComponents.components ?? [], ...Object.values(tables ?? {})]
+	});
+	return {
+		...base,
+		schemaName,
+		get tables() {
+			const tablesMap = mapSchemaComponentsOfType(base.components, TableURNType, (c) => c.tableName);
+			return Object.assign(tablesMap, tables);
+		},
+		addTable: (table) => base.addComponent(typeof table === "string" ? tableSchemaComponent({ tableName: table }) : table)
+	};
+};
+
+//#endregion
+//#region src/core/schema/components/databaseSchemaComponent.ts
+const DatabaseURNType = "sc:dumbo:database";
+const DatabaseURN = ({ name }) => `${DatabaseURNType}:${name}`;
+const databaseSchemaComponent = ({ databaseName, schemas, ...migrationsOrComponents }) => {
+	schemas ??= {};
+	const base = schemaComponent(DatabaseURN({ name: databaseName }), {
+		migrations: migrationsOrComponents.migrations ?? [],
+		components: [...migrationsOrComponents.components ?? [], ...Object.values(schemas)]
+	});
+	return {
+		...base,
+		databaseName,
+		get schemas() {
+			const schemasMap = mapSchemaComponentsOfType(base.components, DatabaseSchemaURNType, (c) => c.schemaName);
+			return Object.assign(schemasMap, schemas);
+		},
+		addSchema: (schema) => base.addComponent(typeof schema === "string" ? databaseSchemaSchemaComponent({ schemaName: schema }) : schema)
+	};
+};
+
+//#endregion
+//#region src/core/schema/databaseMetadata/databaseMetadata.ts
+const DumboDatabaseMetadataRegistry = () => {
+	const infos = /* @__PURE__ */ new Map();
+	const register = (databaseType, info) => {
+		const entry = infos.get(databaseType);
+		if (entry && (typeof entry !== "function" || typeof info === "function")) return;
+		infos.set(databaseType, info);
+	};
+	const tryResolve = async (databaseType) => {
+		const entry = infos.get(databaseType);
+		if (!entry) return null;
+		if (typeof entry !== "function") return entry;
+		const resolved = await entry();
+		register(databaseType, resolved);
+		return resolved;
+	};
+	const tryGet = (databaseType) => {
+		const entry = infos.get(databaseType);
+		return entry && typeof entry !== "function" ? entry : null;
+	};
+	const has = (databaseType) => infos.has(databaseType);
+	return {
+		register,
+		tryResolve,
+		tryGet,
+		has,
+		get databaseTypes() {
+			return Array.from(infos.keys());
+		}
+	};
+};
+const dumboDatabaseMetadataRegistry$1 = globalThis.dumboDatabaseMetadataRegistry = globalThis.dumboDatabaseMetadataRegistry ?? DumboDatabaseMetadataRegistry();
+
+//#endregion
+//#region src/core/schema/dumboSchema/dumboSchema.ts
+const DEFAULT_DATABASE_NAME = "__default_database__";
+const DEFAULT_DATABASE_SCHEMA_NAME = "__default_database_schema__";
+const dumboTable = (name, definition) => {
+	const { columns, indexes, primaryKey, relationships, ...options } = definition;
+	const components = [...indexes ? Object.values(indexes) : []];
+	return tableSchemaComponent({
+		tableName: name,
+		columns: columns ?? {},
+		primaryKey: primaryKey ?? [],
+		...relationships !== void 0 ? { relationships } : {},
+		components,
+		...options
+	});
+};
+function dumboDatabaseSchema(nameOrTables, tables, options) {
+	return databaseSchemaSchemaComponent({
+		schemaName: typeof nameOrTables === "string" ? nameOrTables : DEFAULT_DATABASE_SCHEMA_NAME,
+		tables: (typeof nameOrTables === "string" ? tables : nameOrTables) ?? {},
+		...options
+	});
+}
+dumboDatabaseSchema.from = (schemaName, tableNames) => {
+	const tables = tableNames.reduce((acc, tableName) => {
+		acc[tableName] = dumboTable(tableName, {});
+		return acc;
+	}, {});
+	return schemaName ? dumboDatabaseSchema(schemaName, tables) : dumboDatabaseSchema(tables);
+};
+function dumboDatabase(nameOrSchemas, schemasOrOptions, options) {
+	const databaseName = typeof nameOrSchemas === "string" ? nameOrSchemas : DEFAULT_DATABASE_NAME;
+	const schemasOrSchema = typeof nameOrSchemas === "string" ? schemasOrOptions ?? {} : nameOrSchemas;
+	return databaseSchemaComponent({
+		databaseName,
+		schemas: "schemaComponentKey" in schemasOrSchema && isSchemaComponentOfType(schemasOrSchema, "sc:dumbo:database_schema") ? { [DEFAULT_DATABASE_SCHEMA_NAME]: schemasOrSchema } : schemasOrSchema,
+		...typeof nameOrSchemas === "string" ? options : schemasOrOptions
+	});
+}
+dumboDatabase.from = (databaseName, schemaNames) => {
+	const schemas = schemaNames.reduce((acc, schemaName) => {
+		acc[schemaName] = dumboDatabaseSchema(schemaName, {});
+		return acc;
+	}, {});
+	return databaseName ? dumboDatabase(databaseName, schemas) : dumboDatabase(schemas);
+};
+dumboDatabase.defaultName = DEFAULT_DATABASE_NAME;
+dumboDatabaseSchema.defaultName = DEFAULT_DATABASE_SCHEMA_NAME;
+
+//#endregion
+//#region src/core/serializer/json/index.ts
+const bigIntReplacer = (_key, value) => {
+	return typeof value === "bigint" ? value.toString() : value;
+};
+const dateReplacer = (_key, value) => {
+	return value instanceof Date ? value.toISOString() : value;
+};
+const isFirstLetterNumeric = (str) => {
+	const c = str.charCodeAt(0);
+	return c >= 48 && c <= 57;
+};
+const isFirstLetterNumericOrMinus = (str) => {
+	const c = str.charCodeAt(0);
+	return c >= 48 && c <= 57 || c === 45;
+};
+const bigIntReviver = (_key, value, context) => {
+	if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) try {
+		return BigInt(context?.source ?? value.toString());
+	} catch {
+		return value;
+	}
+	if (typeof value === "string" && value.length > 15) {
+		if (isFirstLetterNumericOrMinus(value)) {
+			const num = Number(value);
+			if (Number.isFinite(num) && !Number.isSafeInteger(num)) try {
+				return BigInt(value);
+			} catch {}
+		}
+	}
+	return value;
+};
+const dateReviver = (_key, value) => {
+	if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
+		const date = new Date(value);
+		if (!isNaN(date.getTime())) return date;
+	}
+	return value;
+};
+const composeJSONReplacers = (...replacers) => {
+	const filteredReplacers = replacers.filter((r) => r !== void 0);
+	if (filteredReplacers.length === 0) return void 0;
+	return (key, value) => filteredReplacers.reduce((accValue, replacer) => replacer(key, accValue), value);
+};
+const composeJSONRevivers = (...revivers) => {
+	const filteredRevivers = revivers.filter((r) => r !== void 0);
+	if (filteredRevivers.length === 0) return void 0;
+	return (key, value, context) => filteredRevivers.reduce((accValue, reviver) => reviver(key, accValue, context), value);
+};
+const JSONReplacer = (opts) => composeJSONReplacers(opts?.replacer, opts?.failOnBigIntSerialization !== true ? JSONReplacers.bigInt : void 0, opts?.useDefaultDateSerialization !== true ? JSONReplacers.date : void 0);
+const JSONReviver = (opts) => composeJSONRevivers(opts?.reviver, opts?.parseBigInts === true ? JSONRevivers.bigInt : void 0, opts?.parseDates === true ? JSONRevivers.date : void 0);
+const JSONReplacers = {
+	bigInt: bigIntReplacer,
+	date: dateReplacer
+};
+const JSONRevivers = {
+	bigInt: bigIntReviver,
+	date: dateReviver
+};
+const jsonSerializer = (options) => {
+	const defaultReplacer = JSONReplacer(options);
+	const defaultReviver = JSONReviver(options);
+	return {
+		serialize: (object, serializerOptions) => JSON.stringify(object, serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer),
+		deserialize: (payload, deserializerOptions) => JSON.parse(payload, deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver)
+	};
+};
+const JSONSerializer = Object.assign(jsonSerializer(), { from: (options) => options?.serialization?.serializer ?? (options?.serialization?.options ? jsonSerializer(options?.serialization?.options) : JSONSerializer) });
+
+//#endregion
+//#region src/core/sql/parametrizedSQL/parametrizedSQL.ts
+const ParametrizedSQLBuilder = ({ mapParamPlaceholder }) => {
+	const sql = [];
+	const params = [];
+	return {
+		addSQL(str) {
+			sql.push(str);
+			return this;
+		},
+		addParam(value) {
+			sql.push(mapParamPlaceholder(params.length, value));
+			params.push(value);
+			return this;
+		},
+		addParams(values) {
+			const placeholders = values.map((value, i) => mapParamPlaceholder(params.length + i, value));
+			this.addSQL(`${placeholders.join(", ")}`);
+			params.push(...values);
+			return this;
+		},
+		build() {
+			return {
+				query: sql.join(""),
+				params
+			};
+		}
+	};
+};
+
+//#endregion
+//#region src/core/sql/tokens/sqlToken.ts
+const SQLToken = (sqlTokenType, map) => {
+	const factory = (input) => {
+		let props;
+		if (map !== void 0) props = map(input);
+		else if (input === void 0 || input === null) props = {};
+		else if (typeof input === "object" && !Array.isArray(input)) props = input;
+		else throw new Error(`Cannot create SQLToken of type ${sqlTokenType} with input: ${input}`);
+		return {
+			sqlTokenType,
+			[sqlTokenType]: true,
+			...props
+		};
+	};
+	const check = (token) => SQLToken.check(token) && token.sqlTokenType === sqlTokenType;
+	return {
+		from: factory,
+		check,
+		type: sqlTokenType
+	};
+};
+SQLToken.check = (token) => token !== null && typeof token === "object" && "sqlTokenType" in token;
+const SQLIdentifier = SQLToken("SQL_IDENTIFIER", (value) => ({ value }));
+const SQLPlain = SQLToken("SQL_RAW", (value) => ({ value }));
+const SQLLiteral = SQLToken("SQL_LITERAL", (value) => ({ value }));
+const SQLArray = SQLToken("SQL_ARRAY", (input) => {
+	if (Array.isArray(input)) return { value: input };
+	return input.mode !== void 0 ? {
+		value: input.value,
+		mode: input.mode
+	} : { value: input.value };
+});
+const SQLIn = SQLToken("SQL_IN", ({ column, values, mode }) => mode !== void 0 ? {
+	column: SQLIdentifier.from(column),
+	values: SQLArray.from(values),
+	mode
+} : {
+	column: SQLIdentifier.from(column),
+	values: SQLArray.from(values)
+});
+
+//#endregion
+//#region src/core/sql/tokens/columnTokens.ts
+const ColumnTypeToken = (sqlTokenType, jsTypeName, map) => {
+	const factory = (input) => {
+		let props;
+		if (map !== void 0) props = map(input);
+		else if (input === void 0 || input === null) props = {};
+		else if (typeof input === "object" && !Array.isArray(input)) props = input;
+		else throw new Error(`Cannot create SQLToken of type ${sqlTokenType} with input: ${input}`);
+		return {
+			sqlTokenType,
+			[sqlTokenType]: true,
+			jsTypeName,
+			...props
+		};
+	};
+	const check = (token) => SQLToken.check(token) && token.sqlTokenType === sqlTokenType;
+	return {
+		from: factory,
+		check,
+		type: sqlTokenType
+	};
+};
+const SerialToken = ColumnTypeToken("SQL_COLUMN_SERIAL", "value_type:js:number");
+const BigSerialToken = ColumnTypeToken("SQL_COLUMN_BIGSERIAL", "value_type:js:bigint");
+const IntegerToken = ColumnTypeToken("SQL_COLUMN_INTEGER", "value_type:js:number");
+const BigIntegerToken = ColumnTypeToken("SQL_COLUMN_BIGINT", "value_type:js:bigint");
+const JSONBToken = {
+	type: "SQL_COLUMN_JSONB",
+	from: () => {
+		return {
+			sqlTokenType: "SQL_COLUMN_JSONB",
+			["SQL_COLUMN_JSONB"]: true
+		};
+	},
+	check: (token) => SQLToken.check(token) && token.sqlTokenType === "SQL_COLUMN_JSONB"
+};
+const TimestampToken = ColumnTypeToken("SQL_COLUMN_TIMESTAMP", "value_type:js:date");
+const TimestamptzToken = ColumnTypeToken("SQL_COLUMN_TIMESTAMPTZ", "value_type:js:date");
+const VarcharToken = ColumnTypeToken("SQL_COLUMN_VARCHAR", "value_type:js:string", (length) => ({
+	length: length ?? "max",
+	jsTypeName: "value_type:js:string"
+}));
+const AutoIncrementSQLColumnToken = ColumnTypeToken("SQL_COLUMN_AUTO_INCREMENT", "value_type:js:bigint");
+const SQLColumnTypeTokensFactory = {
+	AutoIncrement: AutoIncrementSQLColumnToken.from,
+	BigInteger: BigIntegerToken.from(),
+	BigSerial: BigSerialToken.from(),
+	Integer: IntegerToken.from(),
+	JSONB: JSONBToken.from,
+	Serial: SerialToken.from(),
+	Timestamp: TimestampToken.from(),
+	Timestamptz: TimestamptzToken.from(),
+	Varchar: VarcharToken.from
+};
+const SQLColumnToken = SQLToken("SQL_COLUMN");
+
+//#endregion
+//#region src/core/sql/processors/sqlProcessor.ts
+const SQLProcessor = (options) => options;
+
+//#endregion
+//#region src/core/sql/processors/defaultProcessors.ts
+const ExpandArrayProcessor = SQLProcessor({
+	canHandle: "SQL_ARRAY",
+	handle: (token, { builder, serializer, mapper }) => {
+		if (token.value.length === 0) throw new Error("Empty arrays are not supported. If you're using it with SELECT IN statement Use SQL.in(column, array) helper instead.");
+		builder.addParams(mapper.mapValue(token.value, serializer));
+	}
+});
+const ExpandSQLInProcessor = SQLProcessor({
+	canHandle: "SQL_IN",
+	handle: (token, context) => {
+		const { builder, mapper, processorsRegistry, serializer } = context;
+		const { values: inValues, column } = token;
+		if (inValues.value.length === 0) {
+			builder.addParam(mapper.mapValue(false, serializer));
+			return;
+		}
+		builder.addSQL(mapper.mapValue(column.value, serializer));
+		builder.addSQL(` IN (`);
+		const arrayProcessor = processorsRegistry.get(SQLArray.type);
+		if (!arrayProcessor) throw new Error("No sql processor registered for an array. Cannot expand IN statement");
+		arrayProcessor.handle(inValues, {
+			builder,
+			mapper,
+			processorsRegistry,
+			serializer
+		});
+		builder.addSQL(`)`);
+	}
+});
+const FormatIdentifierProcessor = SQLProcessor({
+	canHandle: "SQL_IDENTIFIER",
+	handle: (token, { builder, mapper, serializer }) => {
+		builder.addSQL(mapper.mapValue(token, serializer));
+	}
+});
+const MapLiteralProcessor = SQLProcessor({
+	canHandle: "SQL_LITERAL",
+	handle: (token, { builder, mapper, serializer }) => builder.addParam(mapper.mapValue(token.value, serializer))
+});
+
+//#endregion
+//#region src/core/sql/processors/sqlProcessorRegistry.ts
+const SQLProcessorsRegistry = (options) => {
+	const processors = options ? new Map(options.from.all()) : /* @__PURE__ */ new Map();
+	function register(...args) {
+		if (args.length === 1 && typeof args[0] === "object" && !Array.isArray(args[0])) Object.entries(args[0]).forEach(([_, processor]) => {
+			processors.set(processor.canHandle, processor);
+		});
+		else args.forEach((p) => processors.set(p.canHandle, p));
+		return registry;
+	}
+	const registry = {
+		register,
+		get: (tokenType) => {
+			return processors.get(tokenType) ?? null;
+		},
+		all: () => processors
+	};
+	return registry;
+};
+
+//#endregion
+//#region src/core/sql/processors/columnProcessors.ts
+const mapDefaultSQLColumnProcessors = (mapColumnType) => ({
+	AutoIncrement: SQLProcessor({
+		canHandle: "SQL_COLUMN_AUTO_INCREMENT",
+		handle: (token, context) => {
+			mapColumnType(token, context);
+		}
+	}),
+	BigInteger: SQLProcessor({
+		canHandle: "SQL_COLUMN_BIGINT",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	BigSerial: SQLProcessor({
+		canHandle: "SQL_COLUMN_BIGSERIAL",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	Serial: SQLProcessor({
+		canHandle: "SQL_COLUMN_SERIAL",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	Integer: SQLProcessor({
+		canHandle: "SQL_COLUMN_INTEGER",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	JSONB: SQLProcessor({
+		canHandle: "SQL_COLUMN_JSONB",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	Timestamp: SQLProcessor({
+		canHandle: "SQL_COLUMN_TIMESTAMP",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	Timestamptz: SQLProcessor({
+		canHandle: "SQL_COLUMN_TIMESTAMPTZ",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	Varchar: SQLProcessor({
+		canHandle: "SQL_COLUMN_VARCHAR",
+		handle: (token, context) => mapColumnType(token, context)
+	})
+});
+
+//#endregion
+//#region src/core/sql/processors/index.ts
+const defaultProcessorsRegistry = globalThis.defaultProcessorsRegistry = globalThis.defaultProcessorsRegistry ?? SQLProcessorsRegistry().register(FormatIdentifierProcessor, MapLiteralProcessor, ExpandArrayProcessor, ExpandSQLInProcessor);
+
+//#endregion
+//#region src/core/sql/tokenizedSQL/tokenizedSQL.ts
+const TokenizedSQLBuilder = () => {
+	const sqlChunks = [];
+	const sqlTokens = [];
+	return {
+		addSQL(str) {
+			sqlChunks.push(str);
+		},
+		addSQLs(str) {
+			sqlChunks.push(...str);
+		},
+		addToken(value) {
+			sqlTokens.push(value);
+		},
+		addTokens(vals) {
+			sqlTokens.push(...vals);
+		},
+		build() {
+			return sqlChunks.length > 0 ? {
+				__brand: "tokenized-sql",
+				sqlChunks,
+				sqlTokens
+			} : TokenizedSQL.empty;
+		}
+	};
+};
+const TokenizedSQL = (strings, values) => {
+	const builder = TokenizedSQLBuilder();
+	for (let i = 0; i < strings.length; i++) {
+		if (strings[i] !== "") builder.addSQL(strings[i]);
+		if (i >= values.length) break;
+		const value = values[i];
+		if (isTokenizedSQL(value)) {
+			builder.addSQLs(value.sqlChunks);
+			builder.addTokens(value.sqlTokens);
+		} else if (SQLPlain.check(value)) builder.addSQL(value.value);
+		else {
+			builder.addSQL(TokenizedSQL.paramPlaceholder);
+			builder.addToken(SQLToken.check(value) ? value : Array.isArray(value) ? SQLArray.from(value) : SQLLiteral.from(value));
+		}
+	}
+	return builder.build();
+};
+const isTokenizedSQL = (value) => {
+	return value !== null && typeof value === "object" && "__brand" in value && value.__brand === "tokenized-sql";
+};
+TokenizedSQL.paramPlaceholder = `__P__`;
+TokenizedSQL.empty = {
+	__brand: "tokenized-sql",
+	sqlChunks: [""],
+	sqlTokens: []
+};
+
+//#endregion
+//#region src/core/sql/sql.ts
+const createSQL = (strings, ...values) => {
+	return TokenizedSQL(strings, values);
+};
+/** Returns true when the value is a tokenized SQL statement. */
+const isSQL = (value) => {
+	if (value === void 0 || value === null) return false;
+	return isTokenizedSQL(value);
+};
+const emptySQL = {
+	__brand: "tokenized-sql",
+	sqlChunks: [""],
+	sqlTokens: []
+};
+const mergeSQL = (sqls, separator = " ") => {
+	const parametrized = sqls.filter((sql) => !isEmpty(sql)).map((sql) => sql);
+	const params = parametrized.flatMap((p) => p.sqlTokens);
+	const sqlChunks = parametrized.flatMap((p, i) => i == parametrized.length - 1 || separator === "" ? p.sqlChunks : [...p.sqlChunks, separator]);
+	return sqlChunks.length > 0 ? {
+		__brand: "tokenized-sql",
+		sqlChunks,
+		sqlTokens: params
+	} : TokenizedSQL.empty;
+};
+const concatSQL = (...sqls) => mergeSQL(sqls, "");
+const literal = (value) => SQLPlain.from(`'${value.replace(/'/g, "''")}'`);
+const isEmpty = (sql) => {
+	if (isTokenizedSQL(sql)) {
+		const parametrized = sql;
+		return parametrized.sqlChunks.every((chunk) => chunk.trim() === "") && parametrized.sqlTokens.length === 0;
+	}
+	return false;
+};
+const columnFactory = SQLColumnToken.from;
+columnFactory.type = SQLColumnTypeTokensFactory;
+const schemaColumnFactory = ((name, type, options) => columnSchemaComponent({
+	columnName: name,
+	type,
+	...options
+}));
+const SQL = Object.assign(createSQL, {
+	EMPTY: emptySQL,
+	concat: concatSQL,
+	merge: mergeSQL,
+	format: (sql, formatter, options) => formatSQL(sql, formatter, options?.serializer ?? JSONSerializer, options),
+	describe: (sql, formatter, options) => describeSQL(sql, formatter, options?.serializer ?? JSONSerializer, options),
+	in: (column, values, options) => options?.mode ? SQLIn.from({
+		column,
+		values,
+		mode: options.mode
+	}) : SQLIn.from({
+		column,
+		values
+	}),
+	array: (values, options) => SQLArray.from(options?.mode ? {
+		value: values,
+		mode: options.mode
+	} : values),
+	identifier: SQLIdentifier.from,
+	plain: SQLPlain.from,
+	literal,
+	check: {
+		isSQL,
+		isTokenizedSQL: (value) => isTokenizedSQL(value),
+		isEmpty,
+		isIdentifier: SQLIdentifier.check,
+		isPlain: SQLPlain.check,
+		isSQLIn: SQLIn.check
+	},
+	column: columnFactory,
+	columnN: Object.assign(schemaColumnFactory, { type: SQLColumnTypeTokensFactory })
+});
+
+//#endregion
+//#region src/core/sql/valueMappers/reservedSqlWords.ts
+const ansiSqlReservedMap = {
+	ALL: true,
+	AND: true,
+	ANY: true,
+	ARRAY: true,
+	AS: true,
+	ASC: true,
+	AUTHORIZATION: true,
+	BETWEEN: true,
+	BINARY: true,
+	BOTH: true,
+	CASE: true,
+	CAST: true,
+	CHECK: true,
+	COLLATE: true,
+	COLUMN: true,
+	CONSTRAINT: true,
+	CREATE: true,
+	CROSS: true,
+	CURRENT_DATE: true,
+	CURRENT_TIME: true,
+	CURRENT_TIMESTAMP: true,
+	CURRENT_USER: true,
+	DEFAULT: true,
+	DEFERRABLE: true,
+	DESC: true,
+	DISTINCT: true,
+	DO: true,
+	ELSE: true,
+	END: true,
+	EXCEPT: true,
+	FALSE: true,
+	FOR: true,
+	FOREIGN: true,
+	FROM: true,
+	FULL: true,
+	GRANT: true,
+	GROUP: true,
+	HAVING: true,
+	IN: true,
+	INITIALLY: true,
+	INNER: true,
+	INTERSECT: true,
+	INTO: true,
+	IS: true,
+	JOIN: true,
+	LEADING: true,
+	LEFT: true,
+	LIKE: true,
+	LOCALTIME: true,
+	LOCALTIMESTAMP: true,
+	NATURAL: true,
+	NEW: true,
+	NOT: true,
+	NULL: true,
+	NULLS: true,
+	OLD: true,
+	ON: true,
+	ONLY: true,
+	OPEN: true,
+	OR: true,
+	ORDER: true,
+	OUTER: true,
+	OVERLAPS: true,
+	PARTITION: true,
+	PLACING: true,
+	PRIMARY: true,
+	REFERENCES: true,
+	RIGHT: true,
+	SELECT: true,
+	SESSION_USER: true,
+	SIMILAR: true,
+	SOME: true,
+	TABLE: true,
+	THEN: true,
+	TO: true,
+	TRAILING: true,
+	TRUE: true,
+	UNION: true,
+	UNIQUE: true,
+	USER: true,
+	USING: true,
+	WHEN: true,
+	WHERE: true,
+	WITH: true,
+	WITHOUT: true,
+	ADD: true,
+	ALTER: true,
+	ARE: true,
+	AT: true,
+	BEGIN: true,
+	BY: true,
+	CASCADE: true,
+	CLOSE: true,
+	COMMIT: true,
+	CONNECT: true,
+	CONTINUE: true,
+	CORRESPONDING: true,
+	CURSOR: true,
+	DEALLOCATE: true,
+	DECLARE: true,
+	DELETE: true,
+	DESCRIBE: true,
+	DISCONNECT: true,
+	DROP: true,
+	ESCAPE: true,
+	EXECUTE: true,
+	EXISTS: true,
+	FETCH: true,
+	FIRST: true,
+	FLOAT: true,
+	GET: true,
+	GLOBAL: true,
+	GO: true,
+	GOTO: true,
+	HOUR: true,
+	IMMEDIATE: true,
+	INDICATOR: true,
+	INPUT: true,
+	INSERT: true,
+	INT: true,
+	INTEGER: true,
+	INTERVAL: true,
+	LANGUAGE: true,
+	LAST: true,
+	LOCAL: true,
+	MATCH: true,
+	MINUTE: true,
+	MODULE: true,
+	MONTH: true,
+	NATIONAL: true,
+	NEXT: true,
+	NO: true,
+	OF: true,
+	OUTPUT: true,
+	PARTIAL: true,
+	PREPARE: true,
+	PRESERVE: true,
+	PRIOR: true,
+	PRIVILEGES: true,
+	PROCEDURE: true,
+	PUBLIC: true,
+	READ: true,
+	REAL: true,
+	RESTRICT: true,
+	REVOKE: true,
+	ROLLBACK: true,
+	ROWS: true,
+	SCHEMA: true,
+	SCROLL: true,
+	SECOND: true,
+	SECTION: true,
+	SET: true,
+	SIZE: true,
+	SMALLINT: true,
+	SQL: true,
+	SQLCODE: true,
+	SQLERROR: true,
+	SQLSTATE: true,
+	TEMPORARY: true,
+	TIMEZONE_HOUR: true,
+	TIMEZONE_MINUTE: true,
+	TRANSACTION: true,
+	TRANSLATE: true,
+	TRANSLATION: true,
+	UNKNOWN: true,
+	UPDATE: true,
+	VALUE: true,
+	VALUES: true,
+	VARCHAR: true,
+	VARYING: true,
+	VIEW: true,
+	WHENEVER: true,
+	WORK: true,
+	WRITE: true,
+	YEAR: true,
+	ZONE: true
+};
+
+//#endregion
+//#region src/core/sql/valueMappers/sqlValueMapper.ts
+const ANSISQLParamPlaceholder = "?";
+const ANSISQLIdentifierQuote = "\"";
+const mapANSISQLParamPlaceholder = () => "?";
+const isReserved = (value, reserved) => !!reserved[value.toUpperCase()];
+const mapSQLIdentifier = (value, options) => {
+	if (value === void 0 || value === null) throw new Error("SQL identifier cannot be null or undefined");
+	const ident = value.toString().slice(0);
+	const quoteSign = options?.quote ?? "\"";
+	if (/^[a-z_][a-z0-9_$]*$/.test(ident) && !isReserved(ident, options?.reservedWords ?? ansiSqlReservedMap)) return ident;
+	let quoted = quoteSign;
+	for (let i = 0; i < ident.length; i++) {
+		const c = ident[i];
+		quoted += c === quoteSign ? c + c : c;
+	}
+	quoted += quoteSign;
+	return quoted;
+};
+const DefaultMapSQLParamValueOptions = {
+	mapPlaceholder: mapANSISQLParamPlaceholder,
+	mapIdentifier: mapSQLIdentifier
+};
+const SQLValueMapper = (options) => {
+	const mapSQLParamValueOptions = {
+		...DefaultMapSQLParamValueOptions,
+		...options ?? {}
+	};
+	return {
+		mapValue: (value, serializer, mapOptions) => mapSQLParamValue(value, serializer, {
+			...mapSQLParamValueOptions,
+			...mapOptions
+		}),
+		mapPlaceholder: mapSQLParamValueOptions.mapPlaceholder,
+		mapIdentifier: mapSQLParamValueOptions.mapIdentifier
+	};
+};
+function mapSQLParamValue(value, serializer, options) {
+	if (value === null || value === void 0) return null;
+	else if (typeof value === "number") return value;
+	else if (typeof value === "string") return value;
+	else if (Array.isArray(value)) {
+		const mapValue = options?.mapValue ?? mapSQLParamValue;
+		return options?.mapArray ? options.mapArray(value, mapValue) : value.map((item) => mapValue(item, serializer, options));
+	} else if (typeof value === "boolean") return options?.mapBoolean ? options.mapBoolean(value) : value;
+	else if (typeof value === "bigint") return options?.mapBigInt ? options.mapBigInt(value) : value.toString();
+	else if (value instanceof Date) return options?.mapDate ? options.mapDate(value) : value.toISOString();
+	else if (SQL.check.isIdentifier(value)) return (options?.mapIdentifier ?? mapSQLIdentifier)(value.value);
+	else if (typeof value === "object") return options?.mapObject ? options.mapObject(value) : serializer.serialize(value);
+	else return serializer.serialize(value);
+}
+
+//#endregion
+//#region src/core/sql/formatters/sqlFormatter.ts
+const SQLFormatter = ({ format, describe, valueMapper: valueMapperOptions, processorsRegistry }) => {
+	const valueMapper = SQLValueMapper(valueMapperOptions);
+	const options = {
+		builder: ParametrizedSQLBuilder({ mapParamPlaceholder: valueMapper.mapPlaceholder }),
+		mapper: valueMapper,
+		processorsRegistry: processorsRegistry ?? defaultProcessorsRegistry
+	};
+	const resultFormatter = {
+		format: format ?? ((sql, methodOptions) => formatSQL(sql, resultFormatter, methodOptions?.serializer ?? JSONSerializer, {
+			...options,
+			...methodOptions ?? {}
+		})),
+		describe: describe ?? ((sql, methodOptions) => describeSQL(sql, resultFormatter, methodOptions?.serializer ?? JSONSerializer, {
+			...options,
+			...methodOptions ?? {}
+		})),
+		valueMapper
+	};
+	return resultFormatter;
+};
+const dumboSQLFormatters = globalThis.dumboSQLFormatters = globalThis.dumboSQLFormatters ?? {};
+const registerFormatter = (dialect, formatter) => {
+	dumboSQLFormatters[dialect] = formatter;
+};
+function formatSQL(sql, formatter, serializer, context) {
+	const mapper = context?.mapper == void 0 ? formatter.valueMapper : {
+		...formatter.valueMapper,
+		...context.mapper
+	};
+	const processorsRegistry = context?.processorsRegistry ?? defaultProcessorsRegistry;
+	const merged = Array.isArray(sql) ? SQL.merge(sql, "\n") : sql;
+	if (!isTokenizedSQL(merged)) throw new Error("Expected TokenizedSQL, got string-based SQL");
+	const builder = ParametrizedSQLBuilder({ mapParamPlaceholder: mapper.mapPlaceholder });
+	let paramIndex = 0;
+	for (let i = 0; i < merged.sqlChunks.length; i++) {
+		const sqlChunk = merged.sqlChunks[i];
+		if (sqlChunk !== TokenizedSQL.paramPlaceholder) {
+			builder.addSQL(sqlChunk);
+			continue;
+		}
+		const token = merged.sqlTokens[paramIndex++];
+		const processor = processorsRegistry.get(token.sqlTokenType);
+		if (!processor) throw new Error(`No SQL processor registered for token type: ${token.sqlTokenType}`);
+		processor.handle(token, {
+			builder,
+			processorsRegistry,
+			serializer,
+			mapper
+		});
+	}
+	return builder.build();
+}
+const describeSQL = (sql, formatter, serializer, options) => formatSQL(sql, formatter, serializer, {
+	...options ?? {},
+	mapper: { mapPlaceholder: (_, value) => serializer.serialize(value) }
+}).query;
+
+//#endregion
+//#region src/core/tracing/printing/color.ts
+let enableColors = true;
+const color = {
+	set level(value) {
+		enableColors = value === 1;
+	},
+	hex: (value) => (text) => enableColors ? ansis.default.hex(value)(text) : text,
+	red: (value) => enableColors ? ansis.default.red(value) : value,
+	green: (value) => enableColors ? ansis.default.green(value) : value,
+	blue: (value) => enableColors ? ansis.default.blue(value) : value,
+	cyan: (value) => enableColors ? ansis.default.cyan(value) : value,
+	yellow: (value) => enableColors ? ansis.default.yellow(value) : value
+};
+
+//#endregion
+//#region src/core/tracing/printing/pretty.ts
+const TWO_SPACES = "  ";
+const COLOR_STRING = color.hex("#98c379");
+const COLOR_KEY = color.hex("#61afef");
+const COLOR_NUMBER_OR_DATE = color.hex("#d19a66");
+const COLOR_BOOLEAN = color.hex("#c678dd");
+const COLOR_NULL_OR_UNDEFINED = color.hex("#c678dd");
+const COLOR_BRACKETS = color.hex("#abb2bf");
+const processString = (str, indent, handleMultiline) => {
+	if (handleMultiline && str.includes("\n")) {
+		const indentedLines = str.split("\n").map((line) => indent + TWO_SPACES + COLOR_STRING(line));
+		return COLOR_STRING("\"") + "\n" + indentedLines.join("\n") + "\n" + indent + COLOR_STRING("\"");
+	}
+	return COLOR_STRING(`"${str}"`);
+};
+const shouldPrint = (obj) => typeof obj !== "function" && typeof obj !== "symbol";
+const formatJson = (obj, indentLevel = 0, handleMultiline = false) => {
+	const indent = TWO_SPACES.repeat(indentLevel);
+	if (obj === null) return COLOR_NULL_OR_UNDEFINED("null");
+	if (obj === void 0) return COLOR_NULL_OR_UNDEFINED("undefined");
+	if (typeof obj === "string") return processString(obj, indent, handleMultiline);
+	if (typeof obj === "number" || typeof obj === "bigint" || obj instanceof Date) return COLOR_NUMBER_OR_DATE(String(obj));
+	if (typeof obj === "boolean") return COLOR_BOOLEAN(String(obj));
+	if (obj instanceof Error) {
+		const errorObj = {};
+		Object.getOwnPropertyNames(obj).forEach((key) => {
+			errorObj[key] = obj[key];
+		});
+		return formatJson(errorObj, indentLevel, handleMultiline);
+	}
+	if (obj instanceof Promise) return COLOR_STRING("Promise {pending}");
+	if (Array.isArray(obj)) {
+		const arrayItems = obj.map((item) => formatJson(item, indentLevel + 1, handleMultiline));
+		return `${COLOR_BRACKETS("[")}\n${indent}  ${arrayItems.join(`,\n${indent}  `)}\n${indent}${COLOR_BRACKETS("]")}`;
+	}
+	const entries = Object.entries(obj).filter(([_, value]) => shouldPrint(value)).map(([key, value]) => `${COLOR_KEY(`"${key}"`)}: ${formatJson(value, indentLevel + 1, handleMultiline)}`);
+	return `${COLOR_BRACKETS("{")}\n${indent}  ${entries.join(`,\n${indent}  `)}\n${indent}${COLOR_BRACKETS("}")}`;
+};
+const prettyJson = (obj, options) => formatJson(obj, 0, options?.handleMultiline);
+
+//#endregion
+//#region src/core/tracing/index.ts
+const tracer = () => {};
+const LogLevel = {
+	DISABLED: "DISABLED",
+	INFO: "INFO",
+	LOG: "LOG",
+	WARN: "WARN",
+	ERROR: "ERROR"
+};
+const getEnvVariable = (name) => {
+	try {
+		if (typeof process !== "undefined" && process.env) return process.env[name];
+		return;
+	} catch {
+		return;
+	}
+};
+const shouldLog = (logLevel) => {
+	const definedLogLevel = getEnvVariable("DUMBO_LOG_LEVEL") ?? LogLevel.ERROR;
+	if (definedLogLevel === LogLevel.ERROR && logLevel === LogLevel.ERROR) return true;
+	if (definedLogLevel === LogLevel.WARN && [LogLevel.ERROR, LogLevel.WARN].includes(logLevel)) return true;
+	if (definedLogLevel === LogLevel.LOG && [
+		LogLevel.ERROR,
+		LogLevel.WARN,
+		LogLevel.LOG
+	].includes(logLevel)) return true;
+	if (definedLogLevel === LogLevel.INFO && [
+		LogLevel.ERROR,
+		LogLevel.WARN,
+		LogLevel.LOG,
+		LogLevel.INFO
+	].includes(logLevel)) return true;
+	return false;
+};
+const nulloTraceEventRecorder = () => {};
+const getTraceEventFormatter = (logStyle, serializer = JSONSerializer) => (event) => {
+	switch (logStyle) {
+		case "RAW": return serializer.serialize(event);
+		case "PRETTY": return prettyJson(event, { handleMultiline: true });
+	}
+};
+const getTraceEventRecorder = (logLevel, logStyle) => {
+	const format = getTraceEventFormatter(logStyle);
+	switch (logLevel) {
+		case "DISABLED": return nulloTraceEventRecorder;
+		case "INFO": return (event) => console.info(format(event));
+		case "LOG": return (event) => console.log(format(event));
+		case "WARN": return (event) => console.warn(format(event));
+		case "ERROR": return (event) => console.error(format(event));
+	}
+};
+const recordTraceEvent = (logLevel, eventName, attributes) => {
+	if (!shouldLog(LogLevel.LOG)) return;
+	const event = {
+		name: eventName,
+		timestamp: (/* @__PURE__ */ new Date()).getTime(),
+		...attributes
+	};
+	getTraceEventRecorder(logLevel, getEnvVariable("DUMBO_LOG_STYLE") ?? "RAW")(event);
+};
+tracer.info = (eventName, attributes) => recordTraceEvent(LogLevel.INFO, eventName, attributes);
+tracer.warn = (eventName, attributes) => recordTraceEvent(LogLevel.WARN, eventName, attributes);
+tracer.log = (eventName, attributes) => recordTraceEvent(LogLevel.LOG, eventName, attributes);
+tracer.error = (eventName, attributes) => recordTraceEvent(LogLevel.ERROR, eventName, attributes);
+
+//#endregion
+//#region src/core/schema/sqlMigration.ts
+const sqlMigration = (name, sqls) => ({
+	name,
+	sqls
+});
+
+//#endregion
+//#region src/core/schema/migrators/schemaComponentMigrator.ts
+const { AutoIncrement, Varchar, Timestamp } = SQL.column.type;
+const migrationTableSQL = SQL`
+  CREATE TABLE IF NOT EXISTS dmb_migrations (
+    id ${AutoIncrement({ primaryKey: true })},
+    name ${Varchar(255)} NOT NULL UNIQUE,
+    application ${Varchar(255)} NOT NULL DEFAULT 'default',
+    sql_hash ${Varchar(64)} NOT NULL,
+    timestamp ${Timestamp} NOT NULL DEFAULT CURRENT_TIMESTAMP
+  );
+`;
+const migrationTableSchemaComponent = schemaComponent("dumbo:schema-component:migrations-table", { migrations: [sqlMigration("dumbo:migrationTable:001", [migrationTableSQL])] });
+
+//#endregion
+//#region src/core/schema/migrators/migrator.ts
+const defaultMigratorOptions = globalThis.defaultMigratorOptions = globalThis.defaultMigratorOptions ?? {};
+const registerDefaultMigratorOptions = (databaseType, options) => {
+	defaultMigratorOptions[databaseType] = options;
+};
+
+//#endregion
+//#region src/storage/sqlite/core/errors/errorMapper.ts
+/**
+* Extracts the SQLite error code string from a `sqlite3` driver error.
+*
+* The `sqlite3` (node-sqlite3) driver sets `error.code` to a string like
+* `'SQLITE_CONSTRAINT'` and `error.errno` to the numeric result code.
+* See: https://github.com/TryGhost/node-sqlite3
+*/
+const getSqliteErrorCode = (error) => {
+	if (error instanceof Error && "code" in error && typeof error.code === "string") return error.code;
+};
+const getErrorMessage = (error) => error instanceof Error ? error.message : void 0;
+const asError = (error) => error instanceof Error ? error : void 0;
+/**
+* Maps a constraint error to a specific DumboError subtype by inspecting the
+* error message. The `sqlite3` driver only exposes the primary result code
+* `SQLITE_CONSTRAINT` — the constraint subtype (UNIQUE, FOREIGN KEY, etc.)
+* is embedded in the message string by SQLite, e.g.:
+*   "SQLITE_CONSTRAINT: UNIQUE constraint failed: users.email"
+*
+* Reference: https://www.sqlite.org/rescode.html (extended result codes 275–3091)
+*/
+const mapConstraintError = (message, innerError) => {
+	const upperMessage = message?.toUpperCase() ?? "";
+	if (upperMessage.includes("UNIQUE") || upperMessage.includes("PRIMARY KEY")) return new UniqueConstraintError(message, innerError);
+	if (upperMessage.includes("FOREIGN KEY")) return new ForeignKeyViolationError(message, innerError);
+	if (upperMessage.includes("NOT NULL")) return new NotNullViolationError(message, innerError);
+	if (upperMessage.includes("CHECK")) return new CheckViolationError(message, innerError);
+	return new IntegrityConstraintViolationError(message, innerError);
+};
+/**
+* Maps a SQLite error (from the `sqlite3` / node-sqlite3 driver) to a typed
+* DumboError based on the SQLite result code.
+*
+* Result code reference: https://www.sqlite.org/rescode.html
+*
+* Falls back to a generic DumboError (500) if the error is not a recognized SQLite error.
+*/
+const mapSqliteError = (error) => {
+	if (DumboError.isInstanceOf(error)) return error;
+	const code = getSqliteErrorCode(error);
+	if (!code) return new DumboError({
+		errorCode: 500,
+		message: getErrorMessage(error),
+		innerError: asError(error)
+	});
+	const message = getErrorMessage(error);
+	const innerError = asError(error);
+	switch (code) {
+		case "SQLITE_CONSTRAINT": return mapConstraintError(message, innerError);
+		case "SQLITE_BUSY": return new LockNotAvailableError(message, innerError);
+		case "SQLITE_LOCKED": return new DeadlockError(message, innerError);
+		case "SQLITE_PROTOCOL": return new LockNotAvailableError(message, innerError);
+		case "SQLITE_CANTOPEN": return new ConnectionError(message, innerError);
+		case "SQLITE_NOTADB": return new ConnectionError(message, innerError);
+		case "SQLITE_NOMEM": return new InsufficientResourcesError(message, innerError);
+		case "SQLITE_FULL": return new InsufficientResourcesError(message, innerError);
+		case "SQLITE_IOERR": return new SystemError(message, innerError);
+		case "SQLITE_CORRUPT": return new SystemError(message, innerError);
+		case "SQLITE_INTERNAL": return new SystemError(message, innerError);
+		case "SQLITE_NOLFS": return new SystemError(message, innerError);
+		case "SQLITE_TOOBIG": return new DataError(message, innerError);
+		case "SQLITE_MISMATCH": return new DataError(message, innerError);
+		case "SQLITE_RANGE": return new DataError(message, innerError);
+		case "SQLITE_ERROR": return new InvalidOperationError(message, innerError);
+		case "SQLITE_READONLY": return new InvalidOperationError(message, innerError);
+		case "SQLITE_MISUSE": return new InvalidOperationError(message, innerError);
+		case "SQLITE_AUTH": return new InvalidOperationError(message, innerError);
+		case "SQLITE_PERM": return new InvalidOperationError(message, innerError);
+		case "SQLITE_SCHEMA": return new InvalidOperationError(message, innerError);
+		case "SQLITE_ABORT": return new SerializationError(message, innerError);
+		case "SQLITE_INTERRUPT": return new SerializationError(message, innerError);
+	}
+	return new DumboError({
+		errorCode: 500,
+		message,
+		innerError
+	});
+};
+
+//#endregion
+//#region src/storage/sqlite/core/sql/processors/columProcessors.ts
+const mapColumnType = (token, { builder }) => {
+	let columnSQL;
+	const { sqlTokenType } = token;
+	switch (sqlTokenType) {
+		case "SQL_COLUMN_AUTO_INCREMENT":
+			columnSQL = `INTEGER ${token.primaryKey ? "PRIMARY KEY" : ""} AUTOINCREMENT`;
+			break;
+		case "SQL_COLUMN_BIGINT":
+			columnSQL = "INTEGER";
+			break;
+		case "SQL_COLUMN_SERIAL":
+			columnSQL = "INTEGER";
+			break;
+		case "SQL_COLUMN_INTEGER":
+			columnSQL = "INTEGER";
+			break;
+		case "SQL_COLUMN_JSONB":
+			columnSQL = "BLOB";
+			break;
+		case "SQL_COLUMN_BIGSERIAL":
+			columnSQL = "INTEGER";
+			break;
+		case "SQL_COLUMN_TIMESTAMP":
+			columnSQL = "DATETIME";
+			break;
+		case "SQL_COLUMN_TIMESTAMPTZ":
+			columnSQL = "DATETIME";
+			break;
+		case "SQL_COLUMN_VARCHAR":
+			columnSQL = `VARCHAR ${Number.isNaN(token.length) ? "" : `(${token.length})`}`;
+			break;
+		default: throw new Error(`Unknown column type: ${sqlTokenType}`);
+	}
+	builder.addSQL(columnSQL);
+};
+const sqliteColumnProcessors = mapDefaultSQLColumnProcessors(mapColumnType);
+
+//#endregion
+//#region src/storage/sqlite/core/sql/formatter/index.ts
+const sqliteFormatter = SQLFormatter({ processorsRegistry: SQLProcessorsRegistry({ from: defaultProcessorsRegistry }).register(sqliteColumnProcessors) });
+registerFormatter("SQLite", sqliteFormatter);
+
+//#endregion
+//#region src/storage/sqlite/core/execute/execute.ts
+const sqliteExecute = async (database, handle) => {
+	try {
+		return await handle(database);
+	} finally {
+		await database.close();
+	}
+};
+const sqliteSQLExecutor = (driverType, serializer, formatter, errorMapper) => ({
+	driverType,
+	query: async (client, sql, options) => {
+		tracer.info("db:sql:query", {
+			query: (formatter ?? sqliteFormatter).format(sql, { serializer }).query,
+			params: (formatter ?? sqliteFormatter).format(sql, { serializer }).params,
+			debugSQL: (formatter ?? sqliteFormatter).describe(sql, { serializer })
+		});
+		try {
+			let result = await client.query(sql, options);
+			if (options?.mapping) result = {
+				...result,
+				rows: result.rows.map((row) => mapSQLQueryResult(row, options.mapping))
+			};
+			return result;
+		} catch (error) {
+			tracer.error("db:sql:query:execute:error", { error });
+			throw (errorMapper ?? mapSqliteError)(error);
+		}
+	},
+	batchQuery: async (client, sqls, options) => {
+		try {
+			const results = await client.batchQuery(sqls, options);
+			if (options?.mapping) return results.map((result) => ({
+				...result,
+				rows: result.rows.map((row) => mapSQLQueryResult(row, options.mapping))
+			}));
+			return results;
+		} catch (error) {
+			tracer.error("db:sql:batch_query:execute:error", { error });
+			throw (errorMapper ?? mapSqliteError)(error);
+		}
+	},
+	command: async (client, sql, options) => {
+		tracer.info("db:sql:command", {
+			query: (formatter ?? sqliteFormatter).format(sql, { serializer }).query,
+			params: (formatter ?? sqliteFormatter).format(sql, { serializer }).params,
+			debugSQL: (formatter ?? sqliteFormatter).describe(sql, { serializer })
+		});
+		try {
+			return await client.command(sql, options);
+		} catch (error) {
+			tracer.error("db:sql:command:execute:error", { error });
+			throw (errorMapper ?? mapSqliteError)(error);
+		}
+	},
+	batchCommand: async (client, sqls, options) => {
+		try {
+			return await client.batchCommand(sqls, options);
+		} catch (error) {
+			tracer.error("db:sql:batch_command:execute:error", { error });
+			throw (errorMapper ?? mapSqliteError)(error);
+		}
+	},
+	formatter: formatter ?? sqliteFormatter
+});
+
+//#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 tx = databaseTransaction({
+		begin: async () => {
+			const client = await getClient;
+			const mode = options?.mode ?? defaultTransactionMode ?? "IMMEDIATE";
+			await client.command(SQL`BEGIN ${SQL.plain(mode)} TRANSACTION`);
+		},
+		commit: async () => {
+			const client = await getClient;
+			try {
+				await client.command(SQL`COMMIT`);
+			} finally {
+				if (options?.close) await options.close(client);
+			}
+		},
+		rollback: async (error) => {
+			const client = await getClient;
+			try {
+				await client.command(SQL`ROLLBACK`);
+			} finally {
+				if (options?.close) await options.close(client, error);
+			}
+		},
+		savepoint: async (level) => {
+			await (await getClient).command(SQL`SAVEPOINT transaction${SQL.plain(level.toString())}`);
+		},
+		releaseSavepoint: async (level) => {
+			await (await getClient).command(SQL`RELEASE transaction${SQL.plain(level.toString())}`);
+		}
+	}, {
+		allowNestedTransactions,
+		useSavepoints
+	});
+	return {
+		connection: connection(),
+		driverType,
+		begin: tx.begin,
+		commit: tx.commit,
+		rollback: tx.rollback,
+		execute: sqlExecutor(sqliteSQLExecutor(driverType, serializer), { connect: () => getClient }),
+		_transactionOptions: {
+			...options,
+			allowNestedTransactions
+		}
+	};
+};
+
+//#endregion
+//#region src/storage/sqlite/core/connections/connectionString.ts
+const SQLiteConnectionString = (connectionString) => {
+	if (!connectionString.startsWith("file:") && connectionString !== ":memory:" && !connectionString.startsWith("/") && !connectionString.startsWith("./")) throw new Error(`Invalid SQLite connection string: ${connectionString}. It should start with "file:", ":memory:", "/", or "./".`);
+	return connectionString;
+};
+const parsePragmasFromConnectionString = (connectionString) => {
+	const str = String(connectionString);
+	if (!str.startsWith("file:")) return {};
+	const params = new URL(str).searchParams;
+	const pragmas = {};
+	const journalMode = params.get("journal_mode");
+	if (journalMode !== null) pragmas.journal_mode = journalMode;
+	const synchronous = params.get("synchronous");
+	if (synchronous !== null) pragmas.synchronous = synchronous;
+	const cacheSize = params.get("cache_size");
+	if (cacheSize !== null) pragmas.cache_size = parseInt(cacheSize, 10);
+	const foreignKeys = params.get("foreign_keys");
+	if (foreignKeys !== null) {
+		const val = foreignKeys.toLowerCase();
+		pragmas.foreign_keys = val === "true" || val === "on" || val === "1";
+	}
+	const tempStore = params.get("temp_store");
+	if (tempStore !== null) pragmas.temp_store = tempStore.toUpperCase();
+	const busyTimeout = params.get("busy_timeout");
+	if (busyTimeout !== null) pragmas.busy_timeout = parseInt(busyTimeout, 10);
+	const mmapSize = params.get("mmap_size");
+	if (mmapSize !== null) pragmas.mmap_size = parseInt(mmapSize, 10);
+	return pragmas;
+};
+
+//#endregion
+//#region src/storage/sqlite/core/connections/index.ts
+const isSQLiteError = (error) => {
+	if (error instanceof Error && "code" in error) return true;
+	return false;
+};
+const sqliteAmbientClientConnection = (options) => {
+	const { client, driverType, initTransaction, allowNestedTransactions, defaultTransactionMode, serializer, errorMapper } = options;
+	return createAmbientConnection({
+		driverType,
+		client,
+		initTransaction: initTransaction ?? ((connection) => sqliteTransaction(driverType, connection, allowNestedTransactions ?? false, serializer, defaultTransactionMode)),
+		executor: ({ serializer }) => sqliteSQLExecutor(driverType, serializer, void 0, errorMapper),
+		serializer
+	});
+};
+const sqliteClientConnection = (options) => {
+	const { connectionOptions, sqliteClientFactory, serializer } = options;
+	let client = null;
+	const connect = async () => {
+		if (client) return Promise.resolve(client);
+		client = sqliteClientFactory(connectionOptions);
+		if (client && "connect" in client && typeof client.connect === "function") try {
+			await client.connect();
+		} catch (error) {
+			throw mapSqliteError(error);
+		}
+		return client;
+	};
+	return createConnection({
+		driverType: options.driverType,
+		connect,
+		close: async () => {
+			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),
+		executor: ({ serializer }) => sqliteSQLExecutor(options.driverType, serializer),
+		serializer
+	});
+};
+const sqlitePoolClientConnection = (options) => {
+	const { connectionOptions, sqliteClientFactory, serializer } = options;
+	let client = null;
+	const connect = async () => {
+		if (client) return Promise.resolve(client);
+		client = sqliteClientFactory(connectionOptions);
+		try {
+			await client.connect();
+		} catch (error) {
+			throw mapSqliteError(error);
+		}
+		return client;
+	};
+	return createConnection({
+		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),
+		executor: ({ serializer }) => sqliteSQLExecutor(options.driverType, serializer),
+		serializer
+	});
+};
+function sqliteConnection(options) {
+	return options.type === "Client" ? sqliteClientConnection(options) : sqlitePoolClientConnection(options);
+}
+const InMemorySQLiteDatabase = SQLiteConnectionString(":memory:");
+const DEFAULT_SQLITE_PRAGMA_OPTIONS = {
+	journal_mode: "WAL",
+	synchronous: "NORMAL",
+	cache_size: -1e6,
+	foreign_keys: true,
+	temp_store: "MEMORY",
+	busy_timeout: 5e3,
+	mmap_size: 268435456
+};
+
+//#endregion
+//#region src/storage/sqlite/core/pool/pool.ts
+const isInMemoryDatabase = (options) => {
+	if ("fileName" in options) return options.fileName === InMemorySQLiteDatabase;
+	if ("connectionString" in options) return options.connectionString === InMemorySQLiteDatabase;
+	return false;
+};
+const sqliteAmbientConnectionPool = (options) => {
+	const { connection, driverType } = options;
+	return createAmbientConnectionPool({
+		driverType,
+		connection
+	});
+};
+const sqliteSingletonConnectionPool = (options) => {
+	const { driverType, sqliteConnectionFactory, connectionOptions } = options;
+	return createSingletonConnectionPool({
+		driverType,
+		getConnection: () => sqliteConnectionFactory(connectionOptions)
+	});
+};
+const sqliteAlwaysNewConnectionPool = (options) => {
+	const { driverType, sqliteConnectionFactory, connectionOptions } = options;
+	return createAlwaysNewConnectionPool({
+		driverType,
+		getConnection: () => sqliteConnectionFactory(connectionOptions)
+	});
+};
+const toSqlitePoolOptions = (options) => {
+	const { singleton, ...rest } = options;
+	const isInMemory = isInMemoryDatabase(options);
+	if ("client" in options && options.client) return {
+		...rest,
+		singleton: true
+	};
+	if (isInMemory) return {
+		...rest,
+		singleton: true
+	};
+	if (singleton === true) return {
+		...rest,
+		singleton: true
+	};
+	return rest;
+};
+function sqlitePool(options) {
+	const { driverType } = options;
+	if (options.connection) return createAmbientConnectionPool({
+		driverType,
+		connection: options.connection
+	});
+	if (options.singleton === true && options.sqliteConnectionFactory) return createSingletonConnectionPool({
+		driverType,
+		getConnection: () => options.sqliteConnectionFactory(options.connectionOptions)
+	});
+	return createAlwaysNewConnectionPool({
+		driverType,
+		getConnection: () => options.sqliteConnectionFactory(options.connectionOptions)
+	});
+}
+
+//#endregion
+//#region src/storage/sqlite/core/schema/migrations.ts
+const DefaultSQLiteMigratorOptions = {};
+registerDefaultMigratorOptions("SQLite", DefaultSQLiteMigratorOptions);
+
+//#endregion
+//#region src/storage/sqlite/core/schema/schema.ts
+const defaultSQLiteDatabase = ":memory:";
+const tableExistsSQL = (tableName) => SQL`
+  SELECT EXISTS (
+    SELECT 1
+    FROM sqlite_master
+    WHERE type = 'table' AND name = ${tableName}
+  ) AS "exists"
+   `;
+const tableExists = async (execute, tableName) => exists(execute.query(tableExistsSQL(tableName)));
+
+//#endregion
+//#region src/storage/sqlite/core/schema/sqliteMetadata.ts
+const sqliteMetadata = {
+	databaseType: "SQLite",
+	capabilities: {
+		supportsSchemas: false,
+		supportsFunctions: false,
+		supportsMultipleDatabases: false
+	},
+	tableExists
+};
+dumboDatabaseMetadataRegistry.register("SQLite", sqliteMetadata);
+
+//#endregion
+//#region src/storage/sqlite/core/sql/json.ts
+const path = (path) => SQL.literal(`$.${path}`);
+const SQLiteJSON = { path };
+
+//#endregion
+//#region src/storage/sqlite/core/index.ts
+const SQLiteDatabaseName = "SQLite";
+
+//#endregion
 //#region src/storage/sqlite/core/connections/pragmas.ts
 const mergePragmaOptions = (connectionString, userOptions) => {
-	const connectionStringPragmas = require_core$1.parsePragmasFromConnectionString(connectionString);
+	const connectionStringPragmas = parsePragmasFromConnectionString(connectionString);
 	return {
-		...require_core$1.DEFAULT_SQLITE_PRAGMA_OPTIONS,
+		...DEFAULT_SQLITE_PRAGMA_OPTIONS,
 		...connectionStringPragmas,
 		...userOptions
 	};
@@ -70,7 +2511,7 @@ const sqlite3Client = (options) => {
 	let db;
 	let isClosed = false;
 	const { serializer } = options;
-	const connectionString = options.fileName ?? options.connectionString ?? require_core$1.InMemorySQLiteDatabase;
+	const connectionString = options.fileName ?? options.connectionString ?? InMemorySQLiteDatabase;
 	const finalPragmas = mergePragmaOptions(String(connectionString), options.pragmaOptions);
 	const connectionPragmas = buildConnectionPragmaStatements(finalPragmas);
 	const connect = () => db ? Promise.resolve() : new Promise((resolve, reject) => {
@@ -80,7 +2521,7 @@ const sqlite3Client = (options) => {
 					reject(err);
 					return;
 				}
-				const busyTimeout = finalPragmas.busy_timeout ?? require_core$1.DEFAULT_SQLITE_PRAGMA_OPTIONS.busy_timeout;
+				const busyTimeout = finalPragmas.busy_timeout ?? DEFAULT_SQLITE_PRAGMA_OPTIONS.busy_timeout;
 				db.configure("busyTimeout", busyTimeout);
 				applyPragmas(db, connectionPragmas.filter((p) => p.pragma !== "busy_timeout")).then(async () => {
 					if (options.skipDatabasePragmas) return;
@@ -169,26 +2610,26 @@ const sqlite3Client = (options) => {
 					});
 				});
 			} catch (error) {
-				throw require_core$1.mapSqliteError(error);
+				throw mapSqliteError(error);
 			}
 		},
 		query: async (sql, _options) => {
 			try {
-				const { query, params } = require_core$1.sqliteFormatter.format(sql, { serializer });
+				const { query, params } = sqliteFormatter.format(sql, { serializer });
 				const result = await executeQuery(query, params);
 				return {
 					rowCount: result.length,
 					rows: result
 				};
 			} catch (error) {
-				throw require_core$1.mapSqliteError(error);
+				throw mapSqliteError(error);
 			}
 		},
 		batchQuery: async (sqls, _options) => {
 			try {
 				const results = [];
 				for (const sql of sqls) {
-					const { query, params } = require_core$1.sqliteFormatter.format(sql, { serializer });
+					const { query, params } = sqliteFormatter.format(sql, { serializer });
 					const result = await executeQuery(query, params);
 					results.push({
 						rowCount: result.length,
@@ -197,29 +2638,29 @@ const sqlite3Client = (options) => {
 				}
 				return results;
 			} catch (error) {
-				throw require_core$1.mapSqliteError(error);
+				throw mapSqliteError(error);
 			}
 		},
 		command: async (sql, options) => {
 			try {
-				const { query, params } = require_core$1.sqliteFormatter.format(sql, { serializer });
+				const { query, params } = sqliteFormatter.format(sql, { serializer });
 				return await executeCommand(query, params, options);
 			} catch (error) {
-				throw require_core$1.mapSqliteError(error);
+				throw mapSqliteError(error);
 			}
 		},
 		batchCommand: async (sqls, options) => {
 			try {
 				const results = [];
 				for (let i = 0; i < sqls.length; i++) {
-					const { query, params } = require_core$1.sqliteFormatter.format(sqls[i], { serializer });
+					const { query, params } = sqliteFormatter.format(sqls[i], { serializer });
 					const result = await executeCommand(query, params, options);
 					results.push(result);
-					if (options?.assertChanges && (result.rowCount ?? 0) === 0) throw new require_core.BatchCommandNoChangesError(i);
+					if (options?.assertChanges && (result.rowCount ?? 0) === 0) throw new BatchCommandNoChangesError(i);
 				}
 				return results;
 			} catch (error) {
-				throw require_core$1.mapSqliteError(error);
+				throw mapSqliteError(error);
 			}
 		}
 	};
@@ -230,7 +2671,7 @@ const checkConnection = async (fileName, serializer) => {
 		serializer
 	});
 	try {
-		await client.query(require_core.SQL`SELECT 1`);
+		await client.query(SQL`SELECT 1`);
 		return { successful: true };
 	} catch (error) {
 		const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
@@ -244,7 +2685,7 @@ const checkConnection = async (fileName, serializer) => {
 		await client.close();
 	}
 };
-const sqlite3Connection = (options) => require_core$1.sqliteConnection({
+const sqlite3Connection = (options) => sqliteConnection({
 	type: "Client",
 	driverType: SQLite3DriverType,
 	sqliteClientFactory: (connectionOptions) => {
@@ -260,15 +2701,18 @@ const sqlite3Connection = (options) => require_core$1.sqliteConnection({
 
 //#endregion
 //#region src/storage/sqlite/sqlite3/pool/singletonPool.ts
+const DEFAULT_SQLITE_MAX_TASK_IDLE_TIME_MS = 3e4;
 const sqlite3SingletonPool = (options) => {
-	const inner = require_core.createSingletonConnectionPool({
+	const maxTaskIdleTime = options.maxTaskIdleTime ?? 3e4;
+	const inner = createSingletonConnectionPool({
 		driverType: options.driverType,
 		getConnection: options.getConnection,
 		...options.closeConnection ? { closeConnection: options.closeConnection } : {}
 	});
-	const taskProcessor = new require_core.TaskProcessor({
+	const taskProcessor = new TaskProcessor({
 		maxActiveTasks: 1,
-		maxQueueSize: options.maxQueueSize ?? 1e3
+		maxQueueSize: options.maxQueueSize ?? 1e3,
+		maxTaskIdleTime
 	});
 	const insideWriterTask = new node_async_hooks.AsyncLocalStorage();
 	const enqueue = (op) => {
@@ -293,9 +2737,9 @@ const sqlite3SingletonPool = (options) => {
 			command: (sql, commandOptions) => enqueue(() => inner.execute.command(sql, commandOptions)),
 			batchCommand: (sqls, commandOptions) => enqueue(() => inner.execute.batchCommand(sqls, commandOptions))
 		},
-		close: async () => {
-			await taskProcessor.stop();
-			await inner.close();
+		close: async (closeOptions) => {
+			await taskProcessor.stop({ ...closeOptions?.force ? { force: true } : {} });
+			await inner.close(closeOptions);
 		}
 	};
 };
@@ -306,7 +2750,7 @@ const sqliteDualConnectionPool = (options) => {
 	const { sqliteConnectionFactory, connectionOptions } = options;
 	const readerPoolSize = options.readerPoolSize ?? Math.max(4, (0, os.cpus)().length);
 	let databaseInitPromise = null;
-	const guardSingleConnection = require_core.guardInitializedOnce(async () => {
+	const guardSingleConnection = guardInitializedOnce(async () => {
 		if (databaseInitPromise !== null) return databaseInitPromise;
 		const initConnection = sqliteConnectionFactory({
 			...connectionOptions,
@@ -321,7 +2765,7 @@ const sqliteDualConnectionPool = (options) => {
 		} catch (error) {
 			databaseInitPromise = null;
 			await initConnection.close();
-			throw require_core$1.mapSqliteError(error);
+			throw mapSqliteError(error);
 		}
 	});
 	const ensureDatabaseInitialized = async () => {
@@ -340,9 +2784,10 @@ const sqliteDualConnectionPool = (options) => {
 	};
 	const writerPool = sqlite3SingletonPool({
 		driverType: options.driverType,
-		getConnection: () => wrappedConnectionFactory(false, connectionOptions)
+		getConnection: () => wrappedConnectionFactory(false, connectionOptions),
+		...options.maxTaskIdleTime !== void 0 ? { maxTaskIdleTime: options.maxTaskIdleTime } : {}
 	});
-	const readerPool = require_core.createBoundedConnectionPool({
+	const readerPool = createBoundedConnectionPool({
 		driverType: options.driverType,
 		getConnection: () => wrappedConnectionFactory(true, connectionOptions),
 		maxConnections: readerPoolSize
@@ -369,29 +2814,37 @@ const sqliteDualConnectionPool = (options) => {
 //#endregion
 //#region src/storage/sqlite/sqlite3/index.ts
 const sqlite3Pool = (options) => {
-	if ("connection" in options && options.connection) return require_core$1.sqlitePool(require_core$1.toSqlitePoolOptions({
+	if ("connection" in options && options.connection) return sqlitePool(toSqlitePoolOptions({
 		...options,
 		driverType: SQLite3DriverType
 	}));
 	const sqliteConnectionFactory = (opts) => sqlite3Connection({
 		...opts,
-		serializer: options.serializer ?? require_core.JSONSerializer
+		serializer: options.serializer ?? JSONSerializer
 	});
-	if (require_core$1.isInMemoryDatabase(options) || "client" in options && Boolean(options.client) || options.singleton === true) return sqlite3SingletonPool({
+	const isSingleton = isInMemoryDatabase(options) || "client" in options && Boolean(options.client) || options.singleton === true;
+	const lifecycleOptions = extractLifecycleOptions(options);
+	if (isSingleton) return sqlite3SingletonPool({
 		driverType: SQLite3DriverType,
-		getConnection: () => sqliteConnectionFactory(options)
+		getConnection: () => sqliteConnectionFactory(options),
+		...lifecycleOptions
 	});
 	const readerPoolSize = options.readerPoolSize;
 	return sqliteDualConnectionPool({
 		driverType: SQLite3DriverType,
 		sqliteConnectionFactory,
 		connectionOptions: options,
-		...readerPoolSize !== void 0 ? { readerPoolSize } : {}
+		...readerPoolSize !== void 0 ? { readerPoolSize } : {},
+		...lifecycleOptions
 	});
 };
+const extractLifecycleOptions = (options) => {
+	const lifecycle = options;
+	return { ...lifecycle.maxTaskIdleTime !== void 0 ? { maxTaskIdleTime: lifecycle.maxTaskIdleTime } : {} };
+};
 const tryParseConnectionString = (connectionString) => {
 	try {
-		return require_core$1.SQLiteConnectionString(connectionString);
+		return SQLiteConnectionString(connectionString);
 	} catch {
 		return null;
 	}
@@ -399,49 +2852,48 @@ const tryParseConnectionString = (connectionString) => {
 const sqlite3DumboDriver = {
 	driverType: SQLite3DriverType,
 	createPool: (options) => sqlite3Pool(options),
-	sqlFormatter: require_core$1.sqliteFormatter,
-	defaultMigratorOptions: require_core$1.DefaultSQLiteMigratorOptions,
-	canHandle: require_core.canHandleDriverWithConnectionString(SQLite3DriverType, tryParseConnectionString),
-	databaseMetadata: require_sqliteMetadata.sqliteMetadata
+	sqlFormatter: sqliteFormatter,
+	defaultMigratorOptions: DefaultSQLiteMigratorOptions,
+	canHandle: canHandleDriverWithConnectionString(SQLite3DriverType, tryParseConnectionString),
+	databaseMetadata: sqliteMetadata
 };
 const useSqlite3DumboDriver = () => {
-	require_core.dumboDatabaseDriverRegistry.register(SQLite3DriverType, sqlite3DumboDriver);
+	dumboDatabaseDriverRegistry.register(SQLite3DriverType, sqlite3DumboDriver);
 };
 useSqlite3DumboDriver();
 
 //#endregion
-exports.DEFAULT_SQLITE_PRAGMA_OPTIONS = require_core$1.DEFAULT_SQLITE_PRAGMA_OPTIONS;
-exports.DefaultSQLiteMigratorOptions = require_core$1.DefaultSQLiteMigratorOptions;
-exports.InMemorySQLiteDatabase = require_core$1.InMemorySQLiteDatabase;
+exports.DEFAULT_SQLITE_PRAGMA_OPTIONS = DEFAULT_SQLITE_PRAGMA_OPTIONS;
+exports.DefaultSQLiteMigratorOptions = DefaultSQLiteMigratorOptions;
+exports.InMemorySQLiteDatabase = InMemorySQLiteDatabase;
 exports.SQLite3DriverType = SQLite3DriverType;
-exports.SQLiteConnectionString = require_core$1.SQLiteConnectionString;
-exports.SQLiteDatabaseName = require_core$1.SQLiteDatabaseName;
-exports.SQLiteJSON = require_core$1.SQLiteJSON;
+exports.SQLiteConnectionString = SQLiteConnectionString;
+exports.SQLiteDatabaseName = SQLiteDatabaseName;
+exports.SQLiteJSON = SQLiteJSON;
 exports.checkConnection = checkConnection;
-exports.defaultSQLiteDatabase = require_sqliteMetadata.defaultSQLiteDatabase;
-exports.isInMemoryDatabase = require_core$1.isInMemoryDatabase;
-exports.isSQLiteError = require_core$1.isSQLiteError;
-exports.mapSqliteError = require_core$1.mapSqliteError;
-exports.parsePragmasFromConnectionString = require_core$1.parsePragmasFromConnectionString;
+exports.defaultSQLiteDatabase = defaultSQLiteDatabase;
+exports.isInMemoryDatabase = isInMemoryDatabase;
+exports.isSQLiteError = isSQLiteError;
+exports.mapSqliteError = mapSqliteError;
+exports.parsePragmasFromConnectionString = parsePragmasFromConnectionString;
 exports.sqlite3Client = sqlite3Client;
 exports.sqlite3Connection = sqlite3Connection;
 exports.sqlite3DumboDriver = sqlite3DumboDriver;
 exports.sqlite3Pool = sqlite3Pool;
-exports.sqliteAlwaysNewConnectionPool = require_core$1.sqliteAlwaysNewConnectionPool;
-exports.sqliteAmbientClientConnection = require_core$1.sqliteAmbientClientConnection;
-exports.sqliteAmbientConnectionPool = require_core$1.sqliteAmbientConnectionPool;
-exports.sqliteClientConnection = require_core$1.sqliteClientConnection;
-exports.sqliteConnection = require_core$1.sqliteConnection;
-exports.sqliteExecute = require_core$1.sqliteExecute;
-exports.sqliteFormatter = require_core$1.sqliteFormatter;
-exports.sqliteMetadata = require_sqliteMetadata.sqliteMetadata;
-exports.sqlitePool = require_core$1.sqlitePool;
-exports.sqlitePoolClientConnection = require_core$1.sqlitePoolClientConnection;
-exports.sqliteSQLExecutor = require_core$1.sqliteSQLExecutor;
-exports.sqliteSingletonConnectionPool = require_core$1.sqliteSingletonConnectionPool;
-exports.sqliteTransaction = require_core$1.sqliteTransaction;
-exports.tableExists = require_sqliteMetadata.tableExists;
-exports.toSqlitePoolOptions = require_core$1.toSqlitePoolOptions;
-exports.transactionNestingCounter = require_core$1.transactionNestingCounter;
+exports.sqliteAlwaysNewConnectionPool = sqliteAlwaysNewConnectionPool;
+exports.sqliteAmbientClientConnection = sqliteAmbientClientConnection;
+exports.sqliteAmbientConnectionPool = sqliteAmbientConnectionPool;
+exports.sqliteClientConnection = sqliteClientConnection;
+exports.sqliteConnection = sqliteConnection;
+exports.sqliteExecute = sqliteExecute;
+exports.sqliteFormatter = sqliteFormatter;
+exports.sqliteMetadata = sqliteMetadata;
+exports.sqlitePool = sqlitePool;
+exports.sqlitePoolClientConnection = sqlitePoolClientConnection;
+exports.sqliteSQLExecutor = sqliteSQLExecutor;
+exports.sqliteSingletonConnectionPool = sqliteSingletonConnectionPool;
+exports.sqliteTransaction = sqliteTransaction;
+exports.tableExists = tableExists;
+exports.toSqlitePoolOptions = toSqlitePoolOptions;
 exports.useSqlite3DumboDriver = useSqlite3DumboDriver;
 //# sourceMappingURL=sqlite3.cjs.map