@atscript/db-postgres 0.1.39 → 0.1.41

package/dist/index.mjs

@@ -1,31 +1,45 @@
+import { t as PostgresPlugin } from "./plugin-C4tRUZGB.mjs";
 import { AtscriptDbView, BaseDbAdapter, DbError, DbSpace } from "@atscript/db";
 import { buildAggregateCount, buildAggregateSelect, buildCreateView, buildDelete, buildInsert, buildSelect, buildUpdate, buildWhere as buildWhere$1, defaultValueForType, defaultValueToSqlLiteral, finalizeParams, refActionToSql } from "@atscript/db-sql-tools";
-import { AnnotationSpec } from "@atscript/core";
-
-//#region packages/db-postgres/src/sql-builder.ts
+//#region src/sql-builder.ts
+/**
+* PostgreSQL-aware default value for a given design type.
+* PG uses native BOOLEAN (not TINYINT), so defaults must be `false`/`true` not `0`/`1`.
+*/
 function defaultValueForType$1(designType) {
 	if (designType === "boolean") return "false";
 	if (designType === "json" || designType === "object") return "'{}'";
 	if (designType === "array") return "'[]'";
 	return defaultValueForType(designType);
 }
+/**
+* PostgreSQL-aware default value literal.
+* Converts boolean defaults to `true`/`false` instead of `1`/`0`.
+*/
 function defaultValueToSqlLiteral$1(designType, value) {
 	if (designType === "boolean") return value === "true" || value === "1" ? "true" : "false";
 	return defaultValueToSqlLiteral(designType, value);
 }
+/** Escapes a PostgreSQL identifier by doubling double-quotes. */
 function esc(name) {
 	return name.replace(/"/g, "\"\"");
 }
+/** Double-quote-quotes a single identifier. */
 function qi(name) {
 	return `"${esc(name)}"`;
 }
+/**
+* Double-quote-quotes a table name, handling `schema.table` format.
+* Input is a raw name like `public.users` or just `users`.
+*/
 function quoteTableName(name) {
 	const dot = name.indexOf(".");
 	if (dot >= 0) return `${qi(name.slice(0, dot))}.${qi(name.slice(dot + 1))}`;
 	return qi(name);
 }
-/** Converts JS values to SQL-bindable params, keeping booleans native. */ function toPgValue(value) {
-	if (value === undefined) return null;
+/** Converts JS values to SQL-bindable params, keeping booleans native. */
+function toPgValue(value) {
+	if (value === void 0) return null;
 	if (value === null) return null;
 	if (value instanceof Date) return value.toISOString();
 	if (typeof value === "object") return JSON.stringify(value);
@@ -41,7 +55,7 @@ const pgDialect = {
 	unlimitedLimit: "ALL",
 	toValue: toPgValue,
 	toParam(value) {
-		if (value === undefined) return null;
+		if (value === void 0) return null;
 		return value;
 	},
 	regex(quotedCol, value) {
@@ -62,8 +76,8 @@ function buildInsert$1(table, data) {
 function buildSelect$1(table, where, controls) {
 	return buildSelect(pgDialect, table, where, controls);
 }
-function buildUpdate$1(table, data, where, limit) {
-	return buildUpdate(pgDialect, table, data, where, limit);
+function buildUpdate$1(table, data, where, limit, ops) {
+	return buildUpdate(pgDialect, table, data, where, limit, ops);
 }
 function buildDelete$1(table, where, limit) {
 	return buildDelete(pgDialect, table, where, limit);
@@ -77,6 +91,13 @@ function buildAggregateSelect$1(table, where, controls) {
 function buildAggregateCount$1(table, where, controls) {
 	return buildAggregateCount(pgDialect, table, where, controls);
 }
+/**
+* Maps portable collation values to PostgreSQL collation names.
+*
+* Returns `null` for `'nocase'` — case-insensitive columns use CITEXT type instead
+* (provisioned via `CREATE EXTENSION IF NOT EXISTS citext` in `ensureTable`).
+* Users can also opt into ICU collation explicitly via `@db.pg.collate "und-u-ks-level2"`.
+*/
 function collationToPg(collation) {
 	switch (collation) {
 		case "binary": return "\"C\"";
@@ -90,7 +111,8 @@ function collationToPg(collation) {
 * PostgreSQL only has signed integer types:
 *   uint16 (0-65535) → INTEGER (not SMALLINT which caps at 32767)
 *   uint32 (0-4.3B)  → BIGINT  (not INTEGER which caps at ~2.1B)
-*/ function intTypeFromTags(tags) {
+*/
+function intTypeFromTags(tags) {
 	if (tags?.has("int8") || tags?.has("byte")) return "SMALLINT";
 	if (tags?.has("uint8")) return "SMALLINT";
 	if (tags?.has("int16") || tags?.has("port")) return "SMALLINT";
@@ -100,6 +122,12 @@ function collationToPg(collation) {
 	if (tags?.has("int64") || tags?.has("uint64")) return "BIGINT";
 	return "INTEGER";
 }
+/**
+* Maps an Atscript field descriptor to a PostgreSQL column type.
+*
+* For FK fields, delegates to the target PK's type via `field.fkTargetField`
+* so the FK column type always matches the referenced column.
+*/
 function pgTypeFromField(field) {
 	if (field.fkTargetField) return pgTypeFromField(field.fkTargetField);
 	const tags = field.type?.type?.tags;
@@ -108,36 +136,36 @@ function pgTypeFromField(field) {
 	if (pgTypeOverride) return pgTypeOverride;
 	const precision = metadata?.get("db.column.precision");
 	switch (field.designType) {
-		case "number": {
+		case "number":
 			if (precision) return `NUMERIC(${precision.precision},${precision.scale})`;
 			if (field.defaultValue?.kind === "fn" && field.defaultValue.fn === "increment") return "BIGINT";
 			if (field.defaultValue?.kind === "fn" && field.defaultValue.fn === "now") return "BIGINT";
 			if (tags?.has("int")) return intTypeFromTags(tags);
 			return "DOUBLE PRECISION";
-		}
 		case "integer": return intTypeFromTags(tags);
-		case "decimal": {
+		case "decimal":
 			if (precision) return `NUMERIC(${precision.precision},${precision.scale})`;
 			return "NUMERIC(10,2)";
-		}
 		case "boolean": return "BOOLEAN";
 		case "string": {
 			if (field.collate === "nocase" && !metadata?.get("db.pg.collate")) return "CITEXT";
 			if (tags?.has("char")) return "CHAR(1)";
-			const maxLen = metadata?.get("expect.maxLength")?.length;
-			if (maxLen !== undefined) return `VARCHAR(${maxLen})`;
+			const maxLen = (metadata?.get("expect.maxLength"))?.length;
+			if (maxLen !== void 0) return `VARCHAR(${maxLen})`;
 			if (field.isPrimaryKey || field.defaultValue) return "VARCHAR(255)";
 			return "TEXT";
 		}
 		case "json":
 		case "object":
 		case "array": return "JSONB";
-		default: {
+		default:
 			if (field.isPrimaryKey || field.defaultValue) return "VARCHAR(255)";
 			return "TEXT";
-		}
 	}
 }
+/**
+* Builds a CREATE TABLE IF NOT EXISTS statement with PostgreSQL syntax.
+*/
 function buildCreateTable(table, fields, foreignKeys, options) {
 	const colDefs = [];
 	const primaryKeys = fields.filter((f) => f.isPrimaryKey);
@@ -147,17 +175,17 @@ function buildCreateTable(table, fields, foreignKeys, options) {
 		let def = `${qi(field.physicalName)} ${sqlType}`;
 		if (options?.incrementFields?.has(field.physicalName)) {
 			const start = options.autoIncrementStart;
-			def += start !== undefined ? ` GENERATED BY DEFAULT AS IDENTITY (START WITH ${start})` : " GENERATED BY DEFAULT AS IDENTITY";
+			def += start !== void 0 ? ` GENERATED BY DEFAULT AS IDENTITY (START WITH ${start})` : " GENERATED BY DEFAULT AS IDENTITY";
 		}
 		if (!field.optional && !field.isPrimaryKey && !options?.incrementFields?.has(field.physicalName)) def += " NOT NULL";
 		if (field.defaultValue?.kind === "value") def += ` DEFAULT ${defaultValueToSqlLiteral$1(field.designType, field.defaultValue.value)}`;
-else if (field.defaultValue?.kind === "fn") {
+		else if (field.defaultValue?.kind === "fn") {
 			if (field.defaultValue.fn === "uuid") def += " DEFAULT gen_random_uuid()";
-else if (field.defaultValue.fn === "now") def += " DEFAULT (extract(epoch from now()) * 1000)::bigint";
+			else if (field.defaultValue.fn === "now") def += " DEFAULT (extract(epoch from now()) * 1000)::bigint";
 		}
 		const nativeCollate = field.type?.metadata?.get("db.pg.collate");
 		if (nativeCollate) def += ` COLLATE "${nativeCollate}"`;
-else if (field.collate) {
+		else if (field.collate) {
 			const pgCollate = collationToPg(field.collate);
 			if (pgCollate) def += ` COLLATE ${pgCollate}`;
 		}
@@ -183,41 +211,82 @@ else if (field.collate) {
 	}
 	return `CREATE TABLE IF NOT EXISTS ${quoteTableName(table)} (${colDefs.join(", ")})`;
 }
+/**
+* Offsets numbered placeholders ($1, $2, ...) in a SQL fragment by a given amount.
+* Used when WHERE params follow SET params in UPDATE statements.
+*/
 function offsetPlaceholders(fragment, offset) {
 	if (offset === 0) return fragment;
-	const sql = fragment.sql.replace(/\$(\d+)/g, (_, n) => `$${Number(n) + offset}`);
 	return {
-		sql,
+		sql: fragment.sql.replace(/\$(\d+)/g, (_, n) => `$${Number(n) + offset}`),
 		params: fragment.params
 	};
 }
-
 //#endregion
-//#region packages/db-postgres/src/filter-builder.ts
+//#region src/filter-builder.ts
+/**
+* Translates a filter expression into a parameterized PostgreSQL WHERE clause.
+*
+* Note: The returned fragment uses `?` placeholders (not `$N`).
+* Finalization to `$N` happens when the fragment is consumed by a DML builder
+* (buildSelect, buildUpdate, etc.) via the dialect's `paramPlaceholder`.
+*
+* Case-insensitive columns (`@db.collate 'nocase'`) are handled by CITEXT
+* column type at the storage level — no query-side wrapping needed.
+*/
 function buildWhere(filter) {
 	return buildWhere$1(pgDialect, filter);
 }
-
 //#endregion
-//#region packages/db-postgres/src/postgres-adapter.ts
-function _define_property$1(obj, key, value) {
-	if (key in obj) Object.defineProperty(obj, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-else obj[key] = value;
-	return obj;
-}
-/** PostgreSQL COUNT() may return string (bigint) — parse to number. */ function parseCount(value) {
+//#region src/postgres-adapter.ts
+/** PostgreSQL COUNT() may return string (bigint) — parse to number. */
+function parseCount(value) {
 	if (typeof value === "string") return Number.parseInt(value, 10);
 	return value ?? 0;
 }
+/**
+* PostgreSQL adapter for {@link AtscriptDbTable}.
+*
+* Accepts any {@link TPgDriver} implementation — the actual PostgreSQL driver
+* is fully swappable (pg Pool, custom implementations, etc.).
+*
+* Usage:
+* ```typescript
+* import { PgDriver, PostgresAdapter } from '@atscript/db-postgres'
+* import { DbSpace } from '@atscript/db'
+*
+* const driver = new PgDriver('postgresql://user@localhost:5432/mydb')
+* const space = new DbSpace(() => new PostgresAdapter(driver))
+* const users = space.getTable(UsersType)
+* ```
+*/
 var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
-	/** Schema name for queries (null falls through to 'public'). */ get _schema() {
+	supportsColumnModify = true;
+	static NATIVE_DEFAULT_FNS = new Set([
+		"now",
+		"uuid",
+		"increment"
+	]);
+	_incrementFields = /* @__PURE__ */ new Set();
+	_autoIncrementStart;
+	/** Physical column names with @db.collate 'nocase'. Used to trigger CITEXT extension. */
+	_nocaseColumns = /* @__PURE__ */ new Set();
+	/** Whether citext extension has been provisioned (avoids redundant round-trips). */
+	_citextProvisioned = false;
+	/** Whether the connected PostgreSQL instance has the pgvector extension. */
+	_supportsVector;
+	/** Vector fields: physical field name → { dimensions, similarity, indexName }. */
+	_vectorFields = /* @__PURE__ */ new Map();
+	/** Default similarity thresholds per vector field (from @db.search.vector.threshold). */
+	_vectorThresholds = /* @__PURE__ */ new Map();
+	/** Schema name for queries (null falls through to 'public'). */
+	get _schema() {
 		return this._table.schema ?? null;
 	}
+	constructor(driver) {
+		super();
+		this.driver = driver;
+	}
 	async _beginTransaction() {
 		const conn = await this.driver.getConnection();
 		try {
@@ -250,11 +319,12 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 	/**
 	* Returns the active executor: dedicated connection if inside a transaction,
 	* otherwise the pool-based driver.
-	*/ _exec() {
-		const txState = this._getTransactionState();
-		return txState ?? this.driver;
+	*/
+	_exec() {
+		return this._getTransactionState() ?? this.driver;
 	}
-	/** PostgreSQL enforces FK constraints natively. */ supportsNativeForeignKeys() {
+	/** PostgreSQL enforces FK constraints natively. */
+	supportsNativeForeignKeys() {
 		return true;
 	}
 	prepareId(id, _fieldType) {
@@ -285,7 +355,7 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 				indexName
 			});
 			const threshold = metadata.get("db.search.vector.threshold");
-			if (threshold !== undefined) this._vectorThresholds.set(indexName, threshold);
+			if (threshold !== void 0) this._vectorThresholds.set(indexName, threshold);
 		}
 	}
 	getDesiredTableOptions() {
@@ -298,8 +368,9 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 	* Converts vector fields between JavaScript `number[]` and pgvector text format `[1,2,3]`.
 	* The pg driver serializes JS arrays as PostgreSQL array literals `{1,2,3}` which is
 	* invalid for the pgvector `vector` type — it expects bracket-delimited `[1,2,3]`.
-	*/ formatValue(field) {
-		if (!this._vectorFields.has(field.path)) return undefined;
+	*/
+	formatValue(field) {
+		if (!this._vectorFields.has(field.path)) return;
 		return {
 			toStorage: (value) => Array.isArray(value) ? `[${value.join(",")}]` : value,
 			fromStorage: (value) => typeof value === "string" ? JSON.parse(value) : value
@@ -312,29 +383,24 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 	* PostgreSQL uses SQLSTATE codes:
 	* - 23505 = unique_violation
 	* - 23503 = foreign_key_violation
-	*/ async _wrapConstraintError(fn) {
+	*/
+	async _wrapConstraintError(fn) {
 		try {
 			return await fn();
 		} catch (error) {
 			if (error && typeof error === "object" && "code" in error) {
 				const err = error;
-				if (err.code === "23505") {
-					const field = this._extractFieldFromConstraint(err.constraint) ?? "";
-					throw new DbError("CONFLICT", [{
-						path: field,
-						message: err.detail ?? err.message
-					}]);
-				}
-				if (err.code === "23503") {
-					const errors = this._mapFkError(err.detail ?? err.message, err.constraint);
-					throw new DbError("FK_VIOLATION", errors);
-				}
+				if (err.code === "23505") throw new DbError("CONFLICT", [{
+					path: this._extractFieldFromConstraint(err.constraint) ?? "",
+					message: err.detail ?? err.message
+				}]);
+				if (err.code === "23503") throw new DbError("FK_VIOLATION", this._mapFkError(err.detail ?? err.message, err.constraint));
 			}
 			throw error;
 		}
 	}
 	_extractFieldFromConstraint(constraint) {
-		if (!constraint) return undefined;
+		if (!constraint) return;
 		const tableName = this._table.tableName;
 		if (constraint.startsWith(`${tableName}_`) && constraint.endsWith("_key")) {
 			const fieldPart = constraint.slice(tableName.length + 1, -4);
@@ -347,9 +413,8 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 		const fkMatch = detail.match(/Key \(([^)]+)\)/);
 		if (fkMatch) {
 			const physicalCol = fkMatch[1].split(",")[0].trim();
-			const field = this._table.fieldDescriptors.find((f) => f.physicalName === physicalCol);
 			return [{
-				path: field?.path ?? physicalCol,
+				path: this._table.fieldDescriptors.find((f) => f.physicalName === physicalCol)?.path ?? physicalCol,
 				message: detail
 			}];
 		}
@@ -363,9 +428,8 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 		const pkCols = this._table.primaryKeys.map((pk) => qi(pk));
 		if (pkCols.length > 0) sql += ` RETURNING ${pkCols.join(", ")}`;
 		this._log(sql, params);
-		const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
-		const returned = result.rows?.[0];
-		return { insertedId: this._resolveInsertedId(data, returned ? Object.values(returned)[0] : undefined) };
+		const returned = (await this._wrapConstraintError(() => this._exec().run(sql, params))).rows?.[0];
+		return { insertedId: this._resolveInsertedId(data, returned ? Object.values(returned)[0] : void 0) };
 	}
 	async insertMany(data) {
 		if (data.length === 0) return {
@@ -400,7 +464,7 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 				const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
 				for (let i = 0; i < batchSize; i++) {
 					const returned = result.rows?.[i];
-					allIds.push(this._resolveInsertedId(data[offset + i], returned ? Object.values(returned)[0] : undefined));
+					allIds.push(this._resolveInsertedId(data[offset + i], returned ? Object.values(returned)[0] : void 0));
 				}
 			}
 			return {
@@ -427,40 +491,32 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 	}
 	async count(query) {
 		const where = buildWhere(query.filter);
-		const tableName = this.resolveTableName();
-		const raw = {
-			sql: `SELECT COUNT(*) as cnt FROM ${quoteTableName(tableName)} WHERE ${where.sql}`,
+		const { sql, params } = finalizeParams(pgDialect, {
+			sql: `SELECT COUNT(*) as cnt FROM ${quoteTableName(this.resolveTableName())} WHERE ${where.sql}`,
 			params: where.params
-		};
-		const { sql, params } = finalizeParams(pgDialect, raw);
+		});
 		this._log(sql, params);
-		const row = await this._exec().get(sql, params);
-		return parseCount(row?.cnt);
+		return parseCount((await this._exec().get(sql, params))?.cnt);
 	}
 	async aggregate(query) {
 		const where = buildWhere(query.filter);
 		const tableName = this.resolveTableName();
 		if (query.controls.$count) {
-			const { sql: sql$1, params: params$1 } = buildAggregateCount$1(tableName, where, query.controls);
-			this._log(sql$1, params$1);
-			const row = await this._exec().get(sql$1, params$1);
-			const count = parseCount(row?.count);
-			return [{ count }];
+			const { sql, params } = buildAggregateCount$1(tableName, where, query.controls);
+			this._log(sql, params);
+			return [{ count: parseCount((await this._exec().get(sql, params))?.count) }];
 		}
 		const { sql, params } = buildAggregateSelect$1(tableName, where, query.controls);
 		this._log(sql, params);
 		return this._exec().all(sql, params);
 	}
-	async updateOne(filter, data) {
+	async updateOne(filter, data, ops) {
 		const where = buildWhere(filter);
 		const tableName = this.resolveTableName();
-		const keys = Object.keys(data);
-		const setClauses = keys.map((k, i) => `${qi(k)} = $${i + 1}`);
-		const setParams = keys.map((k) => pgDialect.toValue(data[k]));
-		const finalizedWhere = finalizeParams(pgDialect, where);
-		const offsetWhere = offsetPlaceholders(finalizedWhere, keys.length);
-		const sql = `UPDATE ${quoteTableName(tableName)} SET ${setClauses.join(", ")} WHERE ctid = (SELECT ctid FROM ${quoteTableName(tableName)} WHERE ${offsetWhere.sql} LIMIT 1)`;
-		const params = [...setParams, ...where.params];
+		const { sql, params } = buildUpdate$1(tableName, data, {
+			sql: `ctid = (SELECT ctid FROM ${quoteTableName(tableName)} WHERE ${where.sql} LIMIT 1)`,
+			params: where.params
+		}, void 0, ops);
 		this._log(sql, params);
 		const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
 		return {
@@ -468,9 +524,9 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 			modifiedCount: result.affectedRows
 		};
 	}
-	async updateMany(filter, data) {
+	async updateMany(filter, data, ops) {
 		const where = buildWhere(filter);
-		const { sql, params } = buildUpdate$1(this.resolveTableName(), data, where);
+		const { sql, params } = buildUpdate$1(this.resolveTableName(), data, where, void 0, ops);
 		this._log(sql, params);
 		const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
 		return {
@@ -487,21 +543,18 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 	async deleteOne(filter) {
 		const where = buildWhere(filter);
 		const tableName = this.resolveTableName();
-		const raw = {
+		const { sql, params } = finalizeParams(pgDialect, {
 			sql: `DELETE FROM ${quoteTableName(tableName)} WHERE ctid = (SELECT ctid FROM ${quoteTableName(tableName)} WHERE ${where.sql} LIMIT 1)`,
 			params: where.params
-		};
-		const { sql, params } = finalizeParams(pgDialect, raw);
+		});
 		this._log(sql, params);
-		const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
-		return { deletedCount: result.affectedRows };
+		return { deletedCount: (await this._wrapConstraintError(() => this._exec().run(sql, params))).affectedRows };
 	}
 	async deleteMany(filter) {
 		const where = buildWhere(filter);
 		const { sql, params } = buildDelete$1(this.resolveTableName(), where);
 		this._log(sql, params);
-		const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
-		return { deletedCount: result.affectedRows };
+		return { deletedCount: (await this._wrapConstraintError(() => this._exec().run(sql, params))).affectedRows };
 	}
 	async ensureTable() {
 		if (this._nocaseColumns.size > 0 && !this._citextProvisioned) try {
@@ -509,9 +562,9 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 			this._citextProvisioned = true;
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
-			throw new Error(`Failed to create citext extension for @db.collate 'nocase' columns: ${msg}. ` + `Either run 'CREATE EXTENSION citext' as a superuser, or use @db.pg.type "CITEXT" after provisioning the extension manually.`);
+			throw new Error(`Failed to create citext extension for @db.collate 'nocase' columns: ${msg}. Either run 'CREATE EXTENSION citext' as a superuser, or use @db.pg.type "CITEXT" after provisioning the extension manually.`, { cause: err });
 		}
-		if (this._supportsVector === undefined && this._vectorFields.size > 0) await this._detectVectorSupport();
+		if (this._supportsVector === void 0 && this._vectorFields.size > 0) await this._detectVectorSupport();
 		if (this._table instanceof AtscriptDbView) return this._ensureView();
 		const sql = buildCreateTable(this.resolveTableName(), this._table.fieldDescriptors, this._table.foreignKeys, {
 			incrementFields: this._incrementFields,
@@ -569,18 +622,18 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 			const sqlType = this.typeMapper(field);
 			let ddl = `ALTER TABLE ${quoteTableName(tableName)} ADD COLUMN ${qi(field.physicalName)} ${sqlType}`;
 			if (field.defaultValue?.kind === "fn" && field.defaultValue.fn === "increment") ddl += " GENERATED BY DEFAULT AS IDENTITY";
-else {
+			else {
 				if (!field.optional && !field.isPrimaryKey) ddl += " NOT NULL";
 				if (field.defaultValue?.kind === "value") ddl += ` DEFAULT ${defaultValueToSqlLiteral$1(field.designType, field.defaultValue.value)}`;
-else if (field.defaultValue?.kind === "fn") {
+				else if (field.defaultValue?.kind === "fn") {
 					if (field.defaultValue.fn === "uuid") ddl += " DEFAULT gen_random_uuid()";
-else if (field.defaultValue.fn === "now") ddl += " DEFAULT (extract(epoch from now()) * 1000)::bigint";
+					else if (field.defaultValue.fn === "now") ddl += " DEFAULT (extract(epoch from now()) * 1000)::bigint";
 				} else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValueForType$1(field.designType)}`;
 			}
 			if (field.collate) {
 				const nativeCollate = field.type?.metadata?.get("db.pg.collate");
 				if (nativeCollate) ddl += ` COLLATE "${nativeCollate}"`;
-else {
+				else {
 					const pgCollate = collationToPg(field.collate);
 					if (pgCollate) ddl += ` COLLATE ${pgCollate}`;
 				}
@@ -611,7 +664,7 @@ else {
 		for (const { field } of diff.defaultChanged ?? []) {
 			let ddl;
 			if (field.defaultValue?.kind === "value") ddl = `ALTER TABLE ${quoteTableName(tableName)} ALTER COLUMN ${qi(field.physicalName)} SET DEFAULT ${defaultValueToSqlLiteral$1(field.designType, field.defaultValue.value)}`;
-else if (field.defaultValue?.kind === "fn") {
+			else if (field.defaultValue?.kind === "fn") {
 				const fnExpr = field.defaultValue.fn === "now" ? "(extract(epoch from now()) * 1000)::bigint" : field.defaultValue.fn === "uuid" ? "gen_random_uuid()" : `${field.defaultValue.fn}()`;
 				ddl = `ALTER TABLE ${quoteTableName(tableName)} ALTER COLUMN ${qi(field.physicalName)} SET DEFAULT ${fnExpr}`;
 			} else ddl = `ALTER TABLE ${quoteTableName(tableName)} ALTER COLUMN ${qi(field.physicalName)} DROP DEFAULT`;
@@ -647,7 +700,7 @@ else if (field.defaultValue?.kind === "fn") {
              SELECT constraint_name FROM information_schema.table_constraints
              WHERE table_name = $2 AND table_schema = COALESCE($1, 'public') AND constraint_type = 'PRIMARY KEY'
            )`, [schema, this._table.tableName]);
-			const fkByName = new Map();
+			const fkByName = /* @__PURE__ */ new Map();
 			for (const fk of fkRefs) {
 				let entry = fkByName.get(fk.constraint_name);
 				if (!entry) {
@@ -726,7 +779,8 @@ else if (field.defaultValue?.kind === "fn") {
 	* value doesn't conflict with existing data. PostgreSQL's GENERATED BY DEFAULT
 	* AS IDENTITY does not advance the sequence when rows are inserted with explicit
 	* values, so this is needed after data seeding, bulk imports, or recreateTable().
-	*/ async _resetIdentitySequences() {
+	*/
+	async _resetIdentitySequences() {
 		if (this._incrementFields.size === 0) return;
 		const tableName = this.resolveTableName();
 		const emptyFallback = this._autoIncrementStart ?? 1;
@@ -738,8 +792,7 @@ else if (field.defaultValue?.kind === "fn") {
 		}
 	}
 	async tableExists() {
-		const row = await this._exec().get(`SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = $1 AND table_schema = COALESCE($2, 'public')) AS "exists"`, [this._table.tableName, this._schema]);
-		return row?.exists ?? false;
+		return (await this._exec().get(`SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = $1 AND table_schema = COALESCE($2, 'public')) AS "exists"`, [this._table.tableName, this._schema]))?.exists ?? false;
 	}
 	async dropTable() {
 		const ddl = `DROP TABLE IF EXISTS ${quoteTableName(this.resolveTableName())} CASCADE`;
@@ -785,9 +838,9 @@ else if (field.defaultValue?.kind === "fn") {
 			createIndex: async (index) => {
 				if (index.type === "fulltext") {
 					const tsvectorExpr = this._buildTsvectorExpr(index.fields);
-					const sql$1 = `CREATE INDEX IF NOT EXISTS ${qi(index.key)} ON ${quoteTableName(this.resolveTableName())} USING gin(to_tsvector('english', ${tsvectorExpr}))`;
-					this._log(sql$1);
-					await this._exec().exec(sql$1);
+					const sql = `CREATE INDEX IF NOT EXISTS ${qi(index.key)} ON ${quoteTableName(this.resolveTableName())} USING gin(to_tsvector('english', ${tsvectorExpr}))`;
+					this._log(sql);
+					await this._exec().exec(sql);
 					return;
 				}
 				const unique = index.type === "unique" ? "UNIQUE " : "";
@@ -797,8 +850,7 @@ else if (field.defaultValue?.kind === "fn") {
 				await this._exec().exec(sql);
 			},
 			dropIndex: async (name) => {
-				const schemaPrefix = schema ? `${qi(schema)}.` : "";
-				const sql = `DROP INDEX IF EXISTS ${schemaPrefix}${qi(name)}`;
+				const sql = `DROP INDEX IF EXISTS ${schema ? `${qi(schema)}.` : ""}${qi(name)}`;
 				this._log(sql);
 				await this._exec().exec(sql);
 			}
@@ -813,19 +865,19 @@ else if (field.defaultValue?.kind === "fn") {
 	}
 	async syncForeignKeys() {
 		const existingByName = await this._getExistingFkConstraints();
-		const desiredFkKeys = new Set();
-		for (const fk of this._table.foreignKeys.values()) desiredFkKeys.add([...fk.fields].sort().join(","));
+		const desiredFkKeys = /* @__PURE__ */ new Set();
+		for (const fk of this._table.foreignKeys.values()) desiredFkKeys.add([...fk.fields].toSorted().join(","));
 		for (const [constraintName, columns] of existingByName) {
-			const key = [...columns].sort().join(",");
+			const key = [...columns].toSorted().join(",");
 			if (!desiredFkKeys.has(key)) {
 				const ddl = `ALTER TABLE ${quoteTableName(this.resolveTableName())} DROP CONSTRAINT ${qi(constraintName)}`;
 				this._log(ddl);
 				await this._exec().exec(ddl);
 			}
 		}
-		const existingKeys = new Set([...existingByName.values()].map((cols) => cols.sort().join(",")));
+		const existingKeys = new Set([...existingByName.values()].map((cols) => cols.toSorted().join(",")));
 		for (const fk of this._table.foreignKeys.values()) {
-			const key = [...fk.fields].sort().join(",");
+			const key = [...fk.fields].toSorted().join(",");
 			if (!existingKeys.has(key)) {
 				const localCols = fk.fields.map((f) => qi(f)).join(", ");
 				const targetCols = fk.targetFields.map((f) => qi(f)).join(", ");
@@ -842,7 +894,7 @@ else if (field.defaultValue?.kind === "fn") {
 		const keySet = new Set(fkFieldKeys);
 		const existingByName = await this._getExistingFkConstraints();
 		for (const [constraintName, cols] of existingByName) {
-			const key = cols.sort().join(",");
+			const key = cols.toSorted().join(",");
 			if (keySet.has(key)) {
 				const ddl = `ALTER TABLE ${quoteTableName(this.resolveTableName())} DROP CONSTRAINT ${qi(constraintName)}`;
 				this._log(ddl);
@@ -850,14 +902,15 @@ else if (field.defaultValue?.kind === "fn") {
 			}
 		}
 	}
-	/** Queries information_schema for existing FK constraints. */ async _getExistingFkConstraints() {
+	/** Queries information_schema for existing FK constraints. */
+	async _getExistingFkConstraints() {
 		const rows = await this._exec().all(`SELECT kcu.constraint_name, kcu.column_name
        FROM information_schema.table_constraints tc
        JOIN information_schema.key_column_usage kcu
          ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
        WHERE tc.table_name = $1 AND tc.table_schema = COALESCE($2, 'public')
          AND tc.constraint_type = 'FOREIGN KEY'`, [this._table.tableName, this._schema]);
-		const byName = new Map();
+		const byName = /* @__PURE__ */ new Map();
 		for (const row of rows) {
 			let cols = byName.get(row.constraint_name);
 			if (!cols) {
@@ -902,14 +955,12 @@ else if (field.defaultValue?.kind === "fn") {
 			return this._exec().all(sql, params);
 		})();
 		const countPromise = (async () => {
-			const raw = {
+			const { sql, params } = finalizeParams(pgDialect, {
 				sql: `SELECT COUNT(*) as cnt FROM ${quoteTableName(tableName)} WHERE ${combinedWhere.sql}`,
 				params: combinedWhere.params
-			};
-			const { sql, params } = finalizeParams(pgDialect, raw);
+			});
 			this._log(sql, params);
-			const row = await this._exec().get(sql, params);
-			return parseCount(row?.cnt);
+			return parseCount((await this._exec().get(sql, params))?.cnt);
 		})();
 		const [data, count] = await Promise.all([selectPromise, countPromise]);
 		return {
@@ -928,20 +979,21 @@ else if (field.defaultValue?.kind === "fn") {
 			params: [...where.params, text]
 		};
 	}
-	/** Builds the tsvector SQL expression for a fulltext index's fields. Must match between index DDL and queries. */ _buildTsvectorExpr(fields) {
+	/** Builds the tsvector SQL expression for a fulltext index's fields. Must match between index DDL and queries. */
+	_buildTsvectorExpr(fields) {
 		return fields.map((f) => `coalesce(${qi(f.name)}, '')`).join(" || ' ' || ");
 	}
 	_getFulltextIndex(indexName) {
 		for (const index of this._table.indexes.values()) if (index.type === "fulltext") {
 			if (!indexName || index.key === indexName) return index;
 		}
-		return undefined;
 	}
 	/**
 	* Detects pgvector support by attempting to enable the extension.
 	* Idempotent — safe to call multiple times.
-	*/ async _detectVectorSupport() {
-		if (this._supportsVector !== undefined) return this._supportsVector;
+	*/
+	async _detectVectorSupport() {
+		if (this._supportsVector !== void 0) return this._supportsVector;
 		try {
 			await this._exec().exec("CREATE EXTENSION IF NOT EXISTS vector");
 			this._supportsVector = true;
@@ -968,13 +1020,13 @@ else if (field.defaultValue?.kind === "fn") {
 		this._log(sql, params);
 		this._log(countSql, countParams);
 		const [data, countRow] = await Promise.all([this._exec().all(sql, params), this._exec().get(countSql, countParams)]);
-		const count = parseCount(countRow?.cnt);
 		return {
 			data,
-			count
+			count: parseCount(countRow?.cnt)
 		};
 	}
-	/** Resolves vector field and computes shared context for vector search SQL builders. */ _prepareVectorSearch(vector, query, indexName) {
+	/** Resolves vector field and computes shared context for vector search SQL builders. */
+	_prepareVectorSearch(vector, query, indexName) {
 		let field;
 		let vec;
 		if (indexName) {
@@ -1012,7 +1064,7 @@ else if (field.defaultValue?.kind === "fn") {
 		let inner = `SELECT *, (${qi(ctx.field)} ${ctx.distanceOp} $1::vector) AS _distance FROM ${quoteTableName(ctx.tableName)} WHERE ${offsetPlaceholders(finalizeParams(pgDialect, ctx.where), 1).sql}`;
 		const params = [ctx.vectorStr, ...ctx.where.params];
 		let sql = `SELECT * FROM (${inner}) _v`;
-		if (ctx.threshold !== undefined) {
+		if (ctx.threshold !== void 0) {
 			sql += ` WHERE _distance <= $${params.length + 1}`;
 			params.push(thresholdToDistance(ctx.threshold, ctx.vec.similarity));
 		}
@@ -1034,7 +1086,7 @@ else if (field.defaultValue?.kind === "fn") {
 		let inner = `SELECT (${qi(ctx.field)} ${ctx.distanceOp} $1::vector) AS _distance FROM ${quoteTableName(ctx.tableName)} WHERE ${offsetPlaceholders(finalizeParams(pgDialect, ctx.where), 1).sql}`;
 		const params = [ctx.vectorStr, ...ctx.where.params];
 		let sql = `SELECT COUNT(*) AS cnt FROM (${inner}) _v`;
-		if (ctx.threshold !== undefined) {
+		if (ctx.threshold !== void 0) {
 			sql += ` WHERE _distance <= $${params.length + 1}`;
 			params.push(thresholdToDistance(ctx.threshold, ctx.vec.similarity));
 		}
@@ -1043,26 +1095,19 @@ else if (field.defaultValue?.kind === "fn") {
 			params
 		};
 	}
-	/** Resolves threshold: query-time $threshold > schema-level @db.search.vector.threshold. */ _resolveVectorThreshold(controls, indexName) {
+	/** Resolves threshold: query-time $threshold > schema-level @db.search.vector.threshold. */
+	_resolveVectorThreshold(controls, indexName) {
 		const queryThreshold = controls.$threshold;
-		if (queryThreshold !== undefined) return queryThreshold;
+		if (queryThreshold !== void 0) return queryThreshold;
 		return this._vectorThresholds.get(indexName);
 	}
-	constructor(driver) {
-		super(), _define_property$1(this, "driver", void 0), _define_property$1(this, "supportsColumnModify", void 0), _define_property$1(this, "_incrementFields", void 0), _define_property$1(this, "_autoIncrementStart", void 0), _define_property$1(this, "_nocaseColumns", void 0), _define_property$1(this, "_citextProvisioned", void 0), _define_property$1(this, "_supportsVector", void 0), _define_property$1(this, "_vectorFields", void 0), _define_property$1(this, "_vectorThresholds", void 0), this.driver = driver, this.supportsColumnModify = true, this._incrementFields = new Set(), this._nocaseColumns = new Set(), this._citextProvisioned = false, this._vectorFields = new Map(), this._vectorThresholds = new Map();
-	}
 };
-_define_property$1(PostgresAdapter, "NATIVE_DEFAULT_FNS", new Set([
-	"now",
-	"uuid",
-	"increment"
-]));
 /**
 * Normalizes PostgreSQL information_schema data_type values
 * to match the format produced by `pgTypeFromField()`.
-*/ function normalizePgType(dataType, maxLength, numericPrecision, numericScale, udtName, formattedType) {
-	const dt = dataType.toLowerCase();
-	switch (dt) {
+*/
+function normalizePgType(dataType, maxLength, numericPrecision, numericScale, udtName, formattedType) {
+	switch (dataType.toLowerCase()) {
 		case "character varying": return maxLength ? `VARCHAR(${maxLength})` : "VARCHAR(255)";
 		case "character": return maxLength ? `CHAR(${maxLength})` : "CHAR(1)";
 		case "integer": return "INTEGER";
@@ -1077,20 +1122,20 @@ _define_property$1(PostgresAdapter, "NATIVE_DEFAULT_FNS", new Set([
 		case "timestamp with time zone": return "TIMESTAMPTZ";
 		case "timestamp without time zone": return "TIMESTAMP";
 		case "uuid": return "UUID";
-		case "user-defined": {
+		case "user-defined":
 			if (udtName === "vector") return formattedType;
 			if (udtName === "citext") return "CITEXT";
 			return udtName?.toUpperCase() ?? "USER-DEFINED";
-		}
 		default: return dataType.toUpperCase();
 	}
 }
 /**
 * Normalizes PostgreSQL column_default values to match the format
 * produced by `serializeDefaultValue()`.
-*/ function normalizePgDefault(value, isIdentity) {
+*/
+function normalizePgDefault(value, isIdentity) {
 	if (isIdentity === "YES") return "fn:increment";
-	if (value === null) return undefined;
+	if (value === null) return;
 	let cleaned = value;
 	while (cleaned.startsWith("(") && cleaned.endsWith(")")) cleaned = cleaned.slice(1, -1);
 	const lower = cleaned.toLowerCase();
@@ -1113,60 +1158,58 @@ _define_property$1(PostgresAdapter, "NATIVE_DEFAULT_FNS", new Set([
 * pgvector cosine distance = 1 - cosine_similarity, range [0, 2]
 *
 * Conversion: distance = 2 * (1 - score)
-*/ function thresholdToDistance(threshold, similarity) {
+*/
+function thresholdToDistance(threshold, similarity) {
 	switch (similarity) {
 		case "euclidean": return threshold;
 		case "dotProduct": return -threshold;
 		default: return 2 * (1 - threshold);
 	}
 }
-/** Maps generic similarity metric to PostgreSQL distance operator. */ function similarityToPgOp(similarity) {
+/** Maps generic similarity metric to PostgreSQL distance operator. */
+function similarityToPgOp(similarity) {
 	switch (similarity) {
 		case "euclidean": return "<->";
 		case "dotProduct": return "<#>";
 		default: return "<=>";
 	}
 }
-/** Maps generic similarity metric to pgvector index ops class. */ function similarityToPgOps(similarity) {
+/** Maps generic similarity metric to pgvector index ops class. */
+function similarityToPgOps(similarity) {
 	switch (similarity) {
 		case "euclidean": return "vector_l2_ops";
 		case "dotProduct": return "vector_ip_ops";
 		default: return "vector_cosine_ops";
 	}
 }
-/** Formats a number[] vector as pgvector input: '[1.0, 2.0, ...]'. */ function vectorToString(vector) {
+/** Formats a number[] vector as pgvector input: '[1.0, 2.0, ...]'. */
+function vectorToString(vector) {
 	return `[${vector.join(",")}]`;
 }
-
 //#endregion
-//#region packages/db-postgres/src/pg-driver.ts
-function _define_property(obj, key, value) {
-	if (key in obj) Object.defineProperty(obj, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-else obj[key] = value;
-	return obj;
-}
-/** pg rejects `undefined` in bind arrays — coerce to `null`. */ function sanitizeParams(params) {
+//#region src/pg-driver.ts
+/** pg rejects `undefined` in bind arrays — coerce to `null`. */
+function sanitizeParams(params) {
 	if (!params) return [];
-	return params.map((v) => v === undefined ? null : v);
+	return params.map((v) => v === void 0 ? null : v);
 }
-/** Parses TIMESTAMP/TIMESTAMPTZ to epoch milliseconds. */ function parseTimestamp(val) {
+/** Parses TIMESTAMP/TIMESTAMPTZ to epoch milliseconds. */
+function parseTimestamp(val) {
 	const ms = new Date(val).getTime();
 	return Number.isNaN(ms) ? val : ms;
 }
-/** Parses NUMERIC to number. */ function parseNumeric(val) {
+/** Parses NUMERIC to number. */
+function parseNumeric(val) {
 	const n = Number.parseFloat(val);
 	return Number.isNaN(n) ? val : n;
 }
-/** Parses INT8/BIGINT to number. Returns string if value exceeds safe integer range. */ function parseBigInt(val) {
+/** Parses INT8/BIGINT to number. Returns string if value exceeds safe integer range. */
+function parseBigInt(val) {
 	const n = Number.parseInt(val, 10);
 	return Number.isNaN(n) || !Number.isSafeInteger(n) ? val : n;
 }
-/** OIDs for types we override. */ const TIMESTAMP_OID = 1114;
+/** OIDs for types we override. */
+const TIMESTAMP_OID = 1114;
 const TIMESTAMPTZ_OID = 1184;
 const NUMERIC_OID = 1700;
 const INT8_OID = 20;
@@ -1177,7 +1220,8 @@ const INT8_OID = 20;
 * - TIMESTAMP/TIMESTAMPTZ → epoch milliseconds (number)
 * - NUMERIC → number (not string)
 * - INT8/BIGINT → number (for JS-safe range)
-*/ function createCustomTypes(pgTypes) {
+*/
+function createCustomTypes(pgTypes) {
 	const overrides = new Map([
 		[TIMESTAMP_OID, parseTimestamp],
 		[TIMESTAMPTZ_OID, parseTimestamp],
@@ -1190,35 +1234,78 @@ const INT8_OID = 20;
 		return pgTypes.getTypeParser(oid, format);
 	} };
 }
+/**
+* {@link TPgDriver} implementation backed by `pg` (node-postgres).
+*
+* Accepts a connection URI string, a `pg.PoolConfig` object, or a pre-created
+* `pg.Pool` instance.
+*
+* ```typescript
+* import { PgDriver } from '@atscript/db-postgres'
+*
+* // Connection URI
+* const driver = new PgDriver('postgresql://user:pass@localhost:5432/mydb')
+*
+* // Pool options
+* const driver = new PgDriver({
+*   host: 'localhost',
+*   user: 'postgres',
+*   database: 'mydb',
+*   max: 10,
+* })
+*
+* // Pre-created pool
+* import pg from 'pg'
+* const pool = new pg.Pool({ connectionString: '...' })
+* const driver = new PgDriver(pool)
+* ```
+*
+* Requires `pg` to be installed:
+* ```bash
+* pnpm add pg
+* ```
+*/
 var PgDriver = class {
+	pool;
+	poolInit;
+	constructor(poolOrConfig) {
+		if (typeof poolOrConfig === "object" && typeof poolOrConfig.query === "function") this.pool = poolOrConfig;
+		else this.poolInit = import("pg").then((pg) => {
+			const Pool = pg.default?.Pool ?? pg.Pool;
+			const types = pg.default?.types ?? pg.types;
+			const customTypes = types ? createCustomTypes(types) : void 0;
+			if (typeof poolOrConfig === "string") this.pool = new Pool({
+				connectionString: poolOrConfig,
+				types: customTypes
+			});
+			else this.pool = new Pool({
+				...poolOrConfig,
+				types: customTypes
+			});
+			return this.pool;
+		});
+	}
 	getPool() {
 		return this.pool || this.poolInit;
 	}
 	async run(sql, params) {
-		const pool = await this.getPool();
-		const result = await pool.query(sql, sanitizeParams(params));
+		const result = await (await this.getPool()).query(sql, sanitizeParams(params));
 		return {
 			affectedRows: result.rowCount ?? 0,
 			rows: result.rows ?? []
 		};
 	}
 	async all(sql, params) {
-		const pool = await this.getPool();
-		const result = await pool.query(sql, sanitizeParams(params));
-		return result.rows;
+		return (await (await this.getPool()).query(sql, sanitizeParams(params))).rows;
 	}
 	async get(sql, params) {
-		const pool = await this.getPool();
-		const result = await pool.query(sql, sanitizeParams(params));
-		return result.rows[0] ?? null;
+		return (await (await this.getPool()).query(sql, sanitizeParams(params))).rows[0] ?? null;
 	}
 	async exec(sql) {
-		const pool = await this.getPool();
-		await pool.query(sql);
+		await (await this.getPool()).query(sql);
 	}
 	async getConnection() {
-		const pool = await this.getPool();
-		const client = await pool.connect();
+		const client = await (await this.getPool()).connect();
 		return {
 			async run(sql, params) {
 				const result = await client.query(sql, sanitizeParams(params));
@@ -1228,12 +1315,10 @@ var PgDriver = class {
 				};
 			},
 			async all(sql, params) {
-				const result = await client.query(sql, sanitizeParams(params));
-				return result.rows;
+				return (await client.query(sql, sanitizeParams(params))).rows;
 			},
 			async get(sql, params) {
-				const result = await client.query(sql, sanitizeParams(params));
-				return result.rows[0] ?? null;
+				return (await client.query(sql, sanitizeParams(params))).rows[0] ?? null;
 			},
 			async exec(sql) {
 				await client.query(sql);
@@ -1244,76 +1329,18 @@ var PgDriver = class {
 		};
 	}
 	async close() {
-		const pool = await this.getPool();
-		await pool.end();
-	}
-	constructor(poolOrConfig) {
-		_define_property(this, "pool", void 0);
-		_define_property(this, "poolInit", void 0);
-		if (typeof poolOrConfig === "object" && typeof poolOrConfig.query === "function") this.pool = poolOrConfig;
-else this.poolInit = import("pg").then((pg) => {
-			const Pool = pg.default?.Pool ?? pg.Pool;
-			const types = pg.default?.types ?? pg.types;
-			const customTypes = types ? createCustomTypes(types) : undefined;
-			if (typeof poolOrConfig === "string") this.pool = new Pool({
-				connectionString: poolOrConfig,
-				types: customTypes
-			});
-else this.pool = new Pool({
-				...poolOrConfig,
-				types: customTypes
-			});
-			return this.pool;
-		});
+		await (await this.getPool()).end();
 	}
 };
-
 //#endregion
-//#region packages/db-postgres/src/plugin/annotations.ts
-const annotations = {
-	type: new AnnotationSpec({
-		description: "Overrides the native PostgreSQL column type.\n\n```atscript\n@db.pg.type \"CITEXT\"\nname: string\n```",
-		nodeType: ["prop"],
-		multiple: false,
-		argument: {
-			name: "type",
-			type: "string",
-			description: "Native PostgreSQL column type (e.g., \"CITEXT\", \"INET\", \"MACADDR\")."
-		}
-	}),
-	schema: new AnnotationSpec({
-		description: "Specifies the PostgreSQL schema for the table.\n\n**Default:** `\"public\"`\n\n```atscript\n@db.pg.schema \"analytics\"\nexport interface Events { ... }\n```",
-		nodeType: ["interface"],
-		multiple: false,
-		argument: {
-			name: "schema",
-			type: "string",
-			description: "PostgreSQL schema name (e.g., \"public\", \"analytics\")."
-		}
-	}),
-	collate: new AnnotationSpec({
-		description: "Specifies a native PostgreSQL collation (overrides portable `@db.column.collate`).\n\n```atscript\n@db.pg.collate \"tr-x-icu\"\nname: string\n```",
-		nodeType: ["interface", "prop"],
-		multiple: false,
-		argument: {
-			name: "collation",
-			type: "string",
-			description: "Native PostgreSQL collation name (e.g., \"tr-x-icu\", \"C\", \"und-x-icu\")."
-		}
-	})
-};
-
-//#endregion
-//#region packages/db-postgres/src/plugin/index.ts
-const PostgresPlugin = () => ({
-	name: "postgres",
-	config() {
-		return { annotations: { db: { pg: annotations } } };
-	}
-});
-
-//#endregion
-//#region packages/db-postgres/src/index.ts
+//#region src/index.ts
+/**
+* Creates a {@link DbSpace} backed by a PostgreSQL connection pool.
+*
+* @param uri - PostgreSQL connection URI (e.g., `postgresql://user@localhost:5432/mydb`)
+* @param options - Additional pool options passed to pg.
+* @returns A `DbSpace` that creates `PostgresAdapter` instances per table.
+*/
 function createAdapter(uri, options) {
 	const driver = new PgDriver({
 		connectionString: uri,
@@ -1321,6 +1348,5 @@ function createAdapter(uri, options) {
 	});
 	return new DbSpace(() => new PostgresAdapter(driver));
 }
-
 //#endregion
-export { PgDriver, PostgresAdapter, PostgresPlugin, buildWhere, createAdapter };
+export { PgDriver, PostgresAdapter, PostgresPlugin, buildWhere, createAdapter };