@happyvertical/sql 0.80.6 → 0.81.1

package/dist/index.js

@@ -1,7 +1,7 @@
-import { i as parseConditionKey, n as buildWhere, r as formatDbError, t as DatabaseSchemaManager } from "./chunks/schema-manager-a8RlxIE2.js";
+import { a as validateColumnName$1, c as validateTableName$1, d as formatDbError, f as parseConditionKey, i as generateCreateIndexStatement, l as DatabaseSchemaManager, n as escapeStringLiteral, o as validateColumnNames, p as resolveInsertColumns, r as generateAddColumnStatement, s as validateIndexName, t as escapeQuotedIdentifier, u as buildWhere } from "./chunks/alter-utils-B900pfK_.js";
 import { t as convertUniqueIndexesToInlineConstraints } from "./chunks/duckdb-schema-utils-B-XBP8QF.js";
 import { a as dropPostgresDatabase, c as postgresEnvFromUrl, i as databaseNameFromUrl, l as redactDatabaseUrl, n as assertCanImportDatabase, o as dumpPostgresDatabase, r as createPostgresDatabase, s as isLocalDatabaseUrl, t as assertCanExportDatabase, u as restorePostgresDatabase } from "./chunks/postgres-cli-DzZcXSIG.js";
-import { a as validateTableName$1, i as validateIndexName, n as generateCreateIndexStatement, r as validateColumnName$1, t as generateAddColumnStatement } from "./chunks/alter-utils-K7tiuj5L.js";
+import { n as resolveSchemas, r as createTransactionLock, t as NestedTransactionError } from "./chunks/types-uVFHgaSU.js";
 import { DatabaseError, loadEnvConfig } from "@happyvertical/utils";
 import { mkdir, readdir } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
@@ -308,48 +308,6 @@ function countValueFromRow(value) {
 	return "0";
 }
 //#endregion
-//#region src/shared/types.ts
-/**
-* Error thrown when `transaction()` is called on a transaction-scoped interface
-* belonging to an adapter whose engine has no savepoints.
-*
-* DuckDB — and therefore the JSON adapter built on it — does not implement
-* `SAVEPOINT`, so there is no way to re-enter the current transaction. Adapters
-* that can re-enter (PostgreSQL, SQLite) do so under a savepoint and never
-* throw this.
-*
-* The alternative would be to open a second, independent transaction, which is
-* what these adapters used to do; on a shared connection that silently
-* destroyed the enclosing transaction's uncommitted work.
-*
-* @example Ensuring a helper works on every adapter
-* ```typescript
-* // Take the transaction as a parameter rather than opening a nested one.
-* async function recordClick(db: DatabaseInterface, id: string) {
-*   await db.update('links', { id }, { clicks: 1 });
-* }
-* await db.transaction(async (tx) => recordClick(tx, id));
-* ```
-*/
-var NestedTransactionError = class extends DatabaseError {
-	constructor(message, context) {
-		super(message, context);
-		this.name = "NestedTransactionError";
-	}
-};
-/**
-* Resolves a SchemasOption to its concrete value.
-*
-* Adapters that need schemas (JSON, DuckDB) call this to unwrap the
-* lazy function. Adapters that don't (Postgres, SQLite) simply ignore
-* the `schemas` option without calling this.
-*/
-function resolveSchemas(schemas) {
-	if (!schemas) return void 0;
-	if (typeof schemas === "function") return schemas();
-	return schemas;
-}
-//#endregion
 //#region src/json.ts
 var json_exports = /* @__PURE__ */ __exportAll({
 	clearConnectionCache: () => clearConnectionCache,
@@ -430,21 +388,36 @@ async function createJSONConnection(options) {
 * This function only loads data - it assumes the table already exists with proper schema.
 * Used after DDL creates the table to load persisted JSON data.
 *
+* An unreadable or malformed file is tolerated with a warning - the table
+* structure is what matters and there is no data to lose.
+*
+* A failure to insert records that DID parse is logged loudly rather than
+* swallowed with the old dismissive "that's okay" warning: the resulting empty
+* table is a real surprise the caller should see (issue #1132). It is logged
+* rather than thrown so that one unloadable table cannot abort the load of every
+* other table sharing the same data directory or syncSchema() call - both of
+* those paths already load each table independently.
+*
 * @param connection - DuckDB connection
 * @param tableName - Name of the table to load data into
 * @param filePath - Path to the JSON file
 */
 async function loadJSONData(connection, tableName, filePath) {
+	let records;
 	try {
 		const { readFile } = await import("node:fs/promises");
 		const jsonContent = await readFile(filePath, "utf-8");
-		const records = JSON.parse(jsonContent);
-		if (Array.isArray(records) && records.length > 0) {
-			await insertRecordsWithCast(connection, tableName, records);
-			console.log(`[json-adapter] Loaded ${records.length} records into ${tableName} from JSON`);
-		}
+		records = JSON.parse(jsonContent);
+	} catch (error) {
+		console.warn(`[json-adapter] Could not read data for ${tableName}: ${error instanceof Error ? error.message : String(error)}`);
+		return;
+	}
+	if (!Array.isArray(records) || records.length === 0) return;
+	try {
+		const inserted = await insertRecordsWithCast(connection, tableName, records);
+		if (inserted > 0) console.log(`[json-adapter] Loaded ${inserted} records into ${tableName} from JSON`);
 	} catch (error) {
-		console.warn(`[json-adapter] Could not load data for ${tableName}: ${error instanceof Error ? error.message : String(error)}`);
+		console.error(`[json-adapter] Failed to load data for ${tableName}; the table will be empty:`, error);
 	}
 }
 /**
@@ -503,7 +476,7 @@ async function loadJSONTables(connection, dataDir, providedSchemas = {}, pending
 				}
 				else {
 					if (eagerLoadTables) try {
-						await connection.run(`CREATE TABLE IF NOT EXISTS "${tableName}" AS SELECT * FROM read_json_auto('${filePath}')`);
+						await connection.run(`CREATE TABLE IF NOT EXISTS "${escapeQuotedIdentifier(tableName)}" AS SELECT * FROM read_json_auto('${escapeStringLiteral(filePath)}')`);
 						inferredSchemaTables.add(tableName);
 						console.log(`[json-adapter] Eagerly created ${tableName} with inferred schema (no UNIQUE constraints)`);
 					} catch (error) {
@@ -635,25 +608,87 @@ async function createTableFromSchema(connection, tableName, schema) {
 	}
 }
 /**
+* Reads the column names of an existing table, keyed by lowercase name
+*
+* The table-name predicate is case-insensitive: DuckDB resolves identifiers
+* case-insensitively, so a data file named `Items.json` can back a table
+* created as `items`. Matching table_name exactly would find no columns and
+* make the loader wrongly report that every field is unmatched (issue #1132).
+*
+* @param connection - DuckDB connection
+* @param tableName - Name of the table to describe
+* @returns Map of lowercase column name to the column's declared name
+*/
+async function getTableColumns(connection, tableName) {
+	const reader = await connection.runAndReadAll("SELECT column_name FROM information_schema.columns WHERE LOWER(table_name) = LOWER($1) ORDER BY ordinal_position", [tableName]);
+	return new Map(reader.getRowObjects().map((row) => [String(row.column_name).toLowerCase(), String(row.column_name)]));
+}
+/**
 * Inserts records with proper CAST handling for empty strings
 *
 * This helper avoids using read_json() with auto_detect, which causes DuckDB
 * to re-infer column types from data (causing ANY type for empty strings).
 * Instead, it uses parameterized INSERT with CAST to maintain table schema.
 *
+* Used only for loading a JSON data file, where records having different key
+* sets is normal input rather than a caller error: a document with an optional
+* field omits that key entirely on the records that lack it. Columns are
+* therefore unioned across ALL records and any record missing a key binds NULL.
+* Deriving them from the first record alone bound `undefined` for a missing key
+* (which DuckDB rejects, losing every row) and dropped keys the first record
+* did not have (losing the column silently). See issue #1132.
+*
+* The caller-facing insert() API is a separate implementation (it resolves
+* columns through `resolveInsertColumns`) and is not affected by this
+* file-loading tolerance.
+*
 * @param connection - DuckDB connection
 * @param tableName - Name of the table to insert into
 * @param records - Array of records to insert
+* @returns Number of records inserted (0 if there was nothing loadable)
+* @throws DatabaseError if the resolved records cannot be inserted
 */
 async function insertRecordsWithCast(connection, tableName, records) {
-	if (records.length === 0) return;
-	const keys = Object.keys(records[0]);
+	if (records.length === 0) return 0;
+	const objectRecords = records.filter((record) => record != null && typeof record === "object" && !Array.isArray(record));
+	if (objectRecords.length === 0) return 0;
+	const unionedKeys = [];
+	const seenKeys = /* @__PURE__ */ new Set();
+	for (const record of objectRecords) for (const key of Object.keys(record)) if (!seenKeys.has(key)) {
+		seenKeys.add(key);
+		unionedKeys.push(key);
+	}
+	if (unionedKeys.length === 0) {
+		console.warn(`[json-adapter] Skipping data load for ${tableName}: records have no fields`);
+		return 0;
+	}
+	const tableColumns = await getTableColumns(connection, tableName);
+	const keys = [];
+	const columnNames = [];
+	const unmatchedKeys = [];
+	const claimedColumns = /* @__PURE__ */ new Set();
+	for (const key of unionedKeys) {
+		const column = tableColumns.get(key.toLowerCase());
+		if (column === void 0 || claimedColumns.has(column.toLowerCase())) unmatchedKeys.push(key);
+		else {
+			claimedColumns.add(column.toLowerCase());
+			keys.push(key);
+			columnNames.push(column);
+		}
+	}
+	if (unmatchedKeys.length > 0) console.warn(`[json-adapter] Ignoring ${unmatchedKeys.length} field(s) in ${tableName} data with no matching column: ${unmatchedKeys.join(", ")}`);
+	if (keys.length === 0) throw new DatabaseError(`No fields in the ${tableName} data file match a column on the table`, {
+		tableName,
+		fields: unionedKeys,
+		columns: [...tableColumns.values()]
+	});
+	const insertableRecords = objectRecords.filter((record) => keys.some((key) => key in record));
 	const values = [];
 	let paramIdx = 1;
-	const placeholders = records.map((record) => {
+	const placeholders = insertableRecords.map((record) => {
 		return `(${keys.map((key) => {
 			const value = record[key];
-			if (value === null) return "NULL";
+			if (value === null || value === void 0) return "NULL";
 			else if (value === "" && typeof value === "string") {
 				values.push(value);
 				return `CAST($${paramIdx++} AS TEXT)`;
@@ -672,8 +707,18 @@ async function insertRecordsWithCast(connection, tableName, records) {
 			}
 		}).join(", ")})`;
 	}).join(", ");
-	const sql = `INSERT INTO ${tableName} (${keys.join(", ")}) VALUES ${placeholders}`;
-	await connection.run(sql, values);
+	const sql = `INSERT INTO "${tableName}" (${columnNames.map((name) => `"${name}"`).join(", ")}) VALUES ${placeholders}`;
+	try {
+		await connection.run(sql, values);
+	} catch (e) {
+		throw new DatabaseError("Failed to load records into table", {
+			tableName,
+			recordCount: insertableRecords.length,
+			columns: columnNames,
+			originalError: formatDbError(e)
+		});
+	}
+	return insertableRecords.length;
 }
 /**
 * Validates that a table name is valid (alphanumeric + underscores only)
@@ -708,6 +753,7 @@ async function getDatabase$2(options) {
 		const { connection, pendingJSONFiles, inferredSchemaTables } = await createJSONConnection(options);
 		const writeStrategy = options.writeStrategy || "immediate";
 		const { url } = options;
+		const connectionLock = createTransactionLock("json", options.transactionQueueTimeout);
 		/**
 		* Inserts one or more records into a table
 		*
@@ -727,13 +773,14 @@ async function getDatabase$2(options) {
 				operation: "insert",
 				affected: 0
 			};
-			const keys = Object.keys(records[0]);
+			const keys = resolveInsertColumns(table, records);
+			validateColumnNames(keys);
 			const values = [];
 			let paramIdx = 1;
 			const placeholders = records.map((record) => {
 				return `(${keys.map((key) => {
 					const value = record[key];
-					if (value === null) return "NULL";
+					if (value === null || value === void 0) return "NULL";
 					else if (value === "" && typeof value === "string") {
 						values.push(value);
 						return `CAST($${paramIdx++} AS TEXT)`;
@@ -833,6 +880,7 @@ async function getDatabase$2(options) {
 				writeStrategy
 			});
 			const keys = Object.keys(data);
+			validateColumnNames(keys);
 			const setClause = keys.map((key, idx) => `${key} = $${idx + 1}`).join(", ");
 			const { sql: whereClause, values: whereValues } = buildWhere(where, keys.length + 1, "json");
 			const dataValues = Object.values(data).map((value) => value instanceof Date ? value.toISOString() : value);
@@ -882,7 +930,8 @@ async function getDatabase$2(options) {
 			const values = [];
 			const paramIdx = { value: 1 };
 			const assignments = keys.map((key) => {
-				return `"${key}" = ${buildJSONValueExpression(data[key], values, paramIdx)}`;
+				const valueExpr = buildJSONValueExpression(data[key], values, paramIdx);
+				return `"${escapeQuotedIdentifier(key)}" = ${valueExpr}`;
 			});
 			const { sql: whereClause, values: whereValues } = buildWhere(conflictWhere, paramIdx.value, "json");
 			const sql = `UPDATE "${table}" SET ${assignments.join(", ")} ${whereClause}`;
@@ -981,11 +1030,12 @@ async function getDatabase$2(options) {
 					paramIdx++;
 				}
 			}
-			const conflict = conflictColumns.map((col) => `"${col}"`).join(", ");
-			const quotedKeys = keys.map((key) => `"${key}"`).join(", ");
+			const conflict = conflictColumns.map((col) => `"${escapeQuotedIdentifier(col)}"`).join(", ");
+			const quotedKeys = keys.map((key) => `"${escapeQuotedIdentifier(key)}"`).join(", ");
 			const quotedUpdateSetParts = keys.map((key, i) => {
 				const part = updateSetParts[i];
-				return `"${key}" = ${part.substring(part.indexOf("=") + 1).trim()}`;
+				const valueExpr = part.substring(part.indexOf("=") + 1).trim();
+				return `"${escapeQuotedIdentifier(key)}" = ${valueExpr}`;
 			});
 			const sql = `INSERT INTO "${table}" (${quotedKeys}) VALUES (${placeholders.join(", ")}) ON CONFLICT(${conflict}) DO UPDATE SET ${quotedUpdateSetParts.join(", ")}`;
 			try {
@@ -1101,6 +1151,7 @@ async function getDatabase$2(options) {
 		* @returns Promise resolving to boolean indicating if the table exists
 		*/
 		const tableExists = async (tableName) => {
+			validateTableName(tableName);
 			try {
 				await connection.runAndReadAll(`SELECT * FROM ${tableName} LIMIT 1`);
 				return true;
@@ -1124,6 +1175,7 @@ async function getDatabase$2(options) {
 		* @param dataDir - Directory to write files
 		*/
 		const exportTableToJSON = async (connection, table, dataDir) => {
+			validateTableName(table);
 			const filePath = join(dataDir, `${table}.json`);
 			const schemaPath = join(dataDir, `${table}.schema.sql`);
 			try {
@@ -1199,7 +1251,7 @@ async function getDatabase$2(options) {
 				const { constants } = await import("node:fs");
 				await access(filePath, constants.F_OK);
 				console.log(`[json-adapter] Inferring schema for ${tableName} from JSON file`);
-				await connection.run(`CREATE TABLE "${tableName}" AS SELECT * FROM read_json_auto('${filePath}')`);
+				await connection.run(`CREATE TABLE "${tableName}" AS SELECT * FROM read_json_auto('${escapeStringLiteral(filePath)}')`);
 				pendingJSONFiles.delete(tableName);
 				console.log(`[json-adapter] Created ${tableName} with inferred schema (no UNIQUE constraints)`);
 			} catch (error) {
@@ -1497,7 +1549,7 @@ async function getDatabase$2(options) {
 		* @param callback - Function to execute within transaction
 		* @returns Promise resolving to callback result
 		*/
-		const transaction = async (callback) => {
+		const transaction = async (callback) => connectionLock.run(async () => {
 			try {
 				await connection.run("BEGIN TRANSACTION");
 				const result = await callback(createTransactionScope());
@@ -1509,7 +1561,7 @@ async function getDatabase$2(options) {
 				} catch {}
 				throw error;
 			}
-		};
+		});
 		/**
 		* Builds the transaction-scoped interface handed to a transaction callback.
 		*
@@ -1558,18 +1610,30 @@ async function getDatabase$2(options) {
 		* @returns Promise resolving to a TransactionHandle
 		*/
 		const beginTransaction = async () => {
-			await connection.run("BEGIN TRANSACTION");
+			const releaseConnection = await connectionLock.acquire();
+			try {
+				await connection.run("BEGIN TRANSACTION");
+			} catch (error) {
+				releaseConnection();
+				throw error;
+			}
 			let active = true;
-			const commit = async () => {
-				if (!active) throw new DatabaseError("Transaction already ended", {});
-				await connection.run("COMMIT");
-				active = false;
-			};
-			const rollback = async () => {
+			const end = async (command) => {
 				if (!active) throw new DatabaseError("Transaction already ended", {});
-				await connection.run("ROLLBACK");
-				active = false;
+				try {
+					await connection.run(command);
+				} catch (error) {
+					try {
+						await connection.run("ROLLBACK");
+					} catch {}
+					throw error;
+				} finally {
+					active = false;
+					releaseConnection();
+				}
 			};
+			const commit = () => end("COMMIT");
+			const rollback = () => end("ROLLBACK");
 			const isActive = () => active;
 			return {
 				...createTransactionScope(),
@@ -1818,10 +1882,36 @@ function toVectorLiteral(embedding) {
 * @param pool - PostgreSQL connection pool
 * @returns VectorCapabilities implementation
 */
+/**
+* `type` is interpolated into `USING <type>`, which cannot be parameterized and
+* is not an identifier the quoting helpers cover. `VectorIndexOptions.type`
+* constrains it at compile time only, so anything reaching this at runtime —
+* a JavaScript caller, or a `filter as VectorIndexOptions` on parsed JSON — has
+* to be checked against the values pgvector actually offers.
+*/
+var VECTOR_INDEX_TYPES = /* @__PURE__ */ new Set(["hnsw", "ivfflat"]);
+/**
+* `metric` needs the same treatment as `type`, for a less obvious reason.
+*
+* It never reaches SQL directly — `vectorOpsClass`/`vectorOperator` map it
+* through a closed switch with a safe default, so an unknown metric produces a
+* valid operator class. But it is also concatenated into the *generated index
+* name*, which is then interpolated into a quoted identifier, so a metric
+* carrying a `"` still ends that identifier. The safe-default mapping is what
+* makes this easy to miss: the part of the metric that looks dangerous is
+* handled, and the part that is actually dangerous is somewhere else.
+*/
+var VECTOR_METRICS = /* @__PURE__ */ new Set([
+	"cosine",
+	"l2",
+	"ip"
+]);
 function createVectorCapabilities(pool) {
 	return {
 		async ensureColumn(table, column, dimensions) {
 			if (!Number.isInteger(dimensions) || dimensions <= 0) throw new DatabaseError("Vector dimensions must be a positive integer", { dimensions });
+			validateTableName$1(table);
+			validateColumnName$1(column);
 			try {
 				await pool.query("CREATE EXTENSION IF NOT EXISTS vector");
 				await pool.query(`ALTER TABLE "${table}" ADD COLUMN IF NOT EXISTS "${column}" vector(${dimensions})`);
@@ -1835,8 +1925,22 @@ function createVectorCapabilities(pool) {
 			}
 		},
 		async ensureIndex(table, column, options) {
+			validateTableName$1(table);
+			validateColumnName$1(column);
 			const metric = options?.metric || "cosine";
 			const indexType = options?.type || "hnsw";
+			if (!VECTOR_INDEX_TYPES.has(indexType)) throw new DatabaseError("Unsupported vector index type", {
+				table,
+				column,
+				type: indexType,
+				supported: [...VECTOR_INDEX_TYPES]
+			});
+			if (!VECTOR_METRICS.has(metric)) throw new DatabaseError("Unsupported vector metric", {
+				table,
+				column,
+				metric,
+				supported: [...VECTOR_METRICS]
+			});
 			const opsClass = vectorOpsClass(metric);
 			const indexName = `idx_${table}_${column}_${metric}_${indexType}`;
 			try {
@@ -1851,7 +1955,10 @@ function createVectorCapabilities(pool) {
 			}
 		},
 		async upsertVector(table, where, column, embedding) {
+			validateTableName$1(table);
+			validateColumnName$1(column);
 			const keys = Object.keys(where);
+			validateColumnNames(keys);
 			const values = Object.values(where);
 			const conditions = keys.map((key, i) => `"${key}" IS NOT DISTINCT FROM $${i + 1}`).join(" AND ");
 			const vectorParam = `$${values.length + 1}`;
@@ -1867,6 +1974,8 @@ function createVectorCapabilities(pool) {
 			}
 		},
 		async search(table, column, embedding, options) {
+			validateTableName$1(table);
+			validateColumnName$1(column);
 			const metric = options?.metric || "cosine";
 			const limit = options?.limit || 10;
 			const op = vectorOperator(metric);
@@ -2014,6 +2123,15 @@ async function createDatabase(options, cacheKey) {
 	/**
 	* Serializes all values in an object for database storage
 	*/
+	/**
+	* The serializer the transaction-scoped interfaces have always used: none.
+	*
+	* Identity, deliberately — not even the `undefined`-dropping the pool-backed
+	* `serializeRecord` does. Those copies bound `undefined` straight through to
+	* `pg`, which stores NULL, whereas dropping the key omits the column and lets
+	* its default apply. Preserving that is the point of this parameter.
+	*/
+	const passThroughRecord = (record) => record;
 	const serializeRecord = (record) => {
 		const serialized = {};
 		for (const [key, value] of Object.entries(record)) {
@@ -2190,230 +2308,6 @@ async function createDatabase(options, cacheKey) {
 		return executeNullAwarePostgresUpsertInTransaction(table, conflictColumns, serializedData);
 	};
 	/**
-	* Inserts one or more records into a table
-	*
-	* @param table - Table name
-	* @param data - Single record or array of records to insert
-	* @returns Promise resolving to operation result
-	* @throws Error if the insert operation fails
-	*
-	* @example Single record insert:
-	* ```typescript
-	* await db.insert('users', {
-	*   name: 'John Doe',
-	*   email: 'john@example.com'
-	* });
-	* ```
-	*
-	* @example Multiple record insert:
-	* ```typescript
-	* await db.insert('users', [
-	*   { name: 'John', email: 'john@example.com' },
-	*   { name: 'Jane', email: 'jane@example.com' }
-	* ]);
-	* ```
-	*/
-	const insert = async (table, data) => {
-		if (Array.isArray(data)) {
-			const serializedRecords = data.map((record) => serializeRecord(record));
-			const keys = Object.keys(serializedRecords[0]);
-			const placeholders = serializedRecords.map((_, i) => `(${keys.map((_, j) => `$${i * keys.length + j + 1}`).join(", ")})`).join(", ");
-			const query = `INSERT INTO ${table} (${keys.join(", ")}) VALUES ${placeholders}`;
-			const values = serializedRecords.reduce((acc, row) => acc.concat(Object.values(row)), []);
-			return {
-				operation: "insert",
-				affected: (await client.query(query, values)).rowCount ?? 0
-			};
-		}
-		const serializedData = serializeRecord(data);
-		const keys = Object.keys(serializedData);
-		const values = Object.values(serializedData);
-		const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
-		const query = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`;
-		return {
-			operation: "insert",
-			affected: (await client.query(query, values)).rowCount ?? 0
-		};
-	};
-	/**
-	* Retrieves a single record matching the where criteria
-	*
-	* @param table - Table name
-	* @param where - Criteria to match records
-	* @returns Promise resolving to query result
-	*/
-	const get = async (table, where) => {
-		const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-		if (!whereClause) throw new DatabaseError("GET requires at least one WHERE condition to prevent returning an arbitrary record", { table });
-		const query = `SELECT * FROM ${table} ${whereClause}`;
-		try {
-			return (await client.query(query, values)).rows[0] || null;
-		} catch (e) {
-			throw new DatabaseError("Failed to retrieve record from table", {
-				table,
-				sql: query,
-				values,
-				originalError: formatDbError(e)
-			});
-		}
-	};
-	/**
-	* Retrieves multiple records matching the where criteria
-	*
-	* @param table - Table name
-	* @param where - Criteria to match records
-	* @returns Promise resolving to array of records
-	*/
-	const list = async (table, where) => {
-		const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-		const query = `SELECT * FROM ${table} ${whereClause}`;
-		try {
-			return (await client.query(query, values)).rows;
-		} catch (e) {
-			throw new DatabaseError("Failed to list records from table", {
-				table,
-				sql: query,
-				values,
-				originalError: formatDbError(e)
-			});
-		}
-	};
-	/**
-	* Updates records matching the where criteria
-	*
-	* @param table - Table name
-	* @param where - Criteria to match records to update
-	* @param data - New data to set
-	* @returns Promise resolving to operation result
-	*/
-	const update = async (table, where, data) => {
-		const serializedData = serializeRecord(data);
-		const keys = Object.keys(serializedData);
-		const values = Object.values(serializedData);
-		const setClause = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
-		const { sql: whereClause, values: whereValues } = buildWhere(where, values.length + 1, "postgres");
-		if (!whereClause) throw new DatabaseError("UPDATE requires at least one WHERE condition to prevent accidental update of all records", { table });
-		const sql = `UPDATE ${table} SET ${setClause} ${whereClause}`;
-		try {
-			return {
-				operation: "update",
-				affected: (await client.query(sql, [...values, ...whereValues])).rowCount ?? 0
-			};
-		} catch (e) {
-			throw new DatabaseError("Failed to update records in table", {
-				table,
-				sql,
-				values: [...values, ...whereValues],
-				originalError: formatDbError(e)
-			});
-		}
-	};
-	/**
-	* Inserts a record or updates it if it already exists (UPSERT)
-	*
-	* @param table - Table name
-	* @param conflictColumns - Columns that define the uniqueness constraint
-	* @param data - Data to insert or update
-	* @returns Promise resolving to operation result
-	* @throws Error if the upsert operation fails
-	*/
-	const upsert = async (table, conflictColumns, data, options) => {
-		try {
-			return await executePostgresUpsert(client, table, conflictColumns, data, options, true);
-		} catch (e) {
-			if (e instanceof DatabaseError && e.message === "Conflict columns missing from data") throw e;
-			throw new DatabaseError("Failed to upsert record into table", {
-				table,
-				values: data,
-				conflictColumns,
-				originalError: formatDbError(e)
-			});
-		}
-	};
-	/**
-	* Gets a record matching the where criteria or inserts it if not found
-	*
-	* @param table - Table name
-	* @param where - Criteria to match existing record
-	* @returns Promise resolving to the query result or insert result
-	*/
-	const getOrInsert = async (table, where, data) => {
-		const result = await get(table, where);
-		if (result) return result;
-		await insert(table, data);
-		const inserted = await get(table, where);
-		if (!inserted) throw new DatabaseError("Failed to insert and retrieve record", {
-			table,
-			where,
-			data
-		});
-		return inserted;
-	};
-	/**
-	* Deletes records from a table matching the where criteria
-	*
-	* @param table - Table name
-	* @param where - Criteria to match records for deletion
-	* @returns Promise resolving to operation result with count of deleted rows
-	* @throws Error if the delete operation fails
-	*/
-	const deleteRecords = async (table, where) => {
-		validateTableName$1(table);
-		if (Object.keys(where).length === 0) throw new DatabaseError("DELETE requires at least one WHERE condition to prevent accidental deletion of all records", { table });
-		const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-		try {
-			return {
-				operation: "delete",
-				affected: (await client.query(`DELETE FROM ${table} ${whereClause}`, values)).rowCount ?? 0
-			};
-		} catch (e) {
-			throw new DatabaseError("Failed to delete records from table", {
-				table,
-				where,
-				originalError: formatDbError(e)
-			});
-		}
-	};
-	/**
-	* Counts records in a table matching the where criteria
-	*
-	* @param table - Table name
-	* @param where - Criteria to match records (optional, counts all if omitted)
-	* @returns Promise resolving to count of matching records
-	* @throws Error if the count operation fails
-	*/
-	const count = async (table, where) => {
-		validateTableName$1(table);
-		try {
-			if (!where || Object.keys(where).length === 0) {
-				const result = await client.query(`SELECT COUNT(*) as count FROM ${table}`);
-				return Number(result.rows[0]?.count) || 0;
-			}
-			const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-			const result = await client.query(`SELECT COUNT(*) as count FROM ${table} ${whereClause}`, values);
-			return Number(result.rows[0]?.count) || 0;
-		} catch (e) {
-			throw new DatabaseError("Failed to count records in table", {
-				table,
-				where,
-				originalError: formatDbError(e)
-			});
-		}
-	};
-	/**
-	* Creates a table-specific interface for simplified table operations
-	*
-	* @param tableName - Table name
-	* @returns TableMethods interface for the specified table
-	*/
-	const table = (tableName) => {
-		return {
-			insert: (data) => insert(tableName, data),
-			get: (data) => get(tableName, data),
-			list: (data) => list(tableName, data)
-		};
-	};
-	/**
 	* Parses a tagged template literal into a SQL query and values
 	*
 	* @param strings - Template strings
@@ -2433,111 +2327,533 @@ async function createDatabase(options, cacheKey) {
 		};
 	};
 	/**
-	* Executes a SQL query using template literals and returns a single value
+	* Builds the complete set of query methods bound to one PostgreSQL client.
 	*
-	* @param strings - Template strings
-	* @param vars - Variables to interpolate into the query
-	* @returns Promise resolving to a single value (first column of first row)
-	*/
-	const pluck = async (strings, ...vars) => {
-		const { sql, values } = parseTemplate(strings, ...vars);
-		try {
-			const firstRow = (await client.query(sql, values)).rows[0];
-			if (!firstRow) return null;
-			return Object.values(firstRow)[0];
-		} catch (e) {
-			throw new DatabaseError("Failed to execute pluck query", {
-				sql,
-				values,
-				originalError: formatDbError(e)
-			});
-		}
-	};
-	/**
-	* Executes a SQL query using template literals and returns a single row
+	* The pool-backed interface and every transaction-scoped interface are
+	* instantiated from this one factory, so there is exactly one implementation
+	* of each method. The transaction interfaces used to be hand-maintained
+	* copies of these bodies, and both had drifted:
 	*
-	* @param strings - Template strings
-	* @param vars - Variables to interpolate into the query
-	* @returns Promise resolving to a single result record or null
-	*/
-	const single = async (strings, ...vars) => {
-		const { sql, values } = parseTemplate(strings, ...vars);
-		try {
-			return (await client.query(sql, values)).rows[0] || null;
-		} catch (e) {
-			throw new DatabaseError("Failed to execute single query", {
-				sql,
-				values,
-				originalError: formatDbError(e)
-			});
-		}
-	};
-	/**
-	* Executes a SQL query using template literals and returns multiple rows
+	* - they called the client bare, so a failure inside a transaction threw the
+	*   raw `pg` error rather than `DatabaseError`, and `instanceof` answered
+	*   differently depending on whether the call was in a transaction. `pg`
+	*   exports its own class also named `DatabaseError`, so nothing a developer
+	*   would check by eye showed the difference (#1115);
+	* - they re-exposed `tableExists` and `syncSchema` from the enclosing scope,
+	*   which close over the *pool*. Both therefore ran on a different connection
+	*   than the transaction, so `tx.tableExists()` could not see a table created
+	*   in the same transaction and `tx.syncSchema()` committed its DDL
+	*   immediately, surviving a rollback (#1111).
 	*
-	* @param strings - Template strings
-	* @param vars - Variables to interpolate into the query
-	* @returns Promise resolving to array of result records
-	*/
-	const many = async (strings, ...vars) => {
-		const { sql, values } = parseTemplate(strings, ...vars);
-		try {
-			return (await client.query(sql, values)).rows;
-		} catch (e) {
-			throw new DatabaseError("Failed to execute many query", {
-				sql,
-				values,
-				originalError: formatDbError(e)
-			});
-		}
-	};
-	/**
-	* Executes a SQL query using template literals without returning results
+	* Binding a client is the only difference between the two, so it is the only
+	* thing this factory parameterizes.
 	*
-	* @param strings - Template strings
-	* @param vars - Variables to interpolate into the query
-	* @returns Promise that resolves when the query completes
-	*/
-	const execute = async (strings, ...vars) => {
-		const { sql, values } = parseTemplate(strings, ...vars);
-		try {
-			await client.query(sql, values);
-		} catch (e) {
-			throw new DatabaseError("Failed to execute query", {
-				sql,
-				values,
-				originalError: formatDbError(e)
-			});
-		}
-	};
-	/**
-	* Executes a raw SQL query with parameterized values
+	* One thing is deliberately NOT unified: how `insert` and `update` serialize
+	* values. The pool-backed methods run every value through `serializeRecord`,
+	* which JSON-stringifies objects and arrays; the transaction-scoped copies
+	* never did, so they handed the raw value to `pg`. That is not a cosmetic
+	* difference — it decides what lands in the column, and no single answer is
+	* right for both shapes:
 	*
-	* Uses PostgreSQL-native placeholders ($1, $2, ...). Legacy ? placeholders
-	* are converted only when the placeholder count matches the supplied values,
-	* so Postgres operators such as JSONB ? remain intact.
+	* ```
+	*                    text[] column     jsonb column
+	*   raw JS array     accepted          "invalid input syntax for type json"
+	*   JSON string      "malformed        accepted
+	*                     array literal"
+	* ```
 	*
-	* @param sql - SQL query string
-	* @param values - Variables to use as parameters
-	* @returns Promise resolving to query result with rows and count
+	* So collapsing the two would have silently broken array-column writes inside
+	* a transaction while fixing jsonb-array writes, or the reverse — and would
+	* have corrupted `bytea` writes, where a Buffer would become the JSON of a
+	* Buffer with no error anywhere. Neither belongs in a fix for the error
+	* contract, so the serializer is a parameter: each interface keeps exactly
+	* the behaviour it had, and the difference is stated here instead of being an
+	* accident of two copies drifting apart.
+	*
+	* @param executor - Pool or checked-out client every statement runs on
+	* @param inTransaction - Whether `executor` is already inside a transaction
+	* @param serialize - Applied to each record before `insert`/`update` builds
+	*   its SQL. Pass-through for the transaction-scoped interfaces.
 	*/
-	const query = async (sql, ...values) => {
-		const query = normalizePostgresRawQuery(sql, values);
-		try {
-			const result = await client.query(query.sql, query.values);
+	const createClientMethods = (executor, inTransaction, serialize) => {
+		/**
+		* Inserts one or more records into a table
+		*
+		* @param table - Table name
+		* @param data - Single record or array of records to insert
+		* @returns Promise resolving to operation result
+		* @throws Error if the insert operation fails
+		*
+		* @example Single record insert:
+		* ```typescript
+		* await db.insert('users', {
+		*   name: 'John Doe',
+		*   email: 'john@example.com'
+		* });
+		* ```
+		*
+		* @example Multiple record insert:
+		* ```typescript
+		* await db.insert('users', [
+		*   { name: 'John', email: 'john@example.com' },
+		*   { name: 'Jane', email: 'jane@example.com' }
+		* ]);
+		* ```
+		*/
+		const insert = async (table, data) => {
+			validateTableName$1(table);
+			if (Array.isArray(data)) {
+				if (data.length === 0) return {
+					operation: "insert",
+					affected: 0
+				};
+				const serializedRecords = data.map((record) => serialize(record));
+				const keys = resolveInsertColumns(table, serializedRecords);
+				validateColumnNames(keys);
+				const placeholders = serializedRecords.map((_, i) => `(${keys.map((_, j) => `$${i * keys.length + j + 1}`).join(", ")})`).join(", ");
+				const query = `INSERT INTO ${table} (${keys.join(", ")}) VALUES ${placeholders}`;
+				const values = serializedRecords.flatMap((row) => keys.map((key) => row[key]));
+				return {
+					operation: "insert",
+					affected: (await executor.query(query, values)).rowCount ?? 0
+				};
+			}
+			const serializedData = serialize(data);
+			const keys = Object.keys(serializedData);
+			validateColumnNames(keys);
+			const values = Object.values(serializedData);
+			const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
+			const query = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`;
 			return {
-				rows: result.rows,
-				rowCount: result.rowCount ?? 0
+				operation: "insert",
+				affected: (await executor.query(query, values)).rowCount ?? 0
 			};
-		} catch (e) {
-			throw new DatabaseError("Failed to execute raw query", {
-				sql: query.sql,
-				values: query.values,
-				originalError: formatDbError(e)
-			});
-		}
-	};
-	/**
+		};
+		/**
+		* Retrieves a single record matching the where criteria
+		*
+		* @param table - Table name
+		* @param where - Criteria to match records
+		* @returns Promise resolving to query result
+		*/
+		const get = async (table, where) => {
+			validateTableName$1(table);
+			const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
+			if (!whereClause) throw new DatabaseError("GET requires at least one WHERE condition to prevent returning an arbitrary record", { table });
+			const query = `SELECT * FROM ${table} ${whereClause}`;
+			try {
+				return (await executor.query(query, values)).rows[0] || null;
+			} catch (e) {
+				throw new DatabaseError("Failed to retrieve record from table", {
+					table,
+					sql: query,
+					values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Retrieves multiple records matching the where criteria
+		*
+		* @param table - Table name
+		* @param where - Criteria to match records
+		* @returns Promise resolving to array of records
+		*/
+		const list = async (table, where) => {
+			validateTableName$1(table);
+			const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
+			const query = `SELECT * FROM ${table} ${whereClause}`;
+			try {
+				return (await executor.query(query, values)).rows;
+			} catch (e) {
+				throw new DatabaseError("Failed to list records from table", {
+					table,
+					sql: query,
+					values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Updates records matching the where criteria
+		*
+		* @param table - Table name
+		* @param where - Criteria to match records to update
+		* @param data - New data to set
+		* @returns Promise resolving to operation result
+		*/
+		const update = async (table, where, data) => {
+			validateTableName$1(table);
+			const serializedData = serialize(data);
+			const keys = Object.keys(serializedData);
+			validateColumnNames(keys);
+			const values = Object.values(serializedData);
+			const setClause = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
+			const { sql: whereClause, values: whereValues } = buildWhere(where, values.length + 1, "postgres");
+			if (!whereClause) throw new DatabaseError("UPDATE requires at least one WHERE condition to prevent accidental update of all records", { table });
+			const sql = `UPDATE ${table} SET ${setClause} ${whereClause}`;
+			try {
+				return {
+					operation: "update",
+					affected: (await executor.query(sql, [...values, ...whereValues])).rowCount ?? 0
+				};
+			} catch (e) {
+				throw new DatabaseError("Failed to update records in table", {
+					table,
+					sql,
+					values: [...values, ...whereValues],
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Inserts a record or updates it if it already exists (UPSERT)
+		*
+		* @param table - Table name
+		* @param conflictColumns - Columns that define the uniqueness constraint
+		* @param data - Data to insert or update
+		* @returns Promise resolving to operation result
+		* @throws Error if the upsert operation fails
+		*/
+		const upsert = async (table, conflictColumns, data, options) => {
+			validateTableName$1(table);
+			validateColumnNames([...conflictColumns, ...Object.keys(data)]);
+			try {
+				return await executePostgresUpsert(executor, table, conflictColumns, data, options, !inTransaction);
+			} catch (e) {
+				if (e instanceof DatabaseError && e.message === "Conflict columns missing from data") throw e;
+				throw new DatabaseError("Failed to upsert record into table", {
+					table,
+					values: data,
+					conflictColumns,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Gets a record matching the where criteria or inserts it if not found
+		*
+		* @param table - Table name
+		* @param where - Criteria to match existing record
+		* @returns Promise resolving to the query result or insert result
+		*/
+		const getOrInsert = async (table, where, data) => {
+			validateTableName$1(table);
+			const result = await get(table, where);
+			if (result) return result;
+			await insert(table, data);
+			const inserted = await get(table, where);
+			if (!inserted) throw new DatabaseError("Failed to insert and retrieve record", {
+				table,
+				where,
+				data
+			});
+			return inserted;
+		};
+		/**
+		* Deletes records from a table matching the where criteria
+		*
+		* @param table - Table name
+		* @param where - Criteria to match records for deletion
+		* @returns Promise resolving to operation result with count of deleted rows
+		* @throws Error if the delete operation fails
+		*/
+		const deleteRecords = async (table, where) => {
+			validateTableName$1(table);
+			if (Object.keys(where).length === 0) throw new DatabaseError("DELETE requires at least one WHERE condition to prevent accidental deletion of all records", { table });
+			const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
+			try {
+				return {
+					operation: "delete",
+					affected: (await executor.query(`DELETE FROM ${table} ${whereClause}`, values)).rowCount ?? 0
+				};
+			} catch (e) {
+				throw new DatabaseError("Failed to delete records from table", {
+					table,
+					where,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Counts records in a table matching the where criteria
+		*
+		* @param table - Table name
+		* @param where - Criteria to match records (optional, counts all if omitted)
+		* @returns Promise resolving to count of matching records
+		* @throws Error if the count operation fails
+		*/
+		const count = async (table, where) => {
+			validateTableName$1(table);
+			try {
+				if (!where || Object.keys(where).length === 0) {
+					const result = await executor.query(`SELECT COUNT(*) as count FROM ${table}`);
+					return Number(result.rows[0]?.count) || 0;
+				}
+				const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
+				const result = await executor.query(`SELECT COUNT(*) as count FROM ${table} ${whereClause}`, values);
+				return Number(result.rows[0]?.count) || 0;
+			} catch (e) {
+				throw new DatabaseError("Failed to count records in table", {
+					table,
+					where,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Creates a table-specific interface for simplified table operations
+		*
+		* @param tableName - Table name
+		* @returns TableMethods interface for the specified table
+		*/
+		const table = (tableName) => {
+			return {
+				insert: (data) => insert(tableName, data),
+				get: (data) => get(tableName, data),
+				list: (data) => list(tableName, data)
+			};
+		};
+		/**
+		* Executes a SQL query using template literals and returns a single value
+		*
+		* @param strings - Template strings
+		* @param vars - Variables to interpolate into the query
+		* @returns Promise resolving to a single value (first column of first row)
+		*/
+		const pluck = async (strings, ...vars) => {
+			const { sql, values } = parseTemplate(strings, ...vars);
+			try {
+				const firstRow = (await executor.query(sql, values)).rows[0];
+				if (!firstRow) return null;
+				return Object.values(firstRow)[0];
+			} catch (e) {
+				throw new DatabaseError("Failed to execute pluck query", {
+					sql,
+					values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Executes a SQL query using template literals and returns a single row
+		*
+		* @param strings - Template strings
+		* @param vars - Variables to interpolate into the query
+		* @returns Promise resolving to a single result record or null
+		*/
+		const single = async (strings, ...vars) => {
+			const { sql, values } = parseTemplate(strings, ...vars);
+			try {
+				return (await executor.query(sql, values)).rows[0] || null;
+			} catch (e) {
+				throw new DatabaseError("Failed to execute single query", {
+					sql,
+					values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Executes a SQL query using template literals and returns multiple rows
+		*
+		* @param strings - Template strings
+		* @param vars - Variables to interpolate into the query
+		* @returns Promise resolving to array of result records
+		*/
+		const many = async (strings, ...vars) => {
+			const { sql, values } = parseTemplate(strings, ...vars);
+			try {
+				return (await executor.query(sql, values)).rows;
+			} catch (e) {
+				throw new DatabaseError("Failed to execute many query", {
+					sql,
+					values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Executes a SQL query using template literals without returning results
+		*
+		* @param strings - Template strings
+		* @param vars - Variables to interpolate into the query
+		* @returns Promise that resolves when the query completes
+		*/
+		const execute = async (strings, ...vars) => {
+			const { sql, values } = parseTemplate(strings, ...vars);
+			try {
+				await executor.query(sql, values);
+			} catch (e) {
+				throw new DatabaseError("Failed to execute query", {
+					sql,
+					values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Executes a raw SQL query with parameterized values
+		*
+		* Uses PostgreSQL-native placeholders ($1, $2, ...). Legacy ? placeholders
+		* are converted only when the placeholder count matches the supplied values,
+		* so Postgres operators such as JSONB ? remain intact.
+		*
+		* @param sql - SQL query string
+		* @param values - Variables to use as parameters
+		* @returns Promise resolving to query result with rows and count
+		*/
+		const query = async (sql, ...values) => {
+			const query = normalizePostgresRawQuery(sql, values);
+			try {
+				const result = await executor.query(query.sql, query.values);
+				return {
+					rows: result.rows,
+					rowCount: result.rowCount ?? 0
+				};
+			} catch (e) {
+				throw new DatabaseError("Failed to execute raw query", {
+					sql: query.sql,
+					values: query.values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Checks if a table exists in the database
+		*
+		* @param tableName - Name of the table to check
+		* @returns Promise resolving to boolean indicating if the table exists
+		*/
+		const tableExists = async (tableName) => {
+			return (await executor.query(`SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = $1 AND table_schema = 'public')`, [tableName])).rows[0].exists;
+		};
+		/**
+		* Synchronizes database schema with provided SQL DDL
+		* Creates tables if they don't exist and adds missing columns
+		* Also executes CREATE INDEX statements
+		*
+		* @param schema - SQL schema definition with CREATE TABLE and CREATE INDEX statements
+		* @returns Promise that resolves when schema is synchronized
+		*/
+		/**
+		* Runs a step whose failure `syncSchema` deliberately tolerates.
+		*
+		* Logging and continuing is self-contained on the pool. Inside a
+		* transaction it is not: a failed statement puts PostgreSQL in the aborted
+		* state, and `COMMIT` on an aborted transaction *succeeds* — it reports a
+		* ROLLBACK command tag and no error. The caller is told the transaction
+		* committed while every write in it was discarded, which is the silent
+		* data loss this whole epic is about, re-entering through the schema path.
+		*
+		* A savepoint scopes the failure to the step, which is what "log it and
+		* continue" was always supposed to mean.
+		*/
+		const runTolerated = async (work) => {
+			if (!inTransaction) return work();
+			savepointSequence += 1;
+			const name = `hv_sync_${savepointSequence}`;
+			await executor.query(`SAVEPOINT ${name}`);
+			try {
+				const result = await work();
+				await executor.query(`RELEASE SAVEPOINT ${name}`);
+				return result;
+			} catch (error) {
+				await executor.query(`ROLLBACK TO SAVEPOINT ${name}`);
+				await executor.query(`RELEASE SAVEPOINT ${name}`);
+				throw error;
+			}
+		};
+		const syncSchema = async (schema) => {
+			const commands = schema.trim().split(";").filter((command) => command.trim() !== "");
+			const createIndexRegex = /CREATE (UNIQUE )?INDEX (IF NOT EXISTS )?"?(\w+)"? ON "?(\w+)"?\s*\(([^)]+)\)/i;
+			const indexNames = [];
+			for (const command of commands) {
+				const indexMatch = command.trim().match(createIndexRegex);
+				if (indexMatch) indexNames.push(indexMatch[3]);
+			}
+			const existingIndexes = /* @__PURE__ */ new Set();
+			if (indexNames.length > 0) {
+				const result = await executor.query(`SELECT indexname FROM pg_indexes
+           WHERE schemaname = 'public' AND indexname = ANY($1::text[])`, [indexNames]);
+				for (const row of result.rows) existingIndexes.add(row.indexname);
+			}
+			for (const command of commands) {
+				const trimmedCommand = command.trim();
+				const tableMatch = trimmedCommand.match(/CREATE TABLE (IF NOT EXISTS )?"?(\w+)"? \(([\s\S]+)\)/i);
+				if (tableMatch) {
+					const tableName = tableMatch[2];
+					const columns = tableMatch[3].trim().split(",\n");
+					if (!await tableExists(tableName)) await executor.query(trimmedCommand);
+					else for (const column of columns) {
+						const columnDef = column.trim();
+						const columnMatch = columnDef.match(/"?(\w+)"?\s+(\w+[^,]*)/);
+						if (columnMatch) {
+							const columnName = columnMatch[1];
+							if (columnName.toUpperCase() === "PRIMARY" || columnName.toUpperCase() === "FOREIGN" || columnName.toUpperCase() === "UNIQUE" || columnName.toUpperCase() === "CHECK" || columnName.toUpperCase() === "CONSTRAINT") continue;
+							try {
+								await runTolerated(async () => {
+									if (!(await executor.query(`SELECT EXISTS (
+                        SELECT 1 FROM information_schema.columns
+                        WHERE table_name = $1
+                        AND column_name = $2
+                        AND table_schema = 'public'
+                      )`, [tableName, columnName])).rows[0].exists) {
+										const alterCommand = `ALTER TABLE "${tableName}" ADD COLUMN ${columnDef}`;
+										await executor.query(alterCommand);
+									}
+								});
+							} catch (error) {
+								console.error(`Error adding column ${columnName} to ${tableName}:`, error);
+							}
+						}
+					}
+					continue;
+				}
+				const indexMatch = trimmedCommand.match(createIndexRegex);
+				if (indexMatch) {
+					const indexName = indexMatch[3];
+					const indexTableName = indexMatch[4];
+					if (!existingIndexes.has(indexName)) try {
+						await runTolerated(() => executor.query(trimmedCommand));
+						existingIndexes.add(indexName);
+					} catch (error) {
+						console.warn(`Warning: Failed to create index ${indexName} on ${indexTableName}:`, error instanceof Error ? error.message : String(error));
+					}
+					continue;
+				}
+				if (trimmedCommand.toUpperCase().startsWith("CREATE ") && !trimmedCommand.toUpperCase().includes("CREATE TABLE")) try {
+					await runTolerated(() => executor.query(trimmedCommand));
+				} catch (error) {
+					console.warn(`Warning: DDL statement may have failed:`, error instanceof Error ? error.message : String(error));
+				}
+			}
+		};
+		return {
+			insert,
+			get,
+			list,
+			update,
+			upsert,
+			getOrInsert,
+			delete: deleteRecords,
+			count,
+			table,
+			many,
+			single,
+			pluck,
+			execute,
+			query,
+			oo: many,
+			oO: single,
+			ox: pluck,
+			xx: execute,
+			tableExists,
+			syncSchema
+		};
+	};
+	const { insert, get, list, update, upsert, getOrInsert, delete: deleteRecords, count, table, many, single, pluck, execute, query, oo, oO, ox, xx, tableExists, syncSchema } = createClientMethods(client, false, serializeRecord);
+	/**
 	* Acquire a pinned connection from the pool for session-scoped state such as
 	* `pg_advisory_lock`. Every query on the returned handle runs on the same
 	* client until {@link SessionHandle.release} drops the connection (which
@@ -2586,86 +2902,6 @@ async function createDatabase(options, cacheKey) {
 			}
 		};
 	};
-	/**
-	* Checks if a table exists in the database
-	*
-	* @param tableName - Name of the table to check
-	* @returns Promise resolving to boolean indicating if the table exists
-	*/
-	const tableExists = async (tableName) => {
-		return (await client.query(`SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = $1 AND table_schema = 'public')`, [tableName])).rows[0].exists;
-	};
-	/**
-	* Synchronizes database schema with provided SQL DDL
-	* Creates tables if they don't exist and adds missing columns
-	* Also executes CREATE INDEX statements
-	*
-	* @param schema - SQL schema definition with CREATE TABLE and CREATE INDEX statements
-	* @returns Promise that resolves when schema is synchronized
-	*/
-	const syncSchema = async (schema) => {
-		const commands = schema.trim().split(";").filter((command) => command.trim() !== "");
-		const createIndexRegex = /CREATE (UNIQUE )?INDEX (IF NOT EXISTS )?"?(\w+)"? ON "?(\w+)"?\s*\(([^)]+)\)/i;
-		const indexNames = [];
-		for (const command of commands) {
-			const indexMatch = command.trim().match(createIndexRegex);
-			if (indexMatch) indexNames.push(indexMatch[3]);
-		}
-		const existingIndexes = /* @__PURE__ */ new Set();
-		if (indexNames.length > 0) {
-			const result = await client.query(`SELECT indexname FROM pg_indexes
-         WHERE schemaname = 'public' AND indexname = ANY($1::text[])`, [indexNames]);
-			for (const row of result.rows) existingIndexes.add(row.indexname);
-		}
-		for (const command of commands) {
-			const trimmedCommand = command.trim();
-			const tableMatch = trimmedCommand.match(/CREATE TABLE (IF NOT EXISTS )?"?(\w+)"? \(([\s\S]+)\)/i);
-			if (tableMatch) {
-				const tableName = tableMatch[2];
-				const columns = tableMatch[3].trim().split(",\n");
-				if (!await tableExists(tableName)) await client.query(trimmedCommand);
-				else for (const column of columns) {
-					const columnDef = column.trim();
-					const columnMatch = columnDef.match(/"?(\w+)"?\s+(\w+[^,]*)/);
-					if (columnMatch) {
-						const columnName = columnMatch[1];
-						if (columnName.toUpperCase() === "PRIMARY" || columnName.toUpperCase() === "FOREIGN" || columnName.toUpperCase() === "UNIQUE" || columnName.toUpperCase() === "CHECK" || columnName.toUpperCase() === "CONSTRAINT") continue;
-						try {
-							if (!(await client.query(`SELECT EXISTS (
-                    SELECT 1 FROM information_schema.columns
-                    WHERE table_name = $1
-                    AND column_name = $2
-                    AND table_schema = 'public'
-                  )`, [tableName, columnName])).rows[0].exists) {
-								const alterCommand = `ALTER TABLE "${tableName}" ADD COLUMN ${columnDef}`;
-								await client.query(alterCommand);
-							}
-						} catch (error) {
-							console.error(`Error adding column ${columnName} to ${tableName}:`, error);
-						}
-					}
-				}
-				continue;
-			}
-			const indexMatch = trimmedCommand.match(createIndexRegex);
-			if (indexMatch) {
-				const indexName = indexMatch[3];
-				const indexTableName = indexMatch[4];
-				if (!existingIndexes.has(indexName)) try {
-					await client.query(trimmedCommand);
-					existingIndexes.add(indexName);
-				} catch (error) {
-					console.warn(`Warning: Failed to create index ${indexName} on ${indexTableName}:`, error instanceof Error ? error.message : String(error));
-				}
-				continue;
-			}
-			if (trimmedCommand.toUpperCase().startsWith("CREATE ") && !trimmedCommand.toUpperCase().includes("CREATE TABLE")) try {
-				await client.query(trimmedCommand);
-			} catch (error) {
-				console.warn(`Warning: DDL statement may have failed:`, error instanceof Error ? error.message : String(error));
-			}
-		}
-	};
 	let savepointSequence = 0;
 	/**
 	* Builds the `transaction` exposed on a transaction-scoped interface.
@@ -2715,132 +2951,7 @@ async function createDatabase(options, cacheKey) {
 			const txDb = {
 				url,
 				client: txClient,
-				insert: async (table, data) => {
-					if (Array.isArray(data)) {
-						const keys = Object.keys(data[0]);
-						const placeholders = data.map((_, i) => `(${keys.map((_, j) => `$${i * keys.length + j + 1}`).join(", ")})`).join(", ");
-						const query = `INSERT INTO ${table} (${keys.join(", ")}) VALUES ${placeholders}`;
-						const values = data.reduce((acc, row) => acc.concat(Object.values(row)), []);
-						return {
-							operation: "insert",
-							affected: (await txClient.query(query, values)).rowCount ?? 0
-						};
-					}
-					const keys = Object.keys(data);
-					const values = Object.values(data);
-					const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
-					const query = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`;
-					return {
-						operation: "insert",
-						affected: (await txClient.query(query, values)).rowCount ?? 0
-					};
-				},
-				get: async (table, where) => {
-					const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-					if (!whereClause) throw new DatabaseError("GET requires at least one WHERE condition to prevent returning an arbitrary record", { table });
-					const query = `SELECT * FROM ${table} ${whereClause}`;
-					return (await txClient.query(query, values)).rows[0] || null;
-				},
-				list: async (table, where) => {
-					const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-					const query = `SELECT * FROM ${table} ${whereClause}`;
-					return (await txClient.query(query, values)).rows;
-				},
-				update: async (table, where, data) => {
-					const keys = Object.keys(data);
-					const values = Object.values(data);
-					const setClause = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
-					const { sql: whereClause, values: whereValues } = buildWhere(where, values.length + 1, "postgres");
-					if (!whereClause) throw new DatabaseError("UPDATE requires at least one WHERE condition to prevent accidental update of all records", { table });
-					const sql = `UPDATE ${table} SET ${setClause} ${whereClause}`;
-					return {
-						operation: "update",
-						affected: (await txClient.query(sql, [...values, ...whereValues])).rowCount ?? 0
-					};
-				},
-				upsert: async (table, conflictColumns, data, options) => executePostgresUpsert(txClient, table, conflictColumns, data, options, false),
-				getOrInsert: async (table, where, data) => {
-					const result = await txDb.get(table, where);
-					if (result) return result;
-					await txDb.insert(table, data);
-					const inserted = await txDb.get(table, where);
-					if (!inserted) throw new DatabaseError("Failed to insert and retrieve record", {
-						table,
-						where,
-						data
-					});
-					return inserted;
-				},
-				delete: async (table, where) => {
-					validateTableName$1(table);
-					if (Object.keys(where).length === 0) throw new DatabaseError("DELETE requires at least one WHERE condition to prevent accidental deletion of all records", { table });
-					const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-					return {
-						operation: "delete",
-						affected: (await txClient.query(`DELETE FROM ${table} ${whereClause}`, values)).rowCount ?? 0
-					};
-				},
-				count: async (table, where) => {
-					validateTableName$1(table);
-					if (!where || Object.keys(where).length === 0) {
-						const result = await txClient.query(`SELECT COUNT(*) as count FROM ${table}`);
-						return Number(result.rows[0]?.count) || 0;
-					}
-					const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-					const result = await txClient.query(`SELECT COUNT(*) as count FROM ${table} ${whereClause}`, values);
-					return Number(result.rows[0]?.count) || 0;
-				},
-				table: (tableName) => ({
-					insert: (data) => txDb.insert(tableName, data),
-					get: (data) => txDb.get(tableName, data),
-					list: (data) => txDb.list(tableName, data)
-				}),
-				many: async (strings, ...vars) => {
-					const { sql, values } = parseTemplate(strings, ...vars);
-					return (await txClient.query(sql, values)).rows;
-				},
-				single: async (strings, ...vars) => {
-					const { sql, values } = parseTemplate(strings, ...vars);
-					return (await txClient.query(sql, values)).rows[0] || null;
-				},
-				pluck: async (strings, ...vars) => {
-					const { sql, values } = parseTemplate(strings, ...vars);
-					const firstRow = (await txClient.query(sql, values)).rows[0];
-					if (!firstRow) return null;
-					return Object.values(firstRow)[0];
-				},
-				execute: async (strings, ...vars) => {
-					const { sql, values } = parseTemplate(strings, ...vars);
-					await txClient.query(sql, values);
-				},
-				query: async (sql, ...values) => {
-					const query = normalizePostgresRawQuery(sql, values);
-					const result = await txClient.query(query.sql, query.values);
-					return {
-						rows: result.rows,
-						rowCount: result.rowCount ?? 0
-					};
-				},
-				oo: async (strings, ...vars) => {
-					const { sql, values } = parseTemplate(strings, ...vars);
-					return (await txClient.query(sql, values)).rows;
-				},
-				oO: async (strings, ...vars) => {
-					const { sql, values } = parseTemplate(strings, ...vars);
-					return (await txClient.query(sql, values)).rows[0] || null;
-				},
-				ox: async (strings, ...vars) => {
-					const { sql, values } = parseTemplate(strings, ...vars);
-					const firstRow = (await txClient.query(sql, values)).rows[0];
-					if (!firstRow) return null;
-					return Object.values(firstRow)[0];
-				},
-				xx: async (strings, ...vars) => {
-					const { sql, values } = parseTemplate(strings, ...vars);
-					await txClient.query(sql, values);
-				},
-				tableExists,
-				syncSchema,
+				...createClientMethods(txClient, true, passThroughRecord),
 				transaction: createNestedTransaction(txClient, () => txDb)
 			};
 			const result = await callback(txDb);
@@ -2889,132 +3000,7 @@ async function createDatabase(options, cacheKey) {
 		const txHandle = {
 			url,
 			client: txClient,
-			insert: async (table, data) => {
-				if (Array.isArray(data)) {
-					const keys = Object.keys(data[0]);
-					const placeholders = data.map((_, i) => `(${keys.map((_, j) => `$${i * keys.length + j + 1}`).join(", ")})`).join(", ");
-					const query = `INSERT INTO ${table} (${keys.join(", ")}) VALUES ${placeholders}`;
-					const values = data.reduce((acc, row) => acc.concat(Object.values(row)), []);
-					return {
-						operation: "insert",
-						affected: (await txClient.query(query, values)).rowCount ?? 0
-					};
-				}
-				const keys = Object.keys(data);
-				const values = Object.values(data);
-				const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
-				const query = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`;
-				return {
-					operation: "insert",
-					affected: (await txClient.query(query, values)).rowCount ?? 0
-				};
-			},
-			get: async (table, where) => {
-				const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-				if (!whereClause) throw new DatabaseError("GET requires at least one WHERE condition to prevent returning an arbitrary record", { table });
-				const query = `SELECT * FROM ${table} ${whereClause}`;
-				return (await txClient.query(query, values)).rows[0] || null;
-			},
-			list: async (table, where) => {
-				const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-				const query = `SELECT * FROM ${table} ${whereClause}`;
-				return (await txClient.query(query, values)).rows;
-			},
-			update: async (table, where, data) => {
-				const keys = Object.keys(data);
-				const values = Object.values(data);
-				const setClause = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
-				const { sql: whereClause, values: whereValues } = buildWhere(where, values.length + 1, "postgres");
-				if (!whereClause) throw new DatabaseError("UPDATE requires at least one WHERE condition to prevent accidental update of all records", { table });
-				const sql = `UPDATE ${table} SET ${setClause} ${whereClause}`;
-				return {
-					operation: "update",
-					affected: (await txClient.query(sql, [...values, ...whereValues])).rowCount ?? 0
-				};
-			},
-			upsert: async (table, conflictColumns, data, options) => executePostgresUpsert(txClient, table, conflictColumns, data, options, false),
-			getOrInsert: async (table, where, data) => {
-				const result = await txHandle.get(table, where);
-				if (result) return result;
-				await txHandle.insert(table, data);
-				const inserted = await txHandle.get(table, where);
-				if (!inserted) throw new DatabaseError("Failed to insert and retrieve record", {
-					table,
-					where,
-					data
-				});
-				return inserted;
-			},
-			delete: async (table, where) => {
-				validateTableName$1(table);
-				if (Object.keys(where).length === 0) throw new DatabaseError("DELETE requires at least one WHERE condition to prevent accidental deletion of all records", { table });
-				const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-				return {
-					operation: "delete",
-					affected: (await txClient.query(`DELETE FROM ${table} ${whereClause}`, values)).rowCount ?? 0
-				};
-			},
-			count: async (table, where) => {
-				validateTableName$1(table);
-				if (!where || Object.keys(where).length === 0) {
-					const result = await txClient.query(`SELECT COUNT(*) as count FROM ${table}`);
-					return Number(result.rows[0]?.count) || 0;
-				}
-				const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-				const result = await txClient.query(`SELECT COUNT(*) as count FROM ${table} ${whereClause}`, values);
-				return Number(result.rows[0]?.count) || 0;
-			},
-			table: (tableName) => ({
-				insert: (data) => txHandle.insert(tableName, data),
-				get: (data) => txHandle.get(tableName, data),
-				list: (data) => txHandle.list(tableName, data)
-			}),
-			many: async (strings, ...vars) => {
-				const { sql, values } = parseTemplate(strings, ...vars);
-				return (await txClient.query(sql, values)).rows;
-			},
-			single: async (strings, ...vars) => {
-				const { sql, values } = parseTemplate(strings, ...vars);
-				return (await txClient.query(sql, values)).rows[0] || null;
-			},
-			pluck: async (strings, ...vars) => {
-				const { sql, values } = parseTemplate(strings, ...vars);
-				const firstRow = (await txClient.query(sql, values)).rows[0];
-				if (!firstRow) return null;
-				return Object.values(firstRow)[0];
-			},
-			execute: async (strings, ...vars) => {
-				const { sql, values } = parseTemplate(strings, ...vars);
-				await txClient.query(sql, values);
-			},
-			query: async (sql, ...values) => {
-				const query = normalizePostgresRawQuery(sql, values);
-				const result = await txClient.query(query.sql, query.values);
-				return {
-					rows: result.rows,
-					rowCount: result.rowCount ?? 0
-				};
-			},
-			oo: async (strings, ...vars) => {
-				const { sql, values } = parseTemplate(strings, ...vars);
-				return (await txClient.query(sql, values)).rows;
-			},
-			oO: async (strings, ...vars) => {
-				const { sql, values } = parseTemplate(strings, ...vars);
-				return (await txClient.query(sql, values)).rows[0] || null;
-			},
-			ox: async (strings, ...vars) => {
-				const { sql, values } = parseTemplate(strings, ...vars);
-				const firstRow = (await txClient.query(sql, values)).rows[0];
-				if (!firstRow) return null;
-				return Object.values(firstRow)[0];
-			},
-			xx: async (strings, ...vars) => {
-				const { sql, values } = parseTemplate(strings, ...vars);
-				await txClient.query(sql, values);
-			},
-			tableExists,
-			syncSchema,
+			...createClientMethods(txClient, true, passThroughRecord),
 			transaction: createNestedTransaction(txClient, () => txHandle),
 			commit,
 			rollback,
@@ -3022,10 +3008,6 @@ async function createDatabase(options, cacheKey) {
 		};
 		return txHandle;
 	};
-	const oo = many;
-	const oO = single;
-	const ox = pluck;
-	const xx = execute;
 	/**
 	* Initialize database schemas from JSON manifest
 	* Supports dependency resolution and schema overrides
@@ -3311,8 +3293,8 @@ async function getDatabase(options = {}) {
 	}));
 	if (!options.type && (options.url?.startsWith("file:") || options.url === ":memory:")) options.type = "sqlite";
 	if (options.type === "postgres") return (await Promise.resolve().then(() => postgres_exports)).getDatabase(options);
-	if (options.type === "sqlite") return (await import("./chunks/sqlite-B4ussRTS.js")).getDatabase(options);
-	if (options.type === "duckdb") return (await import("./chunks/duckdb-D_Wu36JL.js")).getDatabase(options);
+	if (options.type === "sqlite") return (await import("./chunks/sqlite-kBmA-x_C.js")).getDatabase(options);
+	if (options.type === "duckdb") return (await import("./chunks/duckdb-CWy7Nziq.js")).getDatabase(options);
 	if (options.type === "json") return (await Promise.resolve().then(() => json_exports)).getDatabase(options);
 	throw new Error("Invalid database type");
 }