@nextlyhq/adapter-drizzle 0.0.2-alpha.68 → 0.0.2-alpha.69

package/dist/index.cjs

@@ -1,1755 +1,1863 @@
-'use strict';
-
-var async_hooks = require('async_hooks');
-var drizzleOrm = require('drizzle-orm');
-
-// src/adapter.ts
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_text_match = require("./text-match.cjs");
+const require_types = require("./types-CNyA1oIm.cjs");
+let node_async_hooks = require("node:async_hooks");
+let drizzle_orm = require("drizzle-orm");
 // src/column-kinds.ts
+/**
+* Whether a column stores JSON, in the spelling each dialect's column class
+* reports. Drizzle serializes objects for these itself, so a value that
+* arrives already serialized has to be parsed first or it is serialized
+* twice.
+*
+* SQLite matches only text columns declared with `{ mode: "json" }`
+* (`SQLiteTextJson`, dataType `json`). A plain `SQLiteText` column stores a
+* serialized string as it is and must not be parsed, or better-sqlite3 is
+* handed an object it cannot bind.
+*/
 function isJsonColumn(column) {
-  return column.dataType === "json" || column.columnType === "PgJsonb" || column.columnType === "PgJson" || column.columnType === "MySqlJson" || column.columnType === "SQLiteTextJson";
+	return column.dataType === "json" || column.columnType === "PgJsonb" || column.columnType === "PgJson" || column.columnType === "MySqlJson" || column.columnType === "SQLiteTextJson";
 }
+/**
+* Whether a value is a structured document — a plain object or an array —
+* rather than a scalar, a date, or binary. What a driver does with one of
+* these when the column is not modelled differs (node-postgres spells an
+* array as a PostgreSQL array literal, mysql2 as a value list), and none of
+* it is JSON; serializing here is what makes the same bytes land everywhere.
+*/
 function isStructuredValue(value) {
-  if (value === null || typeof value !== "object") return false;
-  if (value instanceof Date) return false;
-  if (Buffer.isBuffer(value) || ArrayBuffer.isView(value)) return false;
-  return true;
+	if (value === null || typeof value !== "object") return false;
+	if (value instanceof Date) return false;
+	if (Buffer.isBuffer(value) || ArrayBuffer.isView(value)) return false;
+	return true;
 }
+/**
+* How a value binds to a column the runtime model does not declare, on a
+* driver that binds scalars, dates and binary natively: structured values are
+* serialized as JSON text, everything else passes through.
+*/
 function bindStructuredAsJson(value) {
-  return isStructuredValue(value) ? JSON.stringify(value) : value;
+	return isStructuredValue(value) ? JSON.stringify(value) : value;
 }
+// src/drizzle-order.ts
+/**
+* Turn order specifications into drizzle order clauses.
+*
+* Extracted from `DrizzleAdapter.select` so the rendered SQL can be asserted
+* directly. That matters more than it looks: `OrderBySpec.nulls` was declared,
+* documented as "can be explicitly controlled", and read NOWHERE — every caller
+* that set it silently got the dialect default instead, and no test could have
+* caught that while the mapping lived inline in a method that needs a database.
+*
+* ## Why null placement is a leading sort key, not `NULLS FIRST/LAST`
+*
+* That clause is not portable: PostgreSQL and SQLite accept it, MySQL does not.
+* `col IS NULL` is a boolean expression all three evaluate, and sorting on it
+* ascending puts non-null rows first — which is `NULLS LAST` by another name,
+* spelled in something every supported engine understands.
+*
+* The defaults genuinely disagree, which is why the control exists at all:
+* PostgreSQL treats NULL as largest and puts it FIRST on a descending order,
+* while MySQL and SQLite treat it as smallest and put it last. A "newest
+* scheduled first" list containing undated drafts therefore returns different
+* rows per engine, and under a limit it can return only drafts.
+*/
 function buildDrizzleOrderBy(columns, orderBy) {
-  if (!orderBy?.length) return [];
-  return orderBy.flatMap((spec) => {
-    const col = columns[spec.column];
-    if (!col) return [];
-    const direction = spec.direction === "desc" ? drizzleOrm.desc(col) : drizzleOrm.asc(col);
-    if (spec.nulls === void 0) return [direction];
-    const isNull2 = drizzleOrm.sql`${col} is null`;
-    return [spec.nulls === "last" ? drizzleOrm.asc(isNull2) : drizzleOrm.desc(isNull2), direction];
-  });
-}
-function containsPattern(value) {
-  return `%${value.replace(/[!%_]/g, (character) => `!${character}`)}%`;
+	if (!orderBy?.length) return [];
+	return orderBy.flatMap((spec) => {
+		const col = columns[spec.column];
+		if (!col) return [];
+		const direction = spec.direction === "desc" ? (0, drizzle_orm.desc)(col) : (0, drizzle_orm.asc)(col);
+		if (spec.nulls === void 0) return [direction];
+		const isNull = drizzle_orm.sql`${col} is null`;
+		return [spec.nulls === "last" ? (0, drizzle_orm.asc)(isNull) : (0, drizzle_orm.desc)(isNull), direction];
+	});
 }
-function caseInsensitiveContains(column, value) {
-  return drizzleOrm.sql`lower(${column}) like lower(${containsPattern(value)}) escape '!'`;
-}
-
 // src/drizzle-where.ts
 function buildDrizzleWhere(table, where) {
-  const columns = drizzleOrm.getColumns(table);
-  return processWhereClause(columns, where);
+	return processWhereClause((0, drizzle_orm.getColumns)(table), where);
 }
 function processWhereClause(columns, where) {
-  const parts = [];
-  if (where.and?.length) {
-    const andParts = where.and.map((item) => {
-      if (isWhereCondition(item)) {
-        return buildCondition(columns, item);
-      }
-      return processWhereClause(columns, item);
-    }).filter((p) => p !== void 0);
-    if (andParts.length) {
-      parts.push(drizzleOrm.and(...andParts));
-    }
-  }
-  if (where.or?.length) {
-    const orParts = where.or.map((item) => {
-      if (isWhereCondition(item)) {
-        return buildCondition(columns, item);
-      }
-      return processWhereClause(columns, item);
-    }).filter((p) => p !== void 0);
-    if (orParts.length) {
-      parts.push(drizzleOrm.or(...orParts));
-    }
-  }
-  if (where.not) {
-    const notItem = where.not;
-    const notCondition = isWhereCondition(notItem) ? buildCondition(columns, notItem) : processWhereClause(columns, notItem);
-    if (notCondition) {
-      parts.push(drizzleOrm.not(notCondition));
-    }
-  }
-  if (parts.length === 0) {
-    if (namesABranch(where)) {
-      throw new Error(
-        `Where clause produced no condition: ${JSON.stringify(where)}. Every branch resolved to nothing, which would match every row. Pass {} to mean "no filter".`
-      );
-    }
-    return void 0;
-  }
-  if (parts.length === 1) return parts[0];
-  return drizzleOrm.and(...parts);
+	const parts = [];
+	if (where.and?.length) {
+		const andParts = where.and.map((item) => {
+			if (isWhereCondition(item)) return buildCondition(columns, item);
+			return processWhereClause(columns, item);
+		}).filter((p) => p !== void 0);
+		if (andParts.length) parts.push((0, drizzle_orm.and)(...andParts));
+	}
+	if (where.or?.length) {
+		const orParts = where.or.map((item) => {
+			if (isWhereCondition(item)) return buildCondition(columns, item);
+			return processWhereClause(columns, item);
+		}).filter((p) => p !== void 0);
+		if (orParts.length) parts.push((0, drizzle_orm.or)(...orParts));
+	}
+	if (where.not) {
+		const notItem = where.not;
+		const notCondition = isWhereCondition(notItem) ? buildCondition(columns, notItem) : processWhereClause(columns, notItem);
+		if (notCondition) parts.push((0, drizzle_orm.not)(notCondition));
+	}
+	if (parts.length === 0) {
+		if (namesABranch(where)) throw new Error(`Where clause produced no condition: ${JSON.stringify(where)}. Every branch resolved to nothing, which would match every row. Pass {} to mean "no filter".`);
+		return;
+	}
+	if (parts.length === 1) return parts[0];
+	return (0, drizzle_orm.and)(...parts);
 }
 function isWhereCondition(item) {
-  return "column" in item && "op" in item;
+	return "column" in item && "op" in item;
 }
+/**
+* Whether the clause asked for a constraint at all — as opposed to being the empty clause a
+* caller passes to mean "no filter".
+*
+* An empty `and`/`or` array does NOT count: nothing was named, so nothing could be dropped.
+* What counts is a branch with members in it, or a `not`, because those are the shapes that can
+* resolve to nothing and leave the caller believing a filter was applied.
+*/
 function namesABranch(where) {
-  return Boolean(where.and?.length || where.or?.length || where.not);
+	return Boolean(where.and?.length || where.or?.length || where.not);
 }
 function buildCondition(columns, cond) {
-  const column = columns[cond.column];
-  if (!column) {
-    throw new Error(
-      `Column "${cond.column}" not found in table. Available: ${Object.keys(columns).join(", ")}`
-    );
-  }
-  const col = column;
-  switch (cond.op) {
-    case "=":
-      return drizzleOrm.eq(col, cond.value);
-    case "!=":
-      return drizzleOrm.ne(col, cond.value);
-    case ">":
-      return drizzleOrm.gt(col, cond.value);
-    case "<":
-      return drizzleOrm.lt(col, cond.value);
-    case ">=":
-      return drizzleOrm.gte(col, cond.value);
-    case "<=":
-      return drizzleOrm.lte(col, cond.value);
-    case "LIKE":
-      return drizzleOrm.like(col, cond.value);
-    case "ILIKE":
-      return drizzleOrm.sql`lower(${col}) like lower(${cond.value})`;
-    case "IN":
-      return drizzleOrm.inArray(col, cond.value);
-    case "NOT IN":
-      return drizzleOrm.notInArray(col, cond.value);
-    case "IS NULL":
-      return drizzleOrm.isNull(col);
-    case "IS NOT NULL":
-      return drizzleOrm.isNotNull(col);
-    case "BETWEEN":
-      return drizzleOrm.between(col, cond.value, cond.valueTo);
-    case "NOT BETWEEN":
-      return drizzleOrm.notBetween(col, cond.value, cond.valueTo);
-    case "CONTAINS":
-      return drizzleOrm.sql`${col} like ${containsPattern(String(cond.value))} escape '!'`;
-    case "ICONTAINS":
-      return caseInsensitiveContains(col, String(cond.value));
-    default:
-      throw new Error(`Unsupported operator: ${cond.op}`);
-  }
+	const column = columns[cond.column];
+	if (!column) throw new Error(`Column "${cond.column}" not found in table. Available: ${Object.keys(columns).join(", ")}`);
+	const col = column;
+	switch (cond.op) {
+		case "=": return (0, drizzle_orm.eq)(col, cond.value);
+		case "!=": return (0, drizzle_orm.ne)(col, cond.value);
+		case ">": return (0, drizzle_orm.gt)(col, cond.value);
+		case "<": return (0, drizzle_orm.lt)(col, cond.value);
+		case ">=": return (0, drizzle_orm.gte)(col, cond.value);
+		case "<=": return (0, drizzle_orm.lte)(col, cond.value);
+		case "LIKE": return (0, drizzle_orm.like)(col, cond.value);
+		case "ILIKE": return drizzle_orm.sql`lower(${col}) like lower(${cond.value})`;
+		case "IN": return (0, drizzle_orm.inArray)(col, cond.value);
+		case "NOT IN": return (0, drizzle_orm.notInArray)(col, cond.value);
+		case "IS NULL": return (0, drizzle_orm.isNull)(col);
+		case "IS NOT NULL": return (0, drizzle_orm.isNotNull)(col);
+		case "BETWEEN": return (0, drizzle_orm.between)(col, cond.value, cond.valueTo);
+		case "NOT BETWEEN": return (0, drizzle_orm.notBetween)(col, cond.value, cond.valueTo);
+		case "CONTAINS": return drizzle_orm.sql`${col} like ${require_text_match.containsPattern(String(cond.value))} escape '!'`;
+		case "ICONTAINS": return require_text_match.caseInsensitiveContains(col, String(cond.value));
+		default: throw new Error(`Unsupported operator: ${cond.op}`);
+	}
 }
-
 // src/pinned-transaction.ts
+/**
+* Replaces `db`'s `transaction` with one that runs each transaction on a
+* connection from `checkout`.
+*
+* Drizzle, bound to that single connection, runs BEGIN, the work and COMMIT
+* or ROLLBACK as it always does. When the transaction fails, a second
+* ROLLBACK goes to the connection: a no-op when Drizzle's own reached it,
+* and the confirmation that the connection is out of the transaction when
+* Drizzle's did not. If that ROLLBACK fails too, nothing can confirm it, and
+* the connection is closed rather than pooled. The work's own error is what
+* the caller receives, never a ROLLBACK's.
+*
+* @param db - A Drizzle handle on the adapter's pool
+* @param checkout - Checks out a connection for one transaction
+* @returns The same handle, its `transaction` replaced
+*/
 function pinTransactions(db, checkout) {
-  const pinned = async (work, config) => {
-    const connection = await checkout();
-    let dirty = false;
-    let workFailure;
-    try {
-      return await connection.drizzle.transaction(async (tx) => {
-        try {
-          return await work(tx);
-        } catch (error) {
-          workFailure = { error };
-          throw error;
-        }
-      }, config);
-    } catch (error) {
-      await connection.rollback().catch(() => {
-        dirty = true;
-      });
-      throw workFailure ? workFailure.error : error;
-    } finally {
-      connection.release(dirty);
-    }
-  };
-  Object.defineProperty(db, "transaction", {
-    value: pinned,
-    configurable: true,
-    writable: true
-  });
-  return db;
+	const pinned = async (work, config) => {
+		const connection = await checkout();
+		let dirty = false;
+		let workFailure;
+		try {
+			return await connection.drizzle.transaction(async (tx) => {
+				try {
+					return await work(tx);
+				} catch (error) {
+					workFailure = { error };
+					throw error;
+				}
+			}, config);
+		} catch (error) {
+			await connection.rollback().catch(() => {
+				dirty = true;
+			});
+			throw workFailure ? workFailure.error : error;
+		} finally {
+			connection.release(dirty);
+		}
+	};
+	Object.defineProperty(db, "transaction", {
+		value: pinned,
+		configurable: true,
+		writable: true
+	});
+	return db;
 }
-
 // src/transaction-forwarders.ts
+/**
+* Create CRUD and Drizzle instance forwarding methods for a TransactionContext.
+*
+* @remarks
+* TransactionContext delegates its CRUD methods to the adapter's Drizzle CRUD
+* implementation while binding the transaction executor so queries run inside
+* the transaction rather than on the connection pool.
+*
+* @param delegator - Object providing the underlying adapter CRUD methods
+* @param txDb - Thunk returning the transaction-bound Drizzle instance
+* @returns Object with forwarded TransactionContext methods
+*/
 function createTransactionForwarders(delegator, txDb) {
-  return {
-    select: async (table, options) => {
-      return delegator.select(table, options, txDb());
-    },
-    selectOne: async (table, options) => {
-      return delegator.selectOne(table, options, txDb());
-    },
-    updateCount: async (table, data, where) => {
-      return delegator.updateCount(table, data, where, txDb());
-    },
-    delete: async (table, where, options) => {
-      return delegator.delete(table, where, options, txDb());
-    },
-    upsert: async (table, data, options) => {
-      return delegator.upsert(table, data, options, txDb());
-    },
-    getDrizzle: () => txDb()
-  };
+	return {
+		select: async (table, options) => {
+			return delegator.select(table, options, txDb());
+		},
+		selectOne: async (table, options) => {
+			return delegator.selectOne(table, options, txDb());
+		},
+		updateCount: async (table, data, where) => {
+			return delegator.updateCount(table, data, where, txDb());
+		},
+		delete: async (table, where, options) => {
+			return delegator.delete(table, where, options, txDb());
+		},
+		upsert: async (table, data, options) => {
+			return delegator.upsert(table, data, options, txDb());
+		},
+		getDrizzle: () => txDb()
+	};
 }
+/**
+* The Drizzle handles one transaction hands out, built once each.
+*
+* `bare` is the instance the delegated CRUD and `getDrizzle()` run on. `withRelations(relations)` is `drizzleWithRelations`: an instance
+* on the SAME connection whose `query` namespace is populated, so relational
+* reads stay inside the transaction. Both are built lazily — a transaction
+* using only raw execute never constructs one — and the relational ones are
+* memoized per relations object, exactly as `getDrizzle()` memoizes its
+* pooled ones.
+*
+* Shared because the three adapters differ only in how they build an
+* instance on their connection, which is what `build` supplies.
+*/
 function transactionDrizzleHandles(build) {
-  let bareInstance;
-  const bare = () => bareInstance ??= build();
-  const relational = /* @__PURE__ */ new WeakMap();
-  const withRelations = (relations) => {
-    let cached = relational.get(relations);
-    if (cached === void 0) {
-      cached = build(relations);
-      relational.set(relations, cached);
-    }
-    return cached;
-  };
-  return { bare, withRelations };
-}
-
-// src/types/error.ts
-function isDatabaseError(error) {
-  return typeof error === "object" && error !== null && "kind" in error && typeof error.kind === "string";
-}
-function createDatabaseError(options) {
-  const error = new Error(options.message);
-  error.name = "DatabaseError";
-  error.kind = options.kind;
-  if (options.code !== void 0) error.code = options.code;
-  if (options.constraint !== void 0) error.constraint = options.constraint;
-  if (options.table !== void 0) error.table = options.table;
-  if (options.column !== void 0) error.column = options.column;
-  if (options.detail !== void 0) error.detail = options.detail;
-  if (options.hint !== void 0) error.hint = options.hint;
-  if (options.cause !== void 0) error.cause = options.cause;
-  return error;
+	let bareInstance;
+	const bare = () => bareInstance ??= build();
+	const relational = /* @__PURE__ */ new WeakMap();
+	const withRelations = (relations) => {
+		let cached = relational.get(relations);
+		if (cached === void 0) {
+			cached = build(relations);
+			relational.set(relations, cached);
+		}
+		return cached;
+	};
+	return {
+		bare,
+		withRelations
+	};
 }
+// src/update-statement.ts
+/**
+* The transactional UPDATE, assembled by the adapter rather than by the
+* Drizzle query builder.
+*
+* `db.update(table).set(row)` builds its SET clause by walking the table's
+* DECLARED columns and probing `row` for each — never the other way round —
+* so a key naming a column the runtime model does not declare is dropped
+* without a word. One place relies on writing exactly such a column: the
+* localization transition window. `localized` has been flipped on a
+* collection, the runtime model has moved its translatable columns to a
+* companion table that does not exist yet, and the physical main table still
+* holds them. The default locale keeps writing there until the companion
+* appears, and the transactional INSERT already reaches it because every
+* adapter builds that statement itself. This is the UPDATE half of the same
+* rule, shared by the three adapters so the statement is spelled once.
+*
+* Built on Drizzle's `sql` template rather than a string, so each dialect
+* quotes identifiers and numbers placeholders its own way, and the WHERE is
+* the `buildDrizzleWhere` every other read and write goes through — the raw
+* where builders were removed on purpose and this does not bring one back.
+* It returns at most the rows' identity: a caller who asked for the rows back
+* gets them from a read on the same transaction, decoded the way every read
+* is decoded, rather than from a RETURNING list this module would have to
+* decode a second way — and on a dialect with RETURNING that read is by the
+* identities this statement reports, so it is exactly the rows it changed.
+*
+* A value binds in one of three ways, decided per column:
+*  - a column the model DECLARES binds through that column's own encoder.
+*    `sql.param(value, column)` is the `Param` the query builder would have
+*    made for it, so a date, a JSON document or a boolean reaches the driver
+*    as the bytes the builder sent before this existed — for every caller
+*    that was already using the builder;
+*  - a column it does NOT declare binds through the adapter's own sanitizer,
+*    which is how that adapter's transactional INSERT binds every value;
+*  - a value that is itself a `Column` or an `SQL` fragment is an expression
+*    (`{ destination: table.source }` copies a column) and is written as one,
+*    which is what the query builder's `mapUpdateSet` does with it.
+*
+* A declared column with an `$onUpdate` callback that the caller did not name
+* is assigned the callback's value, as the query builder assigns it on every
+* update it builds.
+*
+* A key whose value is `undefined` is not written at all — JSON's meaning of
+* an absent key, and what the builder's `mapUpdateSet` did with it; under
+* both spellings of one column the later key decides, undefined included.
+* `null` is written as NULL. A key naming no column on the physical table is
+* a SQL error from the database: the query builder was the one path that
+* could not say so, which is the defect the transition window was hiding
+* behind. A patch that names nothing is refused before any `$onUpdate`
+* column is considered, as the query builder refused it.
+*
+* @module update-statement
+*/
 function isBindableColumn(value) {
-  return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.mapToDriverValue === "function";
+	return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.mapToDriverValue === "function";
 }
+/**
+* A JSON column's encoder serializes whatever it is given, so a value that
+* arrives already serialized would be serialized twice. The query-builder path
+* parses such a string first; this keeps the same bytes on the wire.
+*/
 function valueForJsonColumn(value) {
-  if (typeof value !== "string") return value;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
-  }
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
 }
+/**
+* A table's columns, indexed by both spellings a caller may use, and the
+* declared columns in order for the `$onUpdate` sweep.
+*/
 function columnsOf(tableObj) {
-  const byName = /* @__PURE__ */ new Map();
-  const declared = [];
-  for (const [jsName, column] of Object.entries(
-    drizzleOrm.getColumns(tableObj)
-  )) {
-    if (!isBindableColumn(column)) continue;
-    byName.set(column.name, column);
-    byName.set(jsName, column);
-    declared.push(column);
-  }
-  return { byName, declared };
+	const byName = /* @__PURE__ */ new Map();
+	const declared = [];
+	for (const [jsName, column] of Object.entries((0, drizzle_orm.getColumns)(tableObj))) {
+		if (!isBindableColumn(column)) continue;
+		byName.set(column.name, column);
+		byName.set(jsName, column);
+		declared.push(column);
+	}
+	return {
+		byName,
+		declared
+	};
 }
+/** How one value is written: as the expression it already is, or bound. */
 function boundValue(value, column, bindUnmodeled) {
-  if (drizzleOrm.is(value, drizzleOrm.SQL) || drizzleOrm.is(value, drizzleOrm.Column)) return drizzleOrm.sql`${value}`;
-  if (column) {
-    return drizzleOrm.sql`${drizzleOrm.sql.param(
-      isJsonColumn(column) ? valueForJsonColumn(value) : value,
-      column
-    )}`;
-  }
-  return drizzleOrm.sql`${drizzleOrm.sql.param(bindUnmodeled(value))}`;
+	if ((0, drizzle_orm.is)(value, drizzle_orm.SQL) || (0, drizzle_orm.is)(value, drizzle_orm.Column)) return drizzle_orm.sql`${value}`;
+	if (column) return drizzle_orm.sql`${drizzle_orm.sql.param(isJsonColumn(column) ? valueForJsonColumn(value) : value, column)}`;
+	return drizzle_orm.sql`${drizzle_orm.sql.param(bindUnmodeled(value))}`;
 }
+/**
+* Build the UPDATE for one table.
+*
+* @returns the statement, or `null` when there is nothing to write — every
+*   key was `undefined`, or there were none. An UPDATE with an empty SET is a
+*   syntax error, so the adapter refuses it by name instead of running it.
+*/
 function buildUpdateStatement(input) {
-  const { byName, declared } = columnsOf(input.tableObj);
-  const assignments = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(input.data)) {
-    const column = byName.get(key);
-    const name = column?.name ?? key;
-    if (value === void 0) {
-      assignments.delete(name);
-      continue;
-    }
-    assignments.set(
-      name,
-      drizzleOrm.sql`${drizzleOrm.sql.identifier(name)} = ${boundValue(value, column, input.bindUnmodeled)}`
-    );
-  }
-  if (assignments.size === 0) return null;
-  for (const column of declared) {
-    if (assignments.has(column.name) || column.onUpdateFn === void 0) {
-      continue;
-    }
-    const value = column.onUpdateFn();
-    assignments.set(
-      column.name,
-      drizzleOrm.sql`${drizzleOrm.sql.identifier(column.name)} = ${boundValue(value, column, input.bindUnmodeled)}`
-    );
-  }
-  const statement = drizzleOrm.sql`UPDATE ${input.tableObj} SET ${drizzleOrm.sql.join([...assignments.values()], drizzleOrm.sql`, `)}`;
-  const condition = buildDrizzleWhere(input.tableObj, input.where);
-  if (condition) statement.append(drizzleOrm.sql` WHERE ${condition}`);
-  if (input.returning && input.returning.length > 0) {
-    statement.append(drizzleOrm.sql` RETURNING ${drizzleOrm.sql.join(input.returning, drizzleOrm.sql`, `)}`);
-  }
-  return statement;
+	const { byName, declared } = columnsOf(input.tableObj);
+	const assignments = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(input.data)) {
+		const column = byName.get(key);
+		const name = column?.name ?? key;
+		if (value === void 0) {
+			assignments.delete(name);
+			continue;
+		}
+		assignments.set(name, drizzle_orm.sql`${drizzle_orm.sql.identifier(name)} = ${boundValue(value, column, input.bindUnmodeled)}`);
+	}
+	if (assignments.size === 0) return null;
+	for (const column of declared) {
+		if (assignments.has(column.name) || column.onUpdateFn === void 0) continue;
+		const value = column.onUpdateFn();
+		assignments.set(column.name, drizzle_orm.sql`${drizzle_orm.sql.identifier(column.name)} = ${boundValue(value, column, input.bindUnmodeled)}`);
+	}
+	const statement = drizzle_orm.sql`UPDATE ${input.tableObj} SET ${drizzle_orm.sql.join([...assignments.values()], drizzle_orm.sql`, `)}`;
+	const condition = buildDrizzleWhere(input.tableObj, input.where);
+	if (condition) statement.append(drizzle_orm.sql` WHERE ${condition}`);
+	if (input.returning && input.returning.length > 0) statement.append(drizzle_orm.sql` RETURNING ${drizzle_orm.sql.join(input.returning, drizzle_orm.sql`, `)}`);
+	return statement;
 }
-
 // src/adapter.ts
-var DATE_DATA_TYPE = /(?:^|\s)date$/;
-var WALL_CLOCK_ALIAS_STEM = "__nx_wc";
-var WALL_CLOCK_PATTERN = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?$/;
+/**
+* Base database adapter abstract class.
+*
+* @remarks
+* This abstract class provides the foundation for all dialect-specific database adapters
+* (PostgreSQL, MySQL, SQLite). It defines required abstract methods that must be implemented
+* by subclasses, while providing default implementations for CRUD operations and query building.
+*
+* Dialect adapters can override any default method to provide optimized implementations.
+*
+* @packageDocumentation
+*/
+/**
+* Where a test harness installs the observer {@link DrizzleAdapter.notePoolAccess}
+* reports a transaction escape to: a global registry key rather than an
+* import, so the harness and every copy of this package agree on it.
+*/
+const TRANSACTION_ESCAPE_OBSERVER = Symbol.for("nextly.transactionEscapeObserver");
+/**
+* The SQL text a pool call was handed: a string, or the `text` (pg) or `sql`
+* (mysql2) of a query object. Undefined for a connection checkout.
+*/
+function statementOf(argument) {
+	if (typeof argument === "string") return argument;
+	if (typeof argument !== "object" || argument === null) return void 0;
+	const { text, sql } = argument;
+	if (typeof text === "string") return text;
+	return typeof sql === "string" ? sql : void 0;
+}
+/** The escape observer a test harness installed; undefined in production. */
+function escapeObserver() {
+	const observe = globalThis[TRANSACTION_ESCAPE_OBSERVER];
+	return typeof observe === "function" ? observe : void 0;
+}
+/**
+* The current stack, deep enough to reach the code that made the query. The
+* driver's and Drizzle's own frames fill V8's default of ten, which cut every
+* report off before its caller. Raised only for this capture and restored
+* after, so nothing else sees the deeper limit; it runs only for an observer a
+* test harness installed.
+*/
+function deepStack() {
+	const limit = Error.stackTraceLimit;
+	try {
+		Error.stackTraceLimit = 64;
+		return (/* @__PURE__ */ new Error()).stack ?? "";
+	} finally {
+		Error.stackTraceLimit = limit;
+	}
+}
+/**
+* Matches the `dataType` a Drizzle timestamp/datetime column reports, in both
+* the bare form and the object-qualified form some column classes carry.
+*/
+const DATE_DATA_TYPE = /(?:^|\s)date$/;
+/**
+* How far an echoed timestamp may sit from the one that was bound and still
+* count as the same value.
+*
+* A column with no fractional precision keeps whole seconds, so a stored value
+* can differ from the bound one by up to a second without anything being wrong.
+* Every real UTC offset is at least fifteen minutes, so a shift is never
+* mistaken for rounding.
+*/
+/**
+* Stem for the alias a statement spells a timestamp's wall clock out under.
+*
+* Short on purpose. PostgreSQL truncates an identifier at 63 bytes, and a
+* truncated alias is worse than a rejected one: the statement still succeeds,
+* the lookup misses the name it asked for, and the row keeps both the driver's
+* value and a stray property. A stem plus an index stays far inside the limit
+* whatever the column is called.
+*/
+const WALL_CLOCK_ALIAS_STEM = "__nx_wc";
+/**
+* A timestamp as the database itself spells it, in a fixed field order.
+*
+* Matched rather than handed to `new Date`, so nothing depends on the host's
+* parsing of a partial date. The fraction is optional and of any length, which
+* covers PostgreSQL's milliseconds and MySQL's microseconds alike.
+*/
+const WALL_CLOCK_PATTERN = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?$/;
+/**
+* Read a database's own rendering of a timestamp as UTC.
+*
+* The statement wrote a UTC wall clock, so reading one back as UTC is what
+* makes a write agree with a later read. The rendering is one the statement
+* asked for by name, so its shape does not depend on a session setting.
+*
+* Anything that does not match answers nothing, leaving the driver's value in
+* place rather than replacing it with an `Invalid Date`.
+*/
 function parseWallClockAsUtc(text) {
-  const match = WALL_CLOCK_PATTERN.exec(text.trim());
-  if (!match) return void 0;
-  const [, year, month, day, hour, minute, second, fraction = ""] = match;
-  const millis = Number(`${fraction}000`.slice(0, 3));
-  const parsed = new Date(
-    Date.UTC(
-      Number(year),
-      Number(month) - 1,
-      Number(day),
-      Number(hour),
-      Number(minute),
-      Number(second),
-      millis
-    )
-  );
-  if (Number(year) < 100) parsed.setUTCFullYear(Number(year));
-  return parsed;
+	const match = WALL_CLOCK_PATTERN.exec(text.trim());
+	if (!match) return void 0;
+	const [, year, month, day, hour, minute, second, fraction = ""] = match;
+	const millis = Number(`${fraction}000`.slice(0, 3));
+	const parsed = new Date(Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second), millis));
+	if (Number(year) < 100) parsed.setUTCFullYear(Number(year));
+	return parsed;
 }
+/** Whether a table property is a date column that can convert its own values. */
 function isDateColumn(colDef) {
-  if (!colDef || typeof colDef !== "object") return false;
-  const candidate = colDef;
-  return typeof candidate.mapFromDriverValue === "function" && typeof candidate.mapToDriverValue === "function" && DATE_DATA_TYPE.test(String(candidate.dataType));
+	if (!colDef || typeof colDef !== "object") return false;
+	const candidate = colDef;
+	return typeof candidate.mapFromDriverValue === "function" && typeof candidate.mapToDriverValue === "function" && DATE_DATA_TYPE.test(String(candidate.dataType));
 }
+/**
+* Whether a date column records the zone its value belongs to.
+*
+* A column declared WITH a time zone stores an instant, so a driver reading it
+* back gets the same moment whatever zone either end is in -- there is nothing
+* ambiguous to resolve and nothing to correct. Rendering one as text would
+* spell it in the session's zone, and reading that as UTC would move it.
+*/
 function carriesTimeZone(colDef) {
-  return colDef.withTimezone === true;
+	return colDef.withTimezone === true;
 }
+/**
+* Abstract base class for database adapters.
+*
+* @remarks
+* All dialect-specific adapters must extend this class and implement the abstract methods.
+* Default implementations are provided for CRUD operations, which can be overridden for
+* optimization or dialect-specific behavior.
+*
+* ## Required Implementations
+*
+* Subclasses must implement:
+* - `dialect` - Database dialect identifier
+* - `connect()` - Establish database connection
+* - `disconnect()` - Close database connection
+* - `executeQuery()` - Execute raw SQL query
+* - `transaction()` - Execute operations within a transaction
+* - `getCapabilities()` - Report database feature support
+*
+* ## Optional Overrides
+*
+* Subclasses can override default CRUD methods for optimization:
+* - `select()`, `selectOne()` - Custom query optimization
+* - `insert()`, `insertMany()` - Bulk insert optimization
+* - `update()`, `delete()` - Custom update/delete logic
+* - `upsert()` - Dialect-specific upsert syntax
+*
+* @example
+* ```typescript
+* export class PostgresAdapter extends DrizzleAdapter {
+*   readonly dialect = 'postgresql' as const;
+*
+*   async connect() {
+*     this.pool = new Pool({ connectionString: this.config.url });
+*     // ... connection logic
+*   }
+*
+*   async executeQuery<T>(sql: string, params?: SqlParam[]) {
+*     const result = await this.pool.query(sql, params);
+*     return result.rows as T[];
+*   }
+*
+*   // ... other required methods
+* }
+* ```
+*
+* @public
+*/
+/**
+* Rows affected by a write, normalised across the driver shapes Drizzle returns.
+*
+* mysql2 resolves to `[ResultSetHeader, FieldPacket[]]`, so treating any array
+* as a row list reports the tuple length — a constant 2 whether the statement
+* matched nothing, one row, or many. Callers that branch on the count (a
+* conditional claim, a retention loop) silently get the wrong answer on MySQL,
+* so the header is read first. node-postgres reports `rowCount` and
+* better-sqlite3 reports `changes`; a plain array is a RETURNING row list, whose
+* length is the count.
+*/
 function affectedRowCount(result) {
-  if (Array.isArray(result)) {
-    const header = result[0];
-    if (header && typeof header.affectedRows === "number") {
-      return header.affectedRows;
-    }
-    return result.length;
-  }
-  const record = result;
-  const rowCount = record?.rowCount;
-  if (typeof rowCount === "number") return rowCount;
-  const changes = record?.changes;
-  if (typeof changes === "number") return changes;
-  return 0;
+	if (Array.isArray(result)) {
+		const header = result[0];
+		if (header && typeof header.affectedRows === "number") return header.affectedRows;
+		return result.length;
+	}
+	const record = result;
+	const rowCount = record?.rowCount;
+	if (typeof rowCount === "number") return rowCount;
+	const changes = record?.changes;
+	if (typeof changes === "number") return changes;
+	return 0;
 }
 var DrizzleAdapter = class {
-  /**
-   * Whether a `transaction()` call made from the current async context would
-   * join a transaction already open on this adapter, as a savepoint, rather
-   * than open one of its own.
-   *
-   * A caller about to do something no rollback can undo — removing a stored
-   * file, say — asks this first: work that joins an enclosing transaction is
-   * undone with it, while the effect it performs after its own savepoint
-   * releases is not.
-   *
-   * False here. Concrete rather than abstract so existing adapters keep
-   * working unchanged, and false is right for a pooled adapter: a call made
-   * inside another transaction's work opens its own transaction on its own
-   * connection, which commits independently.
-   *
-   * @returns True when the call would nest in an open transaction
-   */
-  inTransaction() {
-    return false;
-  }
-  /**
-   * The transaction each async flow is inside, kept per flow rather than per
-   * connection: on SQLite every request shares the one connection, and
-   * another request's open transaction says nothing about this one.
-   */
-  flowTransactions = new async_hooks.AsyncLocalStorage();
-  /**
-   * Whether the calling async flow is inside a transaction on this adapter
-   * that has not finished: its own, or one it was started from inside.
-   *
-   * A write that must outlive any rollback — a count of a failed attempt, the
-   * spend of a single-use secret — asks this before running in a transaction
-   * of its own. Made inside an open transaction on SQLite, it joins that
-   * transaction as a savepoint and is undone with it. On PostgreSQL and MySQL
-   * it would commit on a connection of its own, so refusing it there too
-   * keeps code that passes on one dialect from failing on another. Unlike
-   * {@link inTransaction}, which asks whether a call would nest and is always
-   * false on a pooled adapter, this answers alike on every dialect, and
-   * another flow's open transaction never answers true.
-   *
-   * Covers transactions opened through {@link transaction} and through the
-   * Drizzle handle's own `transaction` on the dialects whose handle takes
-   * async work. A dialect that keeps scopes of its own judges from those
-   * instead; an adapter that does neither answers false.
-   *
-   * @experimental
-   * @returns True while a transaction the calling flow is inside is open
-   */
-  transactionOpenInFlow() {
-    for (let at = this.flowTransactions.getStore(); at !== void 0; at = at.enclosing) {
-      if (at.open) return true;
-    }
-    return false;
-  }
-  /**
-   * Run a whole transaction, from its BEGIN until its COMMIT or ROLLBACK has
-   * run, as the calling flow's open transaction, for
-   * {@link transactionOpenInFlow}. A dialect's `transaction` runs through
-   * this unless it judges the flow from scopes of its own.
-   *
-   * The transaction counts as open for its work and for anything the work
-   * starts, awaited or not, until it has finished. Something the work starts
-   * that outlives it then sees it closed, or the one enclosing it still open.
-   *
-   * @param run - The transaction, BEGIN to COMMIT or ROLLBACK
-   * @returns What `run` resolves to
-   */
-  runInFlowTransaction(run) {
-    const scope = {
-      open: true,
-      enclosing: this.flowTransactions.getStore()
-    };
-    return this.flowTransactions.run(scope, async () => {
-      try {
-        return await run();
-      } finally {
-        scope.open = false;
-      }
-    });
-  }
-  /**
-   * Run each of a pool-bound Drizzle handle's transactions on a connection
-   * `checkout` hands it, and return that connection as the adapter's own
-   * `transaction()` does: closed rather than pooled when no ROLLBACK can be
-   * confirmed on it, and never leaked by a failed BEGIN (`pinTransactions`).
-   *
-   * For PostgreSQL's and MySQL's handles. Apply it before
-   * {@link trackFlowTransactions}, which wraps whatever `transaction` the
-   * handle has at that point.
-   *
-   * @param db - A Drizzle handle on this adapter's pool
-   * @param checkout - Checks out a connection for one transaction
-   * @returns The same handle, its `transaction` replaced
-   */
-  pinDrizzleTransactions(db, checkout) {
-    return pinTransactions(db, checkout);
-  }
-  /**
-   * Make a Drizzle handle's own `transaction` count for
-   * {@link transactionOpenInFlow}, as the adapter's does.
-   *
-   * Core's services run their transactions through the handle on PostgreSQL
-   * and MySQL; without this, a call made inside one would be refused on
-   * SQLite, where they go through the adapter, and let through on the
-   * others. Not for SQLite's handle: its `transaction` takes only
-   * synchronous work, which no async flow can be inside.
-   *
-   * @param db - A Drizzle handle this adapter created
-   * @returns The same handle, its `transaction` tracked
-   */
-  trackFlowTransactions(db) {
-    const transactor = db;
-    const untracked = transactor.transaction.bind(transactor);
-    const tracked = (work, config) => this.runInFlowTransaction(() => untracked(work, config));
-    Object.defineProperty(db, "transaction", {
-      value: tracked,
-      configurable: true,
-      writable: true
-    });
-    return db;
-  }
-  /**
-   * Run `effect` once the write made from the current async context has
-   * committed: an event, a hook, a cache flush, anything outside the database
-   * that must not happen for a change that is rolled back.
-   *
-   * A caller invokes this after its own transaction has resolved. Where that
-   * transaction was nested in an enclosing one, as a savepoint, the change is
-   * not durable yet, and an adapter that nests (see {@link inTransaction})
-   * holds `effect` until the outermost transaction commits, and drops it when
-   * that transaction, or the savepoint it was registered in, rolls back. A
-   * held effect runs after the commit, before the outermost `transaction()`
-   * call resolves, in registration order; one that then throws or rejects is
-   * handed to `onDeferredFailure` rather than failing a transaction that has
-   * committed.
-   *
-   * Here `effect` runs now and the returned promise settles with it, its
-   * failure included. Concrete rather than abstract, as `inTransaction` is,
-   * and right for a pooled adapter: each transaction has its own connection
-   * and has committed by the time its caller continues.
-   *
-   * @experimental
-   * @param effect - What to run once the change is durable
-   * @param onDeferredFailure - Receives the error of a held effect that fails
-   * @returns Settles once `effect` has run, or once it has been held
-   */
-  async afterCommit(effect, _onDeferredFailure) {
-    await effect();
-  }
-  // ============================================================
-  // Drizzle Query API Support
-  // ============================================================
-  /**
-   * Table resolver for looking up Drizzle table objects by name.
-   * When set, CRUD methods use Drizzle's query API instead of raw SQL.
-   * Set via setTableResolver() after boot-time schema loading.
-   */
-  tableResolver = null;
-  /**
-   * Set the table resolver for Drizzle query API support.
-   * When a resolver is set, CRUD methods (select, insert, update, delete, upsert)
-   * will use Drizzle's query API (db.select().from(), etc.) instead of raw SQL
-   * string building. Falls back to raw SQL if the resolver doesn't have the table.
-   *
-   * @param resolver - TableResolver implementation (e.g. SchemaRegistry)
-   */
-  setTableResolver(resolver) {
-    this.tableResolver = resolver;
-  }
-  /**
-   * Get a Drizzle table object by name from the resolver.
-   * Returns null if no resolver is set or table is not found.
-   */
-  getTableObject(tableName) {
-    return this.tableResolver?.getTable(tableName) ?? null;
-  }
-  /**
-   * Run a Drizzle-built statement and return its rows.
-   *
-   * @remarks
-   * The CRUD methods resolve their table through the schema registry and reject
-   * any name it does not declare, which leaves no way to read from a table the
-   * ORM does not know — one mid-rename, above all — except by assembling SQL and
-   * quoting identifiers by hand. This takes Drizzle's `sql` template instead, so
-   * the dialect in use decides the quoting and the parameter binding.
-   *
-   * Concrete rather than abstract so existing adapters keep working unchanged.
-   * The three drivers disagree about both the call and the result: node-postgres
-   * returns `{ rows }`, mysql2 a `[rows, fields]` tuple, and better-sqlite3 has
-   * no `execute` at all and answers `all`. Keeping that here rather than at each
-   * call site is the point — a caller reasoning about it would be reasoning
-   * about a driver it cannot see.
-   *
-   * @param statement - Drizzle `sql` template to run
-   * @returns Rows the statement produced
-   */
-  async queryStatement(statement) {
-    if (this.getCapabilities().dialect === "sqlite") {
-      const db2 = this.getDrizzle();
-      return await db2.all(statement);
-    }
-    const db = this.getDrizzle();
-    const result = await db.execute(statement);
-    if (Array.isArray(result)) {
-      return Array.isArray(result[0]) ? result[0] : result;
-    }
-    if (typeof result === "object" && result !== null && Array.isArray(result.rows)) {
-      return result.rows;
-    }
-    throw this.createDatabaseError(
-      "query",
-      "Drizzle statement returned a result shape this adapter does not recognise; refusing to report it as an empty result.",
-      void 0
-    );
-  }
-  /**
-   * Map data keys from SQL column names (snake_case) to Drizzle JS property names (camelCase).
-   * Drizzle schemas define columns as e.g. `createdAt: timestamp("created_at")` — the JS
-   * property is `createdAt` but the SQL column is `created_at`. Services pass snake_case keys
-   * because they match the DB column names. This method maps them to the JS names Drizzle expects.
-   */
-  mapDataToColumnNames(tableObj, data) {
-    if (!tableObj || typeof tableObj !== "object") return data;
-    const sqlToJs = /* @__PURE__ */ new Map();
-    const jsonColumns = /* @__PURE__ */ new Set();
-    for (const [jsName, colDef] of Object.entries(
-      tableObj
-    )) {
-      if (!colDef || typeof colDef !== "object" || !("name" in colDef) || typeof colDef.name !== "string")
-        continue;
-      const sqlName = colDef.name;
-      sqlToJs.set(sqlName, jsName);
-      if (isJsonColumn(colDef)) {
-        jsonColumns.add(jsName);
-      }
-    }
-    if (sqlToJs.size === 0) return data;
-    const mapped = {};
-    for (const [key, value] of Object.entries(data)) {
-      const jsKey = sqlToJs.get(key) ?? key;
-      if (jsonColumns.has(jsKey) && typeof value === "string") {
-        try {
-          mapped[jsKey] = JSON.parse(value);
-        } catch {
-          mapped[jsKey] = value;
-        }
-      } else {
-        mapped[jsKey] = value;
-      }
-    }
-    return mapped;
-  }
-  /**
-   * Map data keys from Drizzle JS property names to SQL column names for the
-   * raw-SQL transaction insert path. The transaction context builds INSERT
-   * statements from Object.keys(data) used directly as column identifiers, so a
-   * table whose Drizzle property names differ from its SQL column names
-   * (camelCase core tables like nextly_versions) needs its keys translated
-   * first. For tables whose property names already equal their column names
-   * (the dynamic dc_/single_/comp_ tables) every lookup is identity, so
-   * existing callers are unaffected.
-   */
-  mapKeysToSqlColumns(tableObj, data) {
-    if (!tableObj || typeof tableObj !== "object") return data;
-    const jsToSql = /* @__PURE__ */ new Map();
-    for (const [jsName, colDef] of Object.entries(
-      tableObj
-    )) {
-      if (colDef && typeof colDef === "object" && "name" in colDef && typeof colDef.name === "string") {
-        jsToSql.set(jsName, colDef.name);
-      }
-    }
-    if (jsToSql.size === 0) return data;
-    const out = {};
-    for (const [key, value] of Object.entries(data)) {
-      out[jsToSql.get(key) ?? key] = value;
-    }
-    return out;
-  }
-  /**
-   * Map a list of column identifiers (Drizzle property names) to their SQL
-   * column names, for the raw-SQL transaction insert paths that build a
-   * RETURNING clause from `options.returning`. Same identity behavior as
-   * `mapKeysToSqlColumns`: names that are already SQL columns (the dynamic
-   * dc_/single_/comp_ tables) pass through unchanged.
-   */
-  mapColumnNamesToSql(tableObj, names) {
-    if (!tableObj || typeof tableObj !== "object") return names;
-    const jsToSql = /* @__PURE__ */ new Map();
-    for (const [jsName, colDef] of Object.entries(
-      tableObj
-    )) {
-      if (colDef && typeof colDef === "object" && "name" in colDef && typeof colDef.name === "string") {
-        jsToSql.set(jsName, colDef.name);
-      }
-    }
-    if (jsToSql.size === 0) return names;
-    return names.map((n) => jsToSql.get(n) ?? n);
-  }
-  /**
-   * Remap a raw-SQL result row's KEYS from SQL column names to Drizzle property
-   * names, so the raw-SQL transaction insert paths return the same key casing
-   * as the non-transactional (Drizzle) insert. Keys only - values are left
-   * untouched, so this does not change how JSON/date columns are decoded. For
-   * tables whose property names already equal their SQL columns (the dynamic
-   * dc_/single_/comp_ tables) every lookup is identity, so existing callers see
-   * no change.
-   */
-  mapRowKeysToJs(tableObj, row) {
-    if (!tableObj || typeof tableObj !== "object" || !row || typeof row !== "object") {
-      return row;
-    }
-    const sqlToJs = /* @__PURE__ */ new Map();
-    for (const [jsName, colDef] of Object.entries(
-      tableObj
-    )) {
-      if (colDef && typeof colDef === "object" && "name" in colDef && typeof colDef.name === "string") {
-        sqlToJs.set(colDef.name, jsName);
-      }
-    }
-    if (sqlToJs.size === 0) return row;
-    const out = {};
-    for (const [key, value] of Object.entries(row)) {
-      out[sqlToJs.get(key) ?? key] = value;
-    }
-    return out;
-  }
-  /**
-   * Decode a raw-SQL result row's DATE column values the way a Drizzle query
-   * would, so a write answers with the same representation a read of the same
-   * column gives.
-   *
-   * A Drizzle query path runs every value through its column definition; a
-   * raw-SQL path does not, so a dialect that stores a timestamp as a number
-   * answers a write with that number while every read answers a `Date`. Only
-   * date columns are touched, and a value that is already a `Date` is left
-   * alone, so a driver that decodes on its own is unaffected.
-   *
-   * Runs after {@link mapRowKeysToJs}: keys are Drizzle property names by then,
-   * which is what the table definition is keyed by.
-   */
-  mapDateValuesFromDriver(tableObj, row) {
-    if (!tableObj || typeof tableObj !== "object" || !row || typeof row !== "object") {
-      return row;
-    }
-    let decoded;
-    for (const [jsName, colDef] of Object.entries(
-      tableObj
-    )) {
-      if (!isDateColumn(colDef)) continue;
-      const value = row[jsName];
-      if (value == null || value instanceof Date) continue;
-      decoded ??= { ...row };
-      decoded[jsName] = colDef.mapFromDriverValue(value);
-    }
-    return decoded ?? row;
-  }
-  /**
-   * Encode a row's DATE values the way a Drizzle query would before binding
-   * them, so what lands in the column does not depend on the server's timezone.
-   *
-   * A column declared without a time zone stores a wall clock and records
-   * nothing about which zone it belongs to, so both ends have to agree. Drizzle
-   * writes UTC and reads UTC. A driver handed a `Date` writes the LOCAL wall
-   * clock instead, and the same row then reads back shifted by the offset --
-   * on a UTC server the two agree and nothing is visibly wrong, which is why
-   * this survives CI.
-   *
-   * Only date columns are touched. A value that is not a `Date` is left as it
-   * is, so a caller that already encoded one is not encoded twice.
-   *
-   * Keys may be spelled either way at this point, so both the Drizzle property
-   * name and the SQL column name resolve.
-   */
-  mapDateValuesToDriver(tableObj, data) {
-    if (!tableObj || typeof tableObj !== "object" || !data) return data;
-    const dateColumns = /* @__PURE__ */ new Map();
-    for (const [jsName, colDef] of Object.entries(
-      tableObj
-    )) {
-      if (!isDateColumn(colDef)) continue;
-      dateColumns.set(jsName, colDef);
-      const sqlName = colDef.name;
-      if (typeof sqlName === "string") dateColumns.set(sqlName, colDef);
-    }
-    if (dateColumns.size === 0) return data;
-    let encoded;
-    for (const [key, value] of Object.entries(data)) {
-      if (!(value instanceof Date)) continue;
-      const column = dateColumns.get(key);
-      if (!column) continue;
-      encoded ??= { ...data };
-      encoded[key] = column.mapToDriverValue(value);
-    }
-    return encoded ?? data;
-  }
-  /**
-   * Bring a row about to be written through a raw-SQL statement into the shape
-   * a Drizzle query would have bound: SQL column names for keys, encoded values
-   * for date columns.
-   *
-   * The mirror of {@link mapRowFromRawSql}. The raw-SQL write paths exist
-   * because a dialect needs SQL a Drizzle query cannot express, not because
-   * their callers want different values in the table.
-   */
-  mapRowToRawSql(tableObj, data) {
-    return this.mapDateValuesToDriver(
-      tableObj,
-      this.mapKeysToSqlColumns(tableObj, data)
-    );
-  }
-  /**
-   * Bring a raw-SQL result row into the shape a Drizzle query would have
-   * produced: Drizzle property names for keys, decoded values for date columns.
-   *
-   * The raw-SQL write paths exist because a dialect needs SQL a Drizzle query
-   * cannot express, not because their callers want a different row shape, so
-   * every one of them ends here.
-   */
-  mapRowFromRawSql(tableObj, row, aliases = []) {
-    const mapped = this.mapDateValuesFromDriver(
-      tableObj,
-      this.mapRowKeysToJs(tableObj, row)
-    );
-    return this.applyWallClockAliases(mapped, aliases);
-  }
-  /**
-   * The date columns a statement is about to return, and the alias each one's
-   * wall clock is spelled out under.
-   *
-   * A driver turns a timestamp into a `Date` using ITS zone before any of this
-   * code runs, and that conversion is lossy: a wall clock inside a
-   * daylight-saving gap is a local time that does not exist, so the driver
-   * normalizes it and the original is gone. Asking the database for the wall
-   * clock as text alongside the row is the only way to read it exactly.
-   *
-   * `"*"` covers every date column; a projection covers only the ones it asked
-   * for, so a caller still gets back what it requested and nothing more.
-   */
-  dateWallClockAliases(tableObj, returning) {
-    if (!tableObj || typeof tableObj !== "object" || returning === void 0) {
-      return [];
-    }
-    const requested = returning === "*" ? void 0 : new Set(returning.map(String));
-    const taken = /* @__PURE__ */ new Set();
-    for (const [jsName, colDef] of Object.entries(
-      tableObj
-    )) {
-      taken.add(jsName);
-      const columnName = colDef.name;
-      if (typeof columnName === "string") taken.add(columnName);
-    }
-    let next = 0;
-    const freeAlias = () => {
-      let candidate = `${WALL_CLOCK_ALIAS_STEM}${next++}`;
-      while (taken.has(candidate)) {
-        candidate = `${WALL_CLOCK_ALIAS_STEM}${next++}`;
-      }
-      taken.add(candidate);
-      return candidate;
-    };
-    const aliases = [];
-    for (const [jsName, colDef] of Object.entries(
-      tableObj
-    )) {
-      if (!isDateColumn(colDef)) continue;
-      if (carriesTimeZone(colDef)) continue;
-      const sqlName = colDef.name;
-      if (typeof sqlName !== "string") continue;
-      if (requested && !requested.has(sqlName) && !requested.has(jsName)) {
-        continue;
-      }
-      aliases.push({ sqlName, alias: freeAlias(), jsName });
-    }
-    return aliases;
-  }
-  /**
-   * Replace each date in a row with the wall clock the database spelled out,
-   * read as UTC, and drop the aliases that carried it.
-   *
-   * The statement writes a UTC wall clock, so reading one back as UTC is what
-   * makes a write and a later read agree. Whatever the column actually stored
-   * is what arrives -- a column keeping only whole seconds reports whole
-   * seconds -- because this is the database's own text, not a value
-   * reconstructed from the one that was bound.
-   */
-  applyWallClockAliases(row, aliases) {
-    if (!row || typeof row !== "object" || aliases.length === 0) return row;
-    const record = row;
-    let resolved;
-    for (const { alias, jsName } of aliases) {
-      if (!(alias in record)) continue;
-      resolved ??= { ...record };
-      const text = resolved[alias];
-      delete resolved[alias];
-      if (typeof text !== "string") continue;
-      const parsed = parseWallClockAsUtc(text);
-      if (parsed !== void 0) resolved[jsName] = parsed;
-    }
-    return resolved ?? row;
-  }
-  /**
-   * Build a Drizzle column projection object (`{ propertyName: column }`) from a
-   * requested column list, used by `select` (columns) and `insert` (returning).
-   * A requested name resolves against either the Drizzle property name
-   * (camelCase) or the SQL column name (snake_case); the projection is keyed by
-   * the property name so the row shape matches a full select. Returns undefined
-   * for `"*"` or when nothing resolves, so callers fall back to all columns.
-   */
-  buildColumnProjection(tableObj, names) {
-    if (names == null || names === "*" || !tableObj || typeof tableObj !== "object") {
-      return void 0;
-    }
-    const { projection } = this.resolveColumns(tableObj, names);
-    return Object.keys(projection).length ? projection : void 0;
-  }
-  /**
-   * The requested column names split into what this table has and what it does not.
-   *
-   * One resolution, reported both ways, because two callers need different halves
-   * of the same answer: a projection drops what it cannot find, while a distinct
-   * count has to REFUSE it. Resolving twice would let the two disagree about what
-   * "found" means — the SQL-name alias below is exactly the kind of detail a
-   * second implementation gets wrong — and the count would then reject a column
-   * the projection happily uses.
-   *
-   * Both spellings resolve: a caller may name the Drizzle property or the SQL
-   * column, and either maps to the same projection key.
-   */
-  resolveColumns(tableObj, names) {
-    const cols = drizzleOrm.getColumns(tableObj);
-    const byAnyName = {};
-    for (const [jsName, col] of Object.entries(cols)) {
-      byAnyName[jsName] = { jsName, col };
-      const sqlName = col?.name;
-      if (typeof sqlName === "string") byAnyName[sqlName] = { jsName, col };
-    }
-    const projection = {};
-    const unresolved = [];
-    for (const name of names) {
-      const hit = byAnyName[name];
-      if (hit) projection[hit.jsName] = hit.col;
-      else unresolved.push(name);
-    }
-    return { projection, unresolved };
-  }
-  // ============================================================
-  // Connection Status (Default implementations, can override)
-  // ============================================================
-  /**
-   * Check if the adapter is currently connected.
-   *
-   * @remarks
-   * Default implementation returns false. Subclasses should override
-   * to provide accurate connection status.
-   *
-   * @returns True if connected, false otherwise
-   */
-  isConnected() {
-    return false;
-  }
-  /**
-   * Get connection pool statistics.
-   *
-   * @remarks
-   * Returns null by default. Subclasses with connection pooling
-   * should override to provide pool statistics.
-   *
-   * @returns Pool statistics or null if not applicable
-   */
-  getPoolStats() {
-    return null;
-  }
-  // ============================================================
-  // Timeout Utilities
-  // ============================================================
-  /**
-   * Default query timeout in milliseconds.
-   *
-   * @remarks
-   * This value is used by executeWithTimeout() when no explicit timeout
-   * is provided. Subclasses should set this from their config.
-   *
-   * @default 15000 (15 seconds)
-   *
-   * @protected
-   */
-  defaultQueryTimeoutMs = 15e3;
-  /**
-   * Execute an async operation with a timeout.
-   *
-   * @remarks
-   * Wraps an async operation with a timeout that aborts if the operation
-   * exceeds the specified duration. Uses Promise.race for clean timeout
-   * handling without memory leaks.
-   *
-   * When the timeout is reached, a DatabaseError with kind 'timeout' is thrown.
-   * Note that this does NOT cancel the underlying database query - it only
-   * prevents the calling code from waiting indefinitely. For true query
-   * cancellation, use database-level statement timeouts (PostgreSQL) or
-   * similar mechanisms.
-   *
-   * @param operation - Async operation to execute
-   * @param timeoutMs - Timeout in milliseconds (defaults to defaultQueryTimeoutMs)
-   * @returns Result of the operation
-   *
-   * @throws {DatabaseError} With kind 'timeout' if operation exceeds timeout
-   *
-   * @example
-   * ```typescript
-   * // Use default timeout
-   * const result = await adapter.executeWithTimeout(
-   *   () => adapter.select('users', { limit: 1000 })
-   * );
-   *
-   * // Use custom timeout for specific operation
-   * const result = await adapter.executeWithTimeout(
-   *   () => adapter.select('large_table'),
-   *   60000 // 60 seconds for large queries
-   * );
-   * ```
-   *
-   * @public
-   */
-  async executeWithTimeout(operation, timeoutMs) {
-    const timeout = timeoutMs ?? this.defaultQueryTimeoutMs;
-    if (timeout <= 0) {
-      return operation();
-    }
-    let timeoutId;
-    const timeoutPromise = new Promise((_, reject) => {
-      timeoutId = setTimeout(() => {
-        reject(
-          this.createDatabaseError(
-            "timeout",
-            `Query execution timed out after ${timeout}ms`
-          )
-        );
-      }, timeout);
-    });
-    try {
-      const result = await Promise.race([operation(), timeoutPromise]);
-      return result;
-    } finally {
-      if (timeoutId !== void 0) {
-        clearTimeout(timeoutId);
-      }
-    }
-  }
-  /**
-   * Set the default query timeout.
-   *
-   * @remarks
-   * This method allows runtime configuration of the default timeout.
-   * Subclasses should call this in their constructor or connect() method
-   * based on their configuration.
-   *
-   * @param timeoutMs - Timeout in milliseconds (0 to disable)
-   *
-   * @protected
-   */
-  setDefaultQueryTimeout(timeoutMs) {
-    this.defaultQueryTimeoutMs = timeoutMs;
-  }
-  /**
-   * Get the current default query timeout.
-   *
-   * @returns Current default timeout in milliseconds
-   *
-   * @public
-   */
-  getDefaultQueryTimeout() {
-    return this.defaultQueryTimeoutMs;
-  }
-  // ============================================================
-  // CRUD Operations (Default implementations, can override)
-  // ============================================================
-  /**
-   * Select multiple records from a table.
-   *
-   * @remarks
-   * Default implementation builds a SELECT query and executes it.
-   * Subclasses can override for optimization or dialect-specific features.
-   *
-   * @param table - Table name
-   * @param options - Select options (filtering, sorting, pagination)
-   * @returns Array of matching records
-   *
-   * @throws {DatabaseError} If query fails
-   *
-   * @example
-   * ```typescript
-   * const users = await adapter.select('users', {
-   *   where: { and: [{ column: 'role', op: '=', value: 'admin' }] },
-   *   orderBy: [{ column: 'created_at', direction: 'desc' }],
-   *   limit: 10
-   * });
-   * ```
-   */
-  async select(table, options, executor) {
-    const tableObj = this.getTableObject(table);
-    if (tableObj) {
-      try {
-        const db = executor ?? this.getDrizzle();
-        const projection = options?.columns?.length ? this.buildColumnProjection(tableObj, options.columns) : void 0;
-        let query = projection ? db.select(projection).from(tableObj) : db.select().from(tableObj);
-        if (options?.where) {
-          const whereCondition = buildDrizzleWhere(
-            tableObj,
-            options.where
-          );
-          if (whereCondition) {
-            query = query.where(whereCondition);
-          }
-        }
-        if (options?.orderBy?.length) {
-          const orderClauses = buildDrizzleOrderBy(
-            drizzleOrm.getColumns(tableObj),
-            options.orderBy
-          );
-          if (orderClauses.length) {
-            query = query.orderBy(...orderClauses);
-          }
-        }
-        if (options?.limit !== void 0) {
-          query = query.limit(options.limit);
-        }
-        if (options?.offset !== void 0) {
-          query = query.offset(options.offset);
-        }
-        if (options?.forUpdate && !executor) {
-          throw this.createDatabaseError(
-            "query",
-            "forUpdate requires a transaction executor: a lock request on the pooled connection takes no durable lock and cannot prevent a concurrent write.",
-            void 0
-          );
-        }
-        if (options?.forUpdate && this.dialect !== "sqlite") {
-          query = query.for("update");
-        }
-        return await query;
-      } catch (error) {
-        throw this.handleQueryError(error, "select", table);
-      }
-    }
-    throw this.createDatabaseError(
-      "query",
-      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
-      void 0
-    );
-  }
-  /**
-   * Select a single record from a table.
-   *
-   * @remarks
-   * Default implementation uses `select()` with limit 1 and returns first result.
-   * Returns null if no matching record is found.
-   *
-   * @param table - Table name
-   * @param options - Select options
-   * @returns First matching record or null
-   *
-   * @throws {DatabaseError} If query fails
-   *
-   * @example
-   * ```typescript
-   * const user = await adapter.selectOne('users', {
-   *   where: { and: [{ column: 'email', op: '=', value: 'user@example.com' }] }
-   * });
-   * ```
-   */
-  /** The registered table object, or a refusal naming what is missing. */
-  requireTableObject(table) {
-    const tableObj = this.getTableObject(table);
-    if (tableObj) return tableObj;
-    throw this.createDatabaseError(
-      "query",
-      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
-      void 0
-    );
-  }
-  /**
-   * The columns a distinct count groups by, or `undefined` for a row count.
-   *
-   * 🔴 EVERY named column must resolve, not merely one of them. A `distinctOn`
-   * naming no column this table has would fall through to a row count, and one
-   * naming a valid column beside a misspelled or since-removed column would
-   * count distinct over a NARROWER key than the caller asked for. Both answer a
-   * different question than the one asked, silently; the second is the worse of
-   * the two, because a subset key groups more rows together and so UNDERCOUNTS,
-   * which reads as a plausible number rather than as a fault. Refused here,
-   * where the mistake was made, rather than surfacing as a wrong figure.
-   */
-  countProjection(tableObj, table, options) {
-    const distinctOn = options?.distinctOn;
-    if (!distinctOn?.length) return void 0;
-    const { projection, unresolved } = this.resolveColumns(
-      tableObj,
-      distinctOn
-    );
-    if (unresolved.length > 0) {
-      throw this.createDatabaseError(
-        "query",
-        `distinctOn names ${unresolved.length === 1 ? "a column" : "columns"} that do not exist on "${table}": ${unresolved.join(", ")}`,
-        void 0
-      );
-    }
-    return projection;
-  }
-  /**
-   * `COUNT(*)` over a `SELECT DISTINCT` subquery.
-   *
-   * Its own function because it is a genuinely different query from the plain
-   * count rather than a variation on one, and because building both inline made
-   * the public method a chain of decisions the complexity gate objected to
-   * before a reader would have.
-   */
-  async countDistinctRows(db, tableObj, projection, where) {
-    const inner = db.selectDistinct(projection).from(tableObj).$dynamic();
-    const distinctRows = where ? inner.where(where) : inner;
-    const [row] = await db.select({ value: drizzleOrm.count() }).from(distinctRows.as("nextly_distinct"));
-    return Number(row?.value ?? 0);
-  }
-  /** `COUNT(*)` over the table itself. */
-  async countAllRows(db, tableObj, where) {
-    const base = db.select({ value: drizzleOrm.count() }).from(tableObj).$dynamic();
-    const [row] = await (where ? base.where(where) : base);
-    return Number(row?.value ?? 0);
-  }
-  /**
-   * How many rows match, or how many DISTINCT combinations of some columns do.
-   *
-   * The data layer had no count at all: collection totals go through
-   * `countEntries`, an access-controlled path built for collection tables, and
-   * nothing could count a system table. A caller wanting one selected the rows
-   * and measured the array, which transfers every row to learn a number and
-   * cannot be bounded without making the number wrong.
-   *
-   * 🔴 `distinctOn` compiles to `COUNT(*)` over a `SELECT DISTINCT` SUBQUERY,
-   * never to `COUNT(DISTINCT a, b)`. The inline form is not portable and fails
-   * in the direction that is hardest to notice -- MySQL accepts it, PostgreSQL
-   * needs a row constructor, and SQLite rejects it outright with "wrong number
-   * of arguments to function count()" -- so a query written against one engine
-   * is a syntax error on another. The subquery is the single form all three
-   * accept, and building it here rather than at each call site is what keeps
-   * the answer identical per dialect.
-   */
-  async count(table, options, executor) {
-    const tableObj = this.requireTableObject(table);
-    try {
-      const db = executor ?? this.getDrizzle();
-      const where = options?.where ? buildDrizzleWhere(tableObj, options.where) : void 0;
-      const projection = this.countProjection(tableObj, table, options);
-      return projection ? await this.countDistinctRows(db, tableObj, projection, where) : await this.countAllRows(db, tableObj, where);
-    } catch (error) {
-      throw this.handleQueryError(error, "count", table);
-    }
-  }
-  async selectOne(table, options, executor) {
-    const results = await this.select(
-      table,
-      { ...options, limit: 1 },
-      executor
-    );
-    return results.length > 0 ? results[0] : null;
-  }
-  /**
-   * Insert a single record into a table.
-   *
-   * @remarks
-   * Default implementation handles databases with and without RETURNING support.
-   * For databases without RETURNING (MySQL), performs INSERT followed by SELECT.
-   *
-   * @param table - Table name
-   * @param data - Record data to insert
-   * @param options - Insert options
-   * @returns Inserted record (with RETURNING columns if specified)
-   *
-   * @throws {DatabaseError} If insert fails
-   *
-   * @example
-   * ```typescript
-   * const user = await adapter.insert('users', {
-   *   email: 'user@example.com',
-   *   name: 'John Doe'
-   * }, { returning: ['id', 'email', 'created_at'] });
-   * ```
-   */
-  async insert(table, data, options) {
-    const tableObj = this.getTableObject(table);
-    if (tableObj) {
-      try {
-        const mappedData = this.mapDataToColumnNames(tableObj, data);
-        const db = this.getDrizzle();
-        const caps = this.getCapabilities();
-        const returning = options?.returning;
-        const wantsReturning = returning != null && !(Array.isArray(returning) && returning.length === 0);
-        if (caps.supportsReturning && wantsReturning) {
-          const projection = this.buildColumnProjection(tableObj, returning);
-          const insertQuery = db.insert(tableObj).values(mappedData);
-          const result2 = await (projection ? insertQuery.returning(projection) : insertQuery.returning());
-          return Array.isArray(result2) ? result2[0] : result2;
-        }
-        const result = await db.insert(tableObj).values(mappedData);
-        if (!caps.supportsReturning && wantsReturning && data.id !== void 0) {
-          return await this.selectOne(table, {
-            columns: returning === "*" ? void 0 : returning,
-            where: {
-              and: [{ column: "id", op: "=", value: data.id }]
-            }
-          });
-        }
-        return Array.isArray(result) ? result[0] : result;
-      } catch (error) {
-        throw this.handleQueryError(error, "insert", table);
-      }
-    }
-    throw this.createDatabaseError(
-      "query",
-      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
-      void 0
-    );
-  }
-  /**
-   * Insert multiple records into a table.
-   *
-   * @remarks
-   * Default implementation performs individual inserts in sequence.
-   * Subclasses can override for bulk insert optimization (e.g., COPY in PostgreSQL).
-   *
-   * @param table - Table name
-   * @param data - Array of records to insert
-   * @param options - Insert options
-   * @returns Inserted records (with RETURNING columns if specified)
-   *
-   * @throws {DatabaseError} If insert fails
-   *
-   * @example
-   * ```typescript
-   * const users = await adapter.insertMany('users', [
-   *   { email: 'user1@example.com', name: 'User 1' },
-   *   { email: 'user2@example.com', name: 'User 2' }
-   * ], { returning: ['id'] });
-   * ```
-   */
-  async insertMany(table, data, options) {
-    if (data.length === 0) {
-      return [];
-    }
-    const results = [];
-    for (const record of data) {
-      const result = await this.insert(table, record, options);
-      results.push(result);
-    }
-    return results;
-  }
-  /**
-   * Update records in a table.
-   *
-   * @remarks
-   * Default implementation builds an UPDATE query with WHERE clause.
-   * Returns updated records if RETURNING is supported and requested.
-   *
-   * @param table - Table name
-   * @param data - Data to update
-   * @param where - Conditions for records to update
-   * @param options - Update options
-   * @returns Updated records (with RETURNING columns if specified)
-   *
-   * @throws {DatabaseError} If update fails
-   *
-   * @example
-   * ```typescript
-   * const updated = await adapter.update('users',
-   *   { status: 'active' },
-   *   { and: [{ column: 'id', op: '=', value: userId }] },
-   *   { returning: ['id', 'status', 'updated_at'] }
-   * );
-   * ```
-   */
-  async update(table, data, where, options, executor) {
-    const tableObj = this.getTableObject(table);
-    if (tableObj) {
-      try {
-        const db = executor ?? this.getDrizzle();
-        const caps = this.getCapabilities();
-        const mappedData = this.mapDataToColumnNames(tableObj, data);
-        let query = db.update(tableObj).set(mappedData);
-        const whereCondition = buildDrizzleWhere(tableObj, where);
-        if (whereCondition) {
-          query = query.where(whereCondition);
-        }
-        if (caps.supportsReturning && options?.returning) {
-          return await query.returning();
-        }
-        await query;
-        if (!caps.supportsReturning && options?.returning) {
-          return await this.select(table, { where }, executor);
-        }
-        return [];
-      } catch (error) {
-        throw this.handleQueryError(error, "update", table);
-      }
-    }
-    throw this.createDatabaseError(
-      "query",
-      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
-      void 0
-    );
-  }
-  /**
-   * Update records in a table and report how many rows the statement affected.
-   *
-   * The count is the whole return value, mirroring `delete`. `update` cannot answer this: without
-   * `returning` it discards the driver's count, and WITH `returning` on a dialect that lacks
-   * RETURNING it re-SELECTs using the same WHERE — so a conditional update that just changed a
-   * column named in that WHERE reads back zero rows and a write that landed reports as unmatched.
-   * Reading the driver's own count has no second query to disagree with the first.
-   *
-   * 🔴 MySQL reports CHANGED rows, not matched rows: an UPDATE that matches a row but writes values
-   * identical to what it holds counts zero. A caller using this as a compare-and-set must therefore
-   * include a column the write always moves — a version bump, a timestamp with enough resolution —
-   * so that matched implies changed. Postgres (`rowCount`) and SQLite (`changes`) count matched
-   * rows and do not need the precaution, which is exactly why it cannot be dropped: the dialect
-   * where the distinction exists is the one with no RETURNING to fall back on.
-   */
-  async updateCount(table, data, where, executor) {
-    const tableObj = this.getTableObject(table);
-    if (tableObj) {
-      try {
-        const db = executor ?? this.getDrizzle();
-        const mappedData = this.mapDataToColumnNames(tableObj, data);
-        const statement = db.update(tableObj).set(mappedData);
-        const whereCondition = buildDrizzleWhere(tableObj, where);
-        const result = await (whereCondition ? statement.where(whereCondition) : statement);
-        return affectedRowCount(result);
-      } catch (error) {
-        throw this.handleQueryError(error, "update", table);
-      }
-    }
-    throw this.createDatabaseError(
-      "query",
-      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
-      void 0
-    );
-  }
-  /**
-   * Delete records from a table.
-   *
-   * @remarks
-   * Default implementation builds a DELETE query with WHERE clause.
-   * Returns the number of deleted records.
-   *
-   * @param table - Table name
-   * @param where - Conditions for records to delete
-   * @param options - Delete options
-   * @returns Number of deleted records
-   *
-   * @throws {DatabaseError} If delete fails
-   *
-   * @example
-   * ```typescript
-   * const count = await adapter.delete('users', {
-   *   and: [{ column: 'status', op: '=', value: 'inactive' }]
-   * });
-   * console.log(`Deleted ${count} users`);
-   * ```
-   */
-  async delete(table, where, _options, executor) {
-    const tableObj = this.getTableObject(table);
-    if (tableObj) {
-      try {
-        const db = executor ?? this.getDrizzle();
-        let query = db.delete(tableObj);
-        const whereCondition = buildDrizzleWhere(tableObj, where);
-        if (whereCondition) {
-          query = query.where(whereCondition);
-        }
-        const result = await query;
-        return affectedRowCount(result);
-      } catch (error) {
-        throw this.handleQueryError(error, "delete", table);
-      }
-    }
-    throw this.createDatabaseError(
-      "query",
-      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
-      void 0
-    );
-  }
-  /**
-   * Upsert (INSERT or UPDATE) a record.
-   *
-   * @remarks
-   * Default implementation uses dialect-specific ON CONFLICT syntax.
-   * PostgreSQL/SQLite: ON CONFLICT ... DO UPDATE
-   * MySQL: the MySQL adapter overrides this, resolving the conflict by the
-   * conflict columns (see its `upsert`)
-   *
-   * @param table - Table name
-   * @param data - Record data
-   * @param options - Upsert options (must specify conflict columns)
-   * @returns Upserted record (with RETURNING columns if specified)
-   *
-   * @throws {DatabaseError} If upsert fails
-   *
-   * @example
-   * ```typescript
-   * const user = await adapter.upsert('users', {
-   *   email: 'user@example.com',
-   *   name: 'Updated Name'
-   * }, {
-   *   conflictColumns: ['email'],
-   *   updateColumns: ['name'],
-   *   returning: ['id', 'email', 'name']
-   * });
-   * ```
-   */
-  async upsert(table, data, options, executor) {
-    const tableObj = this.getTableObject(table);
-    if (tableObj) {
-      try {
-        const db = executor ?? this.getDrizzle();
-        const caps = this.getCapabilities();
-        const columns = drizzleOrm.getColumns(tableObj);
-        const conflictTarget = options.conflictColumns.map((col) => columns[col]).filter(Boolean);
-        const conflictSet = new Set(options.conflictColumns);
-        const updateData = {};
-        const updateColumns = options.updateColumns ?? Object.keys(data);
-        for (const key of updateColumns) {
-          if (!conflictSet.has(key) && key in data) {
-            updateData[key] = data[key];
-          }
-        }
-        const keepExisting = Object.keys(updateData).length === 0;
-        this.assertUpsertTarget(table, data, options, keepExisting);
-        let query;
-        if (caps.supportsOnConflict) {
-          const inserted = db.insert(tableObj).values(data);
-          query = keepExisting ? inserted.onConflictDoNothing({ target: conflictTarget }) : inserted.onConflictDoUpdate({
-            target: conflictTarget,
-            set: updateData
-          });
-        } else {
-          query = db.insert(tableObj).values(data);
-        }
-        if (caps.supportsReturning) {
-          const result = await query.returning();
-          const row = Array.isArray(result) ? result[0] : result;
-          if (row !== void 0) return row;
-        } else {
-          await query;
-        }
-        const conflictValues = options.conflictColumns.map(
-          (column) => [column, data[column]]
-        );
-        if (conflictValues.length > 0 && conflictValues.every(([, value]) => value !== void 0)) {
-          return await this.selectOne(
-            table,
-            {
-              where: {
-                and: conflictValues.map(([column, value]) => ({
-                  column,
-                  op: "=",
-                  value
-                }))
-              }
-            },
-            executor
-          );
-        }
-        return data;
-      } catch (error) {
-        throw this.handleQueryError(error, "upsert", table);
-      }
-    }
-    throw this.createDatabaseError(
-      "query",
-      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
-      void 0
-    );
-  }
-  // ============================================================
-  // Migration Support (Default implementations, can override)
-  // ============================================================
-  /**
-   * Run pending migrations.
-   *
-   * @remarks
-   * Default implementation is a placeholder. Subclasses should implement
-   * migration tracking and execution logic.
-   *
-   * @param migrations - Array of migrations to run
-   * @returns Migration result with applied and pending migrations
-   *
-   * @throws {DatabaseError} If migration fails
-   */
-  // Base implementation throws synchronously; dialect adapters override with async logic.
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async migrate(_migrations) {
-    throw this.createDatabaseError(
-      "query",
-      "migrate() must be implemented by dialect-specific adapter. Use PostgresAdapter, MySqlAdapter, or SqliteAdapter.",
-      void 0
-    );
-  }
-  /**
-   * Rollback the last migration.
-   *
-   * @remarks
-   * Default implementation is a placeholder. Subclasses should implement
-   * migration rollback logic.
-   *
-   * @returns Migration result after rollback
-   *
-   * @throws {DatabaseError} If rollback fails
-   */
-  // Base implementation throws synchronously; dialect adapters override with async logic.
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async rollback() {
-    throw this.createDatabaseError(
-      "query",
-      "rollback() must be implemented by dialect-specific adapter. Use PostgresAdapter, MySqlAdapter, or SqliteAdapter.",
-      void 0
-    );
-  }
-  /**
-   * Get migration status.
-   *
-   * @remarks
-   * Default implementation is a placeholder. Subclasses should implement
-   * migration status checking.
-   *
-   * @returns Current migration status
-   *
-   * @throws {DatabaseError} If status check fails
-   */
-  async getMigrationStatus() {
-    try {
-      const rows = await this.executeQuery(`SELECT * FROM "__drizzle_migrations" ORDER BY created_at ASC`);
-      const applied = rows.map((r) => ({
-        id: String(r.id),
-        name: r.hash,
-        appliedAt: new Date(r.created_at),
-        checksum: r.hash
-      }));
-      return {
-        applied,
-        pending: [],
-        current: applied.length > 0 ? applied[applied.length - 1].id : null
-      };
-    } catch {
-      return { applied: [], pending: [], current: null };
-    }
-  }
-  // ============================================================
-  // Schema Operations (Default implementations, can override)
-  // ============================================================
-  /**
-   * Create a new table.
-   *
-   * @remarks
-   * Default implementation is a placeholder. Subclasses should implement
-   * table creation logic.
-   *
-   * @param definition - Table definition
-   * @param options - Creation options
-   *
-   * @throws {DatabaseError} If table creation fails
-   */
-  async createTable(definition, options) {
-    const columnDefs = definition.columns.map((col) => {
-      let colSql = `${this.escapeIdentifier(col.name)} ${col.type.toUpperCase()}`;
-      if (col.primaryKey) colSql += " PRIMARY KEY";
-      if (col.nullable === false) colSql += " NOT NULL";
-      if (col.unique) colSql += " UNIQUE";
-      if (col.default !== void 0) {
-        colSql += ` DEFAULT ${renderDefaultValue(col.default, col.name)}`;
-      }
-      return colSql;
-    });
-    const ifNotExists = options?.ifNotExists !== false ? "IF NOT EXISTS " : "";
-    const query = `CREATE TABLE ${ifNotExists}${this.escapeIdentifier(definition.name)} (
-  ${columnDefs.join(",\n  ")}
-)`;
-    try {
-      await this.executeQuery(query);
-    } catch (error) {
-      throw this.handleQueryError(error, "createTable", definition.name);
-    }
-  }
-  /**
-   * Drop a table.
-   *
-   * @remarks
-   * Default implementation is a placeholder. Subclasses should implement
-   * table dropping logic.
-   *
-   * @param tableName - Name of table to drop
-   * @param options - Drop options
-   *
-   * @throws {DatabaseError} If table drop fails
-   */
-  async dropTable(tableName, options) {
-    const ifExists = options?.ifExists !== false ? "IF EXISTS " : "";
-    const cascade = options?.cascade ? " CASCADE" : "";
-    const query = `DROP TABLE ${ifExists}${this.escapeIdentifier(tableName)}${cascade}`;
-    try {
-      await this.executeQuery(query);
-    } catch (error) {
-      throw this.handleQueryError(error, "dropTable", tableName);
-    }
-  }
-  /**
-   * Alter an existing table.
-   *
-   * @remarks
-   * Default implementation is a placeholder. Subclasses should implement
-   * table alteration logic.
-   *
-   * @param tableName - Name of table to alter
-   * @param operations - Alteration operations
-   * @param options - Alter options
-   *
-   * @throws {DatabaseError} If table alteration fails
-   */
-  async alterTable(tableName, operations, _options) {
-    const quotedTable = this.escapeIdentifier(tableName);
-    for (const op of operations) {
-      let query;
-      switch (op.kind) {
-        case "add_column": {
-          let colDef = `${this.escapeIdentifier(op.column.name)} ${op.column.type.toUpperCase()}`;
-          if (op.column.nullable === false) colDef += " NOT NULL";
-          if (op.column.unique) colDef += " UNIQUE";
-          if (op.column.default !== void 0) {
-            const defaultVal = typeof op.column.default === "object" && op.column.default !== null && "sql" in op.column.default ? op.column.default.sql : typeof op.column.default === "string" ? `'${op.column.default}'` : String(op.column.default);
-            colDef += ` DEFAULT ${defaultVal}`;
-          }
-          query = `ALTER TABLE ${quotedTable} ADD COLUMN ${colDef}`;
-          break;
-        }
-        case "drop_column": {
-          const cascade = op.cascade ? " CASCADE" : "";
-          query = `ALTER TABLE ${quotedTable} DROP COLUMN ${this.escapeIdentifier(op.columnName)}${cascade}`;
-          break;
-        }
-        case "rename_column":
-          query = `ALTER TABLE ${quotedTable} RENAME COLUMN ${this.escapeIdentifier(op.from)} TO ${this.escapeIdentifier(op.to)}`;
-          break;
-        case "modify_column": {
-          query = `ALTER TABLE ${quotedTable} ALTER COLUMN ${this.escapeIdentifier(op.column.name)} TYPE ${op.column.type.toUpperCase()}`;
-          break;
-        }
-        case "add_constraint":
-          {
-            const constraintCols = op.constraint.columns ?? [];
-            const colList = constraintCols.map((c) => this.escapeIdentifier(c)).join(", ");
-            if (op.constraint.type === "check" && op.constraint.expression) {
-              query = `ALTER TABLE ${quotedTable} ADD CONSTRAINT ${this.escapeIdentifier(op.constraint.name)} CHECK (${op.constraint.expression})`;
-            } else {
-              query = `ALTER TABLE ${quotedTable} ADD CONSTRAINT ${this.escapeIdentifier(op.constraint.name)} ${op.constraint.type.toUpperCase()} (${colList})`;
-            }
-            break;
-          }
-        case "drop_constraint": {
-          const cascadeConstraint = op.cascade ? " CASCADE" : "";
-          query = `ALTER TABLE ${quotedTable} DROP CONSTRAINT ${this.escapeIdentifier(op.constraintName)}${cascadeConstraint}`;
-          break;
-        }
-        default:
-          throw this.createDatabaseError(
-            "query",
-            `Unsupported alter table operation: ${op.kind}`,
-            void 0
-          );
-      }
-      try {
-        await this.executeQuery(query);
-      } catch (error) {
-        throw this.handleQueryError(error, "alterTable", tableName);
-      }
-    }
-  }
-  /**
-   * Check if a table exists in the database.
-   *
-   * @remarks
-   * Uses dialect-specific information schema queries to check table existence.
-   * This is useful for development mode auto-sync to determine whether to
-   * CREATE or DROP/CREATE tables.
-   *
-   * @param tableName - Name of table to check
-   * @param schema - Optional schema name (defaults to 'public' for PostgreSQL)
-   * @returns True if table exists, false otherwise
-   *
-   * @throws {DatabaseError} If query fails
-   *
-   * @example
-   * ```typescript
-   * const exists = await adapter.tableExists('users');
-   * if (exists) {
-   *   await adapter.dropTable('users');
-   * }
-   * await adapter.createTable(userTableDef);
-   * ```
-   */
-  async tableExists(tableName, schema) {
-    try {
-      let sql6;
-      const params = [];
-      switch (this.dialect) {
-        case "postgresql":
-          sql6 = `
+	/**
+	* Whether a `transaction()` call made from the current async context would
+	* join a transaction already open on this adapter, as a savepoint, rather
+	* than open one of its own.
+	*
+	* A caller about to do something no rollback can undo — removing a stored
+	* file, say — asks this first: work that joins an enclosing transaction is
+	* undone with it, while the effect it performs after its own savepoint
+	* releases is not.
+	*
+	* False here. Concrete rather than abstract so existing adapters keep
+	* working unchanged, and false is right for a pooled adapter: a call made
+	* inside another transaction's work opens its own transaction on its own
+	* connection, which commits independently.
+	*
+	* @returns True when the call would nest in an open transaction
+	*/
+	inTransaction() {
+		return false;
+	}
+	/**
+	* The transaction each async flow is inside, kept per flow rather than per
+	* connection: on SQLite every request shares the one connection, and
+	* another request's open transaction says nothing about this one.
+	*/
+	flowTransactions = new node_async_hooks.AsyncLocalStorage();
+	/** Each pool's reporting views, by method list (`observedPool`). Gone with the pool. */
+	observedPools = /* @__PURE__ */ new WeakMap();
+	/**
+	* Whether the calling async flow is inside a transaction on this adapter
+	* that has not finished: its own, or one it was started from inside.
+	*
+	* A write that must outlive any rollback — a count of a failed attempt, the
+	* spend of a single-use secret — asks this before running in a transaction
+	* of its own. Made inside an open transaction on SQLite, it joins that
+	* transaction as a savepoint and is undone with it. On PostgreSQL and MySQL
+	* it would commit on a connection of its own, so refusing it there too
+	* keeps code that passes on one dialect from failing on another. Unlike
+	* {@link inTransaction}, which asks whether a call would nest and is always
+	* false on a pooled adapter, this answers alike on every dialect, and
+	* another flow's open transaction never answers true.
+	*
+	* Covers transactions opened through {@link transaction} and through the
+	* Drizzle handle's own `transaction` on the dialects whose handle takes
+	* async work. A dialect that keeps scopes of its own judges from those
+	* instead; an adapter that does neither answers false.
+	*
+	* @experimental
+	* @returns True while a transaction the calling flow is inside is open
+	*/
+	transactionOpenInFlow() {
+		for (let at = this.flowTransactions.getStore(); at !== void 0; at = at.enclosing) if (at.open) return true;
+		return false;
+	}
+	/**
+	* Run a whole transaction, from its BEGIN until its COMMIT or ROLLBACK has
+	* run, as the calling flow's open transaction, for
+	* {@link transactionOpenInFlow}. A dialect's `transaction` runs through
+	* this unless it judges the flow from scopes of its own.
+	*
+	* The transaction counts as open for its work and for anything the work
+	* starts, awaited or not, until it has finished. Something the work starts
+	* that outlives it then sees it closed, or the one enclosing it still open.
+	*
+	* @param run - The transaction, BEGIN to COMMIT or ROLLBACK
+	* @returns What `run` resolves to
+	*/
+	runInFlowTransaction(run) {
+		const scope = {
+			open: true,
+			connected: false,
+			enclosing: this.flowTransactions.getStore(),
+			openedAt: escapeObserver() === void 0 ? void 0 : deepStack()
+		};
+		return this.flowTransactions.run(scope, async () => {
+			try {
+				return await run();
+			} finally {
+				scope.open = false;
+			}
+		});
+	}
+	/**
+	* Record that the calling flow's transaction now holds its own connection.
+	*
+	* A pooled dialect calls this right after checking out the connection a
+	* transaction runs on, so {@link notePoolAccess} can tell that checkout,
+	* which belongs to the transaction, from any later one, which escapes it.
+	*/
+	markFlowTransactionConnected() {
+		const scope = this.flowTransactions.getStore();
+		if (scope !== void 0) scope.connected = true;
+	}
+	/**
+	* Check out, through `checkout`, the connection the calling flow's
+	* transaction runs on. A transaction opened inside another's work takes a
+	* second connection, so the checkout is reported first
+	* ({@link notePoolAccess}); once it holds its own, the transaction is
+	* marked connected, so its later checkouts are told apart from it.
+	*
+	* @param checkout - Takes a connection from the dialect's pool
+	* @returns The connection
+	*/
+	async connectFlowTransaction(checkout) {
+		this.notePoolAccess();
+		const connection = await checkout();
+		this.markFlowTransactionConnected();
+		return connection;
+	}
+	/**
+	* Called by a pooled dialect before it takes anything from its pool: a
+	* query, or a connection checkout.
+	*
+	* While the calling flow is inside a transaction that already holds its own
+	* connection, a pool access runs on another connection: outside the
+	* transaction, blind to its uncommitted writes, not undone by its rollback,
+	* and able to stall a small pool. Such an access is reported to the
+	* observer a test harness installs under
+	* `Symbol.for("nextly.transactionEscapeObserver")`, with the stack that
+	* names its call site. With no observer installed, which is every
+	* production process, this is one property read.
+	*
+	* @param statement - What the pool call was handed, its SQL passed on so
+	*   the harness can say which statement escaped; nothing for a checkout
+	*/
+	notePoolAccess(statement) {
+		const observe = escapeObserver();
+		if (observe === void 0) return;
+		for (let at = this.flowTransactions.getStore(); at !== void 0; at = at.enclosing) if (at.open && at.connected) {
+			observe({
+				dialect: this.dialect,
+				stack: deepStack(),
+				openedAt: at.openedAt,
+				statement: statementOf(statement)
+			});
+			return;
+		}
+	}
+	/**
+	* `pool`, with {@link notePoolAccess} called before each of `methods`, for
+	* handing to code that queries the pool directly, such as Drizzle's handle.
+	* Everything else, `instanceof` included, reaches the pool unchanged.
+	*
+	* One view per pool and method list, made once: every Drizzle handle on the pool is given the
+	* same one, so `getDrizzle()` and `getDrizzle(relations)` share a `$client`, as they did when
+	* each was handed the pool itself.
+	*
+	* @param pool - The driver's pool
+	* @param methods - The pool methods that take a connection
+	* @returns A view of `pool` that reports those calls
+	*/
+	observedPool(pool, methods) {
+		const key = methods.join(",");
+		const views = this.observedPools.get(pool) ?? /* @__PURE__ */ new Map();
+		this.observedPools.set(pool, views);
+		const cached = views.get(key);
+		if (cached) return cached;
+		const view = new Proxy(pool, { get: (target, property, receiver) => {
+			const value = Reflect.get(target, property, receiver);
+			if (typeof property !== "string" || !methods.includes(property) || typeof value !== "function") return value;
+			return (...args) => {
+				this.notePoolAccess(args[0]);
+				return Reflect.apply(value, target, args);
+			};
+		} });
+		views.set(key, view);
+		return view;
+	}
+	/**
+	* Run each of a pool-bound Drizzle handle's transactions on a connection
+	* `checkout` hands it, and return that connection as the adapter's own
+	* `transaction()` does: closed rather than pooled when no ROLLBACK can be
+	* confirmed on it, and never leaked by a failed BEGIN (`pinTransactions`).
+	*
+	* For PostgreSQL's and MySQL's handles. Apply it before
+	* {@link trackFlowTransactions}, which wraps whatever `transaction` the
+	* handle has at that point.
+	*
+	* @param db - A Drizzle handle on this adapter's pool
+	* @param checkout - Checks out a connection for one transaction
+	* @returns The same handle, its `transaction` replaced
+	*/
+	pinDrizzleTransactions(db, checkout) {
+		return pinTransactions(db, checkout);
+	}
+	/**
+	* Make a Drizzle handle's own `transaction` count for
+	* {@link transactionOpenInFlow}, as the adapter's does.
+	*
+	* Core's services run their transactions through the handle on PostgreSQL
+	* and MySQL; without this, a call made inside one would be refused on
+	* SQLite, where they go through the adapter, and let through on the
+	* others. Not for SQLite's handle: its `transaction` takes only
+	* synchronous work, which no async flow can be inside.
+	*
+	* @param db - A Drizzle handle this adapter created
+	* @returns The same handle, its `transaction` tracked
+	*/
+	trackFlowTransactions(db) {
+		const transactor = db;
+		const untracked = transactor.transaction.bind(transactor);
+		const tracked = (work, config) => this.runInFlowTransaction(() => untracked(work, config));
+		Object.defineProperty(db, "transaction", {
+			value: tracked,
+			configurable: true,
+			writable: true
+		});
+		return db;
+	}
+	/**
+	* Run `effect` once the write made from the current async context has
+	* committed: an event, a hook, a cache flush, anything outside the database
+	* that must not happen for a change that is rolled back.
+	*
+	* A caller invokes this after its own transaction has resolved. Where that
+	* transaction was nested in an enclosing one, as a savepoint, the change is
+	* not durable yet, and an adapter that nests (see {@link inTransaction})
+	* holds `effect` until the outermost transaction commits, and drops it when
+	* that transaction, or the savepoint it was registered in, rolls back. A
+	* held effect runs after the commit, before the outermost `transaction()`
+	* call resolves, in registration order; one that then throws or rejects is
+	* handed to `onDeferredFailure` rather than failing a transaction that has
+	* committed.
+	*
+	* Here `effect` runs now and the returned promise settles with it, its
+	* failure included. Concrete rather than abstract, as `inTransaction` is,
+	* and right for a pooled adapter: each transaction has its own connection
+	* and has committed by the time its caller continues.
+	*
+	* @experimental
+	* @param effect - What to run once the change is durable
+	* @param onDeferredFailure - Receives the error of a held effect that fails
+	* @returns Settles once `effect` has run, or once it has been held
+	*/
+	async afterCommit(effect, _onDeferredFailure) {
+		await effect();
+	}
+	/**
+	* Table resolver for looking up Drizzle table objects by name.
+	* When set, CRUD methods use Drizzle's query API instead of raw SQL.
+	* Set via setTableResolver() after boot-time schema loading.
+	*/
+	tableResolver = null;
+	/**
+	* Set the table resolver for Drizzle query API support.
+	* When a resolver is set, CRUD methods (select, insert, update, delete, upsert)
+	* will use Drizzle's query API (db.select().from(), etc.) instead of raw SQL
+	* string building. Falls back to raw SQL if the resolver doesn't have the table.
+	*
+	* @param resolver - TableResolver implementation (e.g. SchemaRegistry)
+	*/
+	setTableResolver(resolver) {
+		this.tableResolver = resolver;
+	}
+	/**
+	* Get a Drizzle table object by name from the resolver.
+	* Returns null if no resolver is set or table is not found.
+	*/
+	getTableObject(tableName) {
+		return this.tableResolver?.getTable(tableName) ?? null;
+	}
+	/**
+	* Run a Drizzle-built statement and return its rows.
+	*
+	* @remarks
+	* The CRUD methods resolve their table through the schema registry and reject
+	* any name it does not declare, which leaves no way to read from a table the
+	* ORM does not know — one mid-rename, above all — except by assembling SQL and
+	* quoting identifiers by hand. This takes Drizzle's `sql` template instead, so
+	* the dialect in use decides the quoting and the parameter binding.
+	*
+	* Concrete rather than abstract so existing adapters keep working unchanged.
+	* The three drivers disagree about both the call and the result: node-postgres
+	* returns `{ rows }`, mysql2 a `[rows, fields]` tuple, and better-sqlite3 has
+	* no `execute` at all and answers `all`. Keeping that here rather than at each
+	* call site is the point — a caller reasoning about it would be reasoning
+	* about a driver it cannot see.
+	*
+	* @param statement - Drizzle `sql` template to run
+	* @returns Rows the statement produced
+	*/
+	async queryStatement(statement) {
+		if (this.getCapabilities().dialect === "sqlite") return await this.getDrizzle().all(statement);
+		const result = await this.getDrizzle().execute(statement);
+		if (Array.isArray(result)) return Array.isArray(result[0]) ? result[0] : result;
+		if (typeof result === "object" && result !== null && Array.isArray(result.rows)) return result.rows;
+		throw this.createDatabaseError("query", "Drizzle statement returned a result shape this adapter does not recognise; refusing to report it as an empty result.", void 0);
+	}
+	/**
+	* Map data keys from SQL column names (snake_case) to Drizzle JS property names (camelCase).
+	* Drizzle schemas define columns as e.g. `createdAt: timestamp("created_at")` — the JS
+	* property is `createdAt` but the SQL column is `created_at`. Services pass snake_case keys
+	* because they match the DB column names. This method maps them to the JS names Drizzle expects.
+	*/
+	mapDataToColumnNames(tableObj, data) {
+		if (!tableObj || typeof tableObj !== "object") return data;
+		const sqlToJs = /* @__PURE__ */ new Map();
+		const jsonColumns = /* @__PURE__ */ new Set();
+		for (const [jsName, colDef] of Object.entries(tableObj)) {
+			if (!colDef || typeof colDef !== "object" || !("name" in colDef) || typeof colDef.name !== "string") continue;
+			const sqlName = colDef.name;
+			sqlToJs.set(sqlName, jsName);
+			if (isJsonColumn(colDef)) jsonColumns.add(jsName);
+		}
+		if (sqlToJs.size === 0) return data;
+		const mapped = {};
+		for (const [key, value] of Object.entries(data)) {
+			const jsKey = sqlToJs.get(key) ?? key;
+			if (jsonColumns.has(jsKey) && typeof value === "string") try {
+				mapped[jsKey] = JSON.parse(value);
+			} catch {
+				mapped[jsKey] = value;
+			}
+			else mapped[jsKey] = value;
+		}
+		return mapped;
+	}
+	/**
+	* Map data keys from Drizzle JS property names to SQL column names for the
+	* raw-SQL transaction insert path. The transaction context builds INSERT
+	* statements from Object.keys(data) used directly as column identifiers, so a
+	* table whose Drizzle property names differ from its SQL column names
+	* (camelCase core tables like nextly_versions) needs its keys translated
+	* first. For tables whose property names already equal their column names
+	* (the dynamic dc_/single_/comp_ tables) every lookup is identity, so
+	* existing callers are unaffected.
+	*/
+	mapKeysToSqlColumns(tableObj, data) {
+		if (!tableObj || typeof tableObj !== "object") return data;
+		const jsToSql = /* @__PURE__ */ new Map();
+		for (const [jsName, colDef] of Object.entries(tableObj)) if (colDef && typeof colDef === "object" && "name" in colDef && typeof colDef.name === "string") jsToSql.set(jsName, colDef.name);
+		if (jsToSql.size === 0) return data;
+		const out = {};
+		for (const [key, value] of Object.entries(data)) out[jsToSql.get(key) ?? key] = value;
+		return out;
+	}
+	/**
+	* Map a list of column identifiers (Drizzle property names) to their SQL
+	* column names, for the raw-SQL transaction insert paths that build a
+	* RETURNING clause from `options.returning`. Same identity behavior as
+	* `mapKeysToSqlColumns`: names that are already SQL columns (the dynamic
+	* dc_/single_/comp_ tables) pass through unchanged.
+	*/
+	mapColumnNamesToSql(tableObj, names) {
+		if (!tableObj || typeof tableObj !== "object") return names;
+		const jsToSql = /* @__PURE__ */ new Map();
+		for (const [jsName, colDef] of Object.entries(tableObj)) if (colDef && typeof colDef === "object" && "name" in colDef && typeof colDef.name === "string") jsToSql.set(jsName, colDef.name);
+		if (jsToSql.size === 0) return names;
+		return names.map((n) => jsToSql.get(n) ?? n);
+	}
+	/**
+	* Remap a raw-SQL result row's KEYS from SQL column names to Drizzle property
+	* names, so the raw-SQL transaction insert paths return the same key casing
+	* as the non-transactional (Drizzle) insert. Keys only - values are left
+	* untouched, so this does not change how JSON/date columns are decoded. For
+	* tables whose property names already equal their SQL columns (the dynamic
+	* dc_/single_/comp_ tables) every lookup is identity, so existing callers see
+	* no change.
+	*/
+	mapRowKeysToJs(tableObj, row) {
+		if (!tableObj || typeof tableObj !== "object" || !row || typeof row !== "object") return row;
+		const sqlToJs = /* @__PURE__ */ new Map();
+		for (const [jsName, colDef] of Object.entries(tableObj)) if (colDef && typeof colDef === "object" && "name" in colDef && typeof colDef.name === "string") sqlToJs.set(colDef.name, jsName);
+		if (sqlToJs.size === 0) return row;
+		const out = {};
+		for (const [key, value] of Object.entries(row)) out[sqlToJs.get(key) ?? key] = value;
+		return out;
+	}
+	/**
+	* Decode a raw-SQL result row's DATE column values the way a Drizzle query
+	* would, so a write answers with the same representation a read of the same
+	* column gives.
+	*
+	* A Drizzle query path runs every value through its column definition; a
+	* raw-SQL path does not, so a dialect that stores a timestamp as a number
+	* answers a write with that number while every read answers a `Date`. Only
+	* date columns are touched, and a value that is already a `Date` is left
+	* alone, so a driver that decodes on its own is unaffected.
+	*
+	* Runs after {@link mapRowKeysToJs}: keys are Drizzle property names by then,
+	* which is what the table definition is keyed by.
+	*/
+	mapDateValuesFromDriver(tableObj, row) {
+		if (!tableObj || typeof tableObj !== "object" || !row || typeof row !== "object") return row;
+		let decoded;
+		for (const [jsName, colDef] of Object.entries(tableObj)) {
+			if (!isDateColumn(colDef)) continue;
+			const value = row[jsName];
+			if (value == null || value instanceof Date) continue;
+			decoded ??= { ...row };
+			decoded[jsName] = colDef.mapFromDriverValue(value);
+		}
+		return decoded ?? row;
+	}
+	/**
+	* Encode a row's DATE values the way a Drizzle query would before binding
+	* them, so what lands in the column does not depend on the server's timezone.
+	*
+	* A column declared without a time zone stores a wall clock and records
+	* nothing about which zone it belongs to, so both ends have to agree. Drizzle
+	* writes UTC and reads UTC. A driver handed a `Date` writes the LOCAL wall
+	* clock instead, and the same row then reads back shifted by the offset --
+	* on a UTC server the two agree and nothing is visibly wrong, which is why
+	* this survives CI.
+	*
+	* Only date columns are touched. A value that is not a `Date` is left as it
+	* is, so a caller that already encoded one is not encoded twice.
+	*
+	* Keys may be spelled either way at this point, so both the Drizzle property
+	* name and the SQL column name resolve.
+	*/
+	mapDateValuesToDriver(tableObj, data) {
+		if (!tableObj || typeof tableObj !== "object" || !data) return data;
+		const dateColumns = /* @__PURE__ */ new Map();
+		for (const [jsName, colDef] of Object.entries(tableObj)) {
+			if (!isDateColumn(colDef)) continue;
+			dateColumns.set(jsName, colDef);
+			const sqlName = colDef.name;
+			if (typeof sqlName === "string") dateColumns.set(sqlName, colDef);
+		}
+		if (dateColumns.size === 0) return data;
+		let encoded;
+		for (const [key, value] of Object.entries(data)) {
+			if (!(value instanceof Date)) continue;
+			const column = dateColumns.get(key);
+			if (!column) continue;
+			encoded ??= { ...data };
+			encoded[key] = column.mapToDriverValue(value);
+		}
+		return encoded ?? data;
+	}
+	/**
+	* Bring a row about to be written through a raw-SQL statement into the shape
+	* a Drizzle query would have bound: SQL column names for keys, encoded values
+	* for date columns.
+	*
+	* The mirror of {@link mapRowFromRawSql}. The raw-SQL write paths exist
+	* because a dialect needs SQL a Drizzle query cannot express, not because
+	* their callers want different values in the table.
+	*/
+	mapRowToRawSql(tableObj, data) {
+		return this.mapDateValuesToDriver(tableObj, this.mapKeysToSqlColumns(tableObj, data));
+	}
+	/**
+	* Bring a raw-SQL result row into the shape a Drizzle query would have
+	* produced: Drizzle property names for keys, decoded values for date columns.
+	*
+	* The raw-SQL write paths exist because a dialect needs SQL a Drizzle query
+	* cannot express, not because their callers want a different row shape, so
+	* every one of them ends here.
+	*/
+	mapRowFromRawSql(tableObj, row, aliases = []) {
+		const mapped = this.mapDateValuesFromDriver(tableObj, this.mapRowKeysToJs(tableObj, row));
+		return this.applyWallClockAliases(mapped, aliases);
+	}
+	/**
+	* The date columns a statement is about to return, and the alias each one's
+	* wall clock is spelled out under.
+	*
+	* A driver turns a timestamp into a `Date` using ITS zone before any of this
+	* code runs, and that conversion is lossy: a wall clock inside a
+	* daylight-saving gap is a local time that does not exist, so the driver
+	* normalizes it and the original is gone. Asking the database for the wall
+	* clock as text alongside the row is the only way to read it exactly.
+	*
+	* `"*"` covers every date column; a projection covers only the ones it asked
+	* for, so a caller still gets back what it requested and nothing more.
+	*/
+	dateWallClockAliases(tableObj, returning) {
+		if (!tableObj || typeof tableObj !== "object" || returning === void 0) return [];
+		const requested = returning === "*" ? void 0 : new Set(returning.map(String));
+		const taken = /* @__PURE__ */ new Set();
+		for (const [jsName, colDef] of Object.entries(tableObj)) {
+			taken.add(jsName);
+			const columnName = colDef.name;
+			if (typeof columnName === "string") taken.add(columnName);
+		}
+		let next = 0;
+		const freeAlias = () => {
+			let candidate = `${WALL_CLOCK_ALIAS_STEM}${next++}`;
+			while (taken.has(candidate)) candidate = `${WALL_CLOCK_ALIAS_STEM}${next++}`;
+			taken.add(candidate);
+			return candidate;
+		};
+		const aliases = [];
+		for (const [jsName, colDef] of Object.entries(tableObj)) {
+			if (!isDateColumn(colDef)) continue;
+			if (carriesTimeZone(colDef)) continue;
+			const sqlName = colDef.name;
+			if (typeof sqlName !== "string") continue;
+			if (requested && !requested.has(sqlName) && !requested.has(jsName)) continue;
+			aliases.push({
+				sqlName,
+				alias: freeAlias(),
+				jsName
+			});
+		}
+		return aliases;
+	}
+	/**
+	* Replace each date in a row with the wall clock the database spelled out,
+	* read as UTC, and drop the aliases that carried it.
+	*
+	* The statement writes a UTC wall clock, so reading one back as UTC is what
+	* makes a write and a later read agree. Whatever the column actually stored
+	* is what arrives -- a column keeping only whole seconds reports whole
+	* seconds -- because this is the database's own text, not a value
+	* reconstructed from the one that was bound.
+	*/
+	applyWallClockAliases(row, aliases) {
+		if (!row || typeof row !== "object" || aliases.length === 0) return row;
+		const record = row;
+		let resolved;
+		for (const { alias, jsName } of aliases) {
+			if (!(alias in record)) continue;
+			resolved ??= { ...record };
+			const text = resolved[alias];
+			delete resolved[alias];
+			if (typeof text !== "string") continue;
+			const parsed = parseWallClockAsUtc(text);
+			if (parsed !== void 0) resolved[jsName] = parsed;
+		}
+		return resolved ?? row;
+	}
+	/**
+	* Build a Drizzle column projection object (`{ propertyName: column }`) from a
+	* requested column list, used by `select` (columns) and `insert` (returning).
+	* A requested name resolves against either the Drizzle property name
+	* (camelCase) or the SQL column name (snake_case); the projection is keyed by
+	* the property name so the row shape matches a full select. Returns undefined
+	* for `"*"` or when nothing resolves, so callers fall back to all columns.
+	*/
+	buildColumnProjection(tableObj, names) {
+		if (names == null || names === "*" || !tableObj || typeof tableObj !== "object") return;
+		const { projection } = this.resolveColumns(tableObj, names);
+		return Object.keys(projection).length ? projection : void 0;
+	}
+	/**
+	* The requested column names split into what this table has and what it does not.
+	*
+	* One resolution, reported both ways, because two callers need different halves
+	* of the same answer: a projection drops what it cannot find, while a distinct
+	* count has to REFUSE it. Resolving twice would let the two disagree about what
+	* "found" means — the SQL-name alias below is exactly the kind of detail a
+	* second implementation gets wrong — and the count would then reject a column
+	* the projection happily uses.
+	*
+	* Both spellings resolve: a caller may name the Drizzle property or the SQL
+	* column, and either maps to the same projection key.
+	*/
+	resolveColumns(tableObj, names) {
+		const cols = (0, drizzle_orm.getColumns)(tableObj);
+		const byAnyName = {};
+		for (const [jsName, col] of Object.entries(cols)) {
+			byAnyName[jsName] = {
+				jsName,
+				col
+			};
+			const sqlName = col?.name;
+			if (typeof sqlName === "string") byAnyName[sqlName] = {
+				jsName,
+				col
+			};
+		}
+		const projection = {};
+		const unresolved = [];
+		for (const name of names) {
+			const hit = byAnyName[name];
+			if (hit) projection[hit.jsName] = hit.col;
+			else unresolved.push(name);
+		}
+		return {
+			projection,
+			unresolved
+		};
+	}
+	/**
+	* Check if the adapter is currently connected.
+	*
+	* @remarks
+	* Default implementation returns false. Subclasses should override
+	* to provide accurate connection status.
+	*
+	* @returns True if connected, false otherwise
+	*/
+	isConnected() {
+		return false;
+	}
+	/**
+	* Get connection pool statistics.
+	*
+	* @remarks
+	* Returns null by default. Subclasses with connection pooling
+	* should override to provide pool statistics.
+	*
+	* @returns Pool statistics or null if not applicable
+	*/
+	getPoolStats() {
+		return null;
+	}
+	/**
+	* Default query timeout in milliseconds.
+	*
+	* @remarks
+	* This value is used by executeWithTimeout() when no explicit timeout
+	* is provided. Subclasses should set this from their config.
+	*
+	* @default 15000 (15 seconds)
+	*
+	* @protected
+	*/
+	defaultQueryTimeoutMs = 15e3;
+	/**
+	* Execute an async operation with a timeout.
+	*
+	* @remarks
+	* Wraps an async operation with a timeout that aborts if the operation
+	* exceeds the specified duration. Uses Promise.race for clean timeout
+	* handling without memory leaks.
+	*
+	* When the timeout is reached, a DatabaseError with kind 'timeout' is thrown.
+	* Note that this does NOT cancel the underlying database query - it only
+	* prevents the calling code from waiting indefinitely. For true query
+	* cancellation, use database-level statement timeouts (PostgreSQL) or
+	* similar mechanisms.
+	*
+	* @param operation - Async operation to execute
+	* @param timeoutMs - Timeout in milliseconds (defaults to defaultQueryTimeoutMs)
+	* @returns Result of the operation
+	*
+	* @throws {DatabaseError} With kind 'timeout' if operation exceeds timeout
+	*
+	* @example
+	* ```typescript
+	* // Use default timeout
+	* const result = await adapter.executeWithTimeout(
+	*   () => adapter.select('users', { limit: 1000 })
+	* );
+	*
+	* // Use custom timeout for specific operation
+	* const result = await adapter.executeWithTimeout(
+	*   () => adapter.select('large_table'),
+	*   60000 // 60 seconds for large queries
+	* );
+	* ```
+	*
+	* @public
+	*/
+	async executeWithTimeout(operation, timeoutMs) {
+		const timeout = timeoutMs ?? this.defaultQueryTimeoutMs;
+		if (timeout <= 0) return operation();
+		let timeoutId;
+		const timeoutPromise = new Promise((_, reject) => {
+			timeoutId = setTimeout(() => {
+				reject(this.createDatabaseError("timeout", `Query execution timed out after ${timeout}ms`));
+			}, timeout);
+		});
+		try {
+			return await Promise.race([operation(), timeoutPromise]);
+		} finally {
+			if (timeoutId !== void 0) clearTimeout(timeoutId);
+		}
+	}
+	/**
+	* Set the default query timeout.
+	*
+	* @remarks
+	* This method allows runtime configuration of the default timeout.
+	* Subclasses should call this in their constructor or connect() method
+	* based on their configuration.
+	*
+	* @param timeoutMs - Timeout in milliseconds (0 to disable)
+	*
+	* @protected
+	*/
+	setDefaultQueryTimeout(timeoutMs) {
+		this.defaultQueryTimeoutMs = timeoutMs;
+	}
+	/**
+	* Get the current default query timeout.
+	*
+	* @returns Current default timeout in milliseconds
+	*
+	* @public
+	*/
+	getDefaultQueryTimeout() {
+		return this.defaultQueryTimeoutMs;
+	}
+	/**
+	* Select multiple records from a table.
+	*
+	* @remarks
+	* Default implementation builds a SELECT query and executes it.
+	* Subclasses can override for optimization or dialect-specific features.
+	*
+	* @param table - Table name
+	* @param options - Select options (filtering, sorting, pagination)
+	* @returns Array of matching records
+	*
+	* @throws {DatabaseError} If query fails
+	*
+	* @example
+	* ```typescript
+	* const users = await adapter.select('users', {
+	*   where: { and: [{ column: 'role', op: '=', value: 'admin' }] },
+	*   orderBy: [{ column: 'created_at', direction: 'desc' }],
+	*   limit: 10
+	* });
+	* ```
+	*/
+	async select(table, options, executor) {
+		const tableObj = this.getTableObject(table);
+		if (tableObj) try {
+			const db = executor ?? this.getDrizzle();
+			const projection = options?.columns?.length ? this.buildColumnProjection(tableObj, options.columns) : void 0;
+			let query = projection ? db.select(projection).from(tableObj) : db.select().from(tableObj);
+			if (options?.where) {
+				const whereCondition = buildDrizzleWhere(tableObj, options.where);
+				if (whereCondition) query = query.where(whereCondition);
+			}
+			if (options?.orderBy?.length) {
+				const orderClauses = buildDrizzleOrderBy((0, drizzle_orm.getColumns)(tableObj), options.orderBy);
+				if (orderClauses.length) query = query.orderBy(...orderClauses);
+			}
+			if (options?.limit !== void 0) query = query.limit(options.limit);
+			if (options?.offset !== void 0) query = query.offset(options.offset);
+			if (options?.forUpdate && !executor) throw this.createDatabaseError("query", "forUpdate requires a transaction executor: a lock request on the pooled connection takes no durable lock and cannot prevent a concurrent write.", void 0);
+			if (options?.forUpdate && this.dialect !== "sqlite") query = query.for("update");
+			return await query;
+		} catch (error) {
+			throw this.handleQueryError(error, "select", table);
+		}
+		throw this.createDatabaseError("query", `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`, void 0);
+	}
+	/**
+	* Select a single record from a table.
+	*
+	* @remarks
+	* Default implementation uses `select()` with limit 1 and returns first result.
+	* Returns null if no matching record is found.
+	*
+	* @param table - Table name
+	* @param options - Select options
+	* @returns First matching record or null
+	*
+	* @throws {DatabaseError} If query fails
+	*
+	* @example
+	* ```typescript
+	* const user = await adapter.selectOne('users', {
+	*   where: { and: [{ column: 'email', op: '=', value: 'user@example.com' }] }
+	* });
+	* ```
+	*/
+	/** The registered table object, or a refusal naming what is missing. */
+	requireTableObject(table) {
+		const tableObj = this.getTableObject(table);
+		if (tableObj) return tableObj;
+		throw this.createDatabaseError("query", `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`, void 0);
+	}
+	/**
+	* The columns a distinct count groups by, or `undefined` for a row count.
+	*
+	* 🔴 EVERY named column must resolve, not merely one of them. A `distinctOn`
+	* naming no column this table has would fall through to a row count, and one
+	* naming a valid column beside a misspelled or since-removed column would
+	* count distinct over a NARROWER key than the caller asked for. Both answer a
+	* different question than the one asked, silently; the second is the worse of
+	* the two, because a subset key groups more rows together and so UNDERCOUNTS,
+	* which reads as a plausible number rather than as a fault. Refused here,
+	* where the mistake was made, rather than surfacing as a wrong figure.
+	*/
+	countProjection(tableObj, table, options) {
+		const distinctOn = options?.distinctOn;
+		if (!distinctOn?.length) return void 0;
+		const { projection, unresolved } = this.resolveColumns(tableObj, distinctOn);
+		if (unresolved.length > 0) throw this.createDatabaseError("query", `distinctOn names ${unresolved.length === 1 ? "a column" : "columns"} that do not exist on "${table}": ${unresolved.join(", ")}`, void 0);
+		return projection;
+	}
+	/**
+	* `COUNT(*)` over a `SELECT DISTINCT` subquery.
+	*
+	* Its own function because it is a genuinely different query from the plain
+	* count rather than a variation on one, and because building both inline made
+	* the public method a chain of decisions the complexity gate objected to
+	* before a reader would have.
+	*/
+	async countDistinctRows(db, tableObj, projection, where) {
+		const inner = db.selectDistinct(projection).from(tableObj).$dynamic();
+		const distinctRows = where ? inner.where(where) : inner;
+		const [row] = await db.select({ value: (0, drizzle_orm.count)() }).from(distinctRows.as("nextly_distinct"));
+		return Number(row?.value ?? 0);
+	}
+	/** `COUNT(*)` over the table itself. */
+	async countAllRows(db, tableObj, where) {
+		const base = db.select({ value: (0, drizzle_orm.count)() }).from(tableObj).$dynamic();
+		const [row] = await (where ? base.where(where) : base);
+		return Number(row?.value ?? 0);
+	}
+	/**
+	* How many rows match, or how many DISTINCT combinations of some columns do.
+	*
+	* The data layer had no count at all: collection totals go through
+	* `countEntries`, an access-controlled path built for collection tables, and
+	* nothing could count a system table. A caller wanting one selected the rows
+	* and measured the array, which transfers every row to learn a number and
+	* cannot be bounded without making the number wrong.
+	*
+	* 🔴 `distinctOn` compiles to `COUNT(*)` over a `SELECT DISTINCT` SUBQUERY,
+	* never to `COUNT(DISTINCT a, b)`. The inline form is not portable and fails
+	* in the direction that is hardest to notice -- MySQL accepts it, PostgreSQL
+	* needs a row constructor, and SQLite rejects it outright with "wrong number
+	* of arguments to function count()" -- so a query written against one engine
+	* is a syntax error on another. The subquery is the single form all three
+	* accept, and building it here rather than at each call site is what keeps
+	* the answer identical per dialect.
+	*/
+	async count(table, options, executor) {
+		const tableObj = this.requireTableObject(table);
+		try {
+			const db = executor ?? this.getDrizzle();
+			const where = options?.where ? buildDrizzleWhere(tableObj, options.where) : void 0;
+			const projection = this.countProjection(tableObj, table, options);
+			return projection ? await this.countDistinctRows(db, tableObj, projection, where) : await this.countAllRows(db, tableObj, where);
+		} catch (error) {
+			throw this.handleQueryError(error, "count", table);
+		}
+	}
+	async selectOne(table, options, executor) {
+		const results = await this.select(table, {
+			...options,
+			limit: 1
+		}, executor);
+		return results.length > 0 ? results[0] : null;
+	}
+	/**
+	* Insert a single record into a table.
+	*
+	* @remarks
+	* Default implementation handles databases with and without RETURNING support.
+	* For databases without RETURNING (MySQL), performs INSERT followed by SELECT.
+	*
+	* @param table - Table name
+	* @param data - Record data to insert
+	* @param options - Insert options
+	* @returns Inserted record (with RETURNING columns if specified)
+	*
+	* @throws {DatabaseError} If insert fails
+	*
+	* @example
+	* ```typescript
+	* const user = await adapter.insert('users', {
+	*   email: 'user@example.com',
+	*   name: 'John Doe'
+	* }, { returning: ['id', 'email', 'created_at'] });
+	* ```
+	*/
+	async insert(table, data, options) {
+		const tableObj = this.getTableObject(table);
+		if (tableObj) try {
+			const mappedData = this.mapDataToColumnNames(tableObj, data);
+			const db = this.getDrizzle();
+			const caps = this.getCapabilities();
+			const returning = options?.returning;
+			const wantsReturning = returning != null && !(Array.isArray(returning) && returning.length === 0);
+			if (caps.supportsReturning && wantsReturning) {
+				const projection = this.buildColumnProjection(tableObj, returning);
+				const insertQuery = db.insert(tableObj).values(mappedData);
+				const result = await (projection ? insertQuery.returning(projection) : insertQuery.returning());
+				return Array.isArray(result) ? result[0] : result;
+			}
+			const result = await db.insert(tableObj).values(mappedData);
+			if (!caps.supportsReturning && wantsReturning && data.id !== void 0) return await this.selectOne(table, {
+				columns: returning === "*" ? void 0 : returning,
+				where: { and: [{
+					column: "id",
+					op: "=",
+					value: data.id
+				}] }
+			});
+			return Array.isArray(result) ? result[0] : result;
+		} catch (error) {
+			throw this.handleQueryError(error, "insert", table);
+		}
+		throw this.createDatabaseError("query", `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`, void 0);
+	}
+	/**
+	* Insert multiple records into a table.
+	*
+	* @remarks
+	* Default implementation performs individual inserts in sequence.
+	* Subclasses can override for bulk insert optimization (e.g., COPY in PostgreSQL).
+	*
+	* @param table - Table name
+	* @param data - Array of records to insert
+	* @param options - Insert options
+	* @returns Inserted records (with RETURNING columns if specified)
+	*
+	* @throws {DatabaseError} If insert fails
+	*
+	* @example
+	* ```typescript
+	* const users = await adapter.insertMany('users', [
+	*   { email: 'user1@example.com', name: 'User 1' },
+	*   { email: 'user2@example.com', name: 'User 2' }
+	* ], { returning: ['id'] });
+	* ```
+	*/
+	async insertMany(table, data, options) {
+		if (data.length === 0) return [];
+		const results = [];
+		for (const record of data) {
+			const result = await this.insert(table, record, options);
+			results.push(result);
+		}
+		return results;
+	}
+	/**
+	* Update records in a table.
+	*
+	* @remarks
+	* Default implementation builds an UPDATE query with WHERE clause.
+	* Returns updated records if RETURNING is supported and requested.
+	*
+	* @param table - Table name
+	* @param data - Data to update
+	* @param where - Conditions for records to update
+	* @param options - Update options
+	* @returns Updated records (with RETURNING columns if specified)
+	*
+	* @throws {DatabaseError} If update fails
+	*
+	* @example
+	* ```typescript
+	* const updated = await adapter.update('users',
+	*   { status: 'active' },
+	*   { and: [{ column: 'id', op: '=', value: userId }] },
+	*   { returning: ['id', 'status', 'updated_at'] }
+	* );
+	* ```
+	*/
+	async update(table, data, where, options, executor) {
+		const tableObj = this.getTableObject(table);
+		if (tableObj) try {
+			const db = executor ?? this.getDrizzle();
+			const caps = this.getCapabilities();
+			const mappedData = this.mapDataToColumnNames(tableObj, data);
+			let query = db.update(tableObj).set(mappedData);
+			const whereCondition = buildDrizzleWhere(tableObj, where);
+			if (whereCondition) query = query.where(whereCondition);
+			if (caps.supportsReturning && options?.returning) return await query.returning();
+			await query;
+			if (!caps.supportsReturning && options?.returning) return await this.select(table, { where }, executor);
+			return [];
+		} catch (error) {
+			throw this.handleQueryError(error, "update", table);
+		}
+		throw this.createDatabaseError("query", `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`, void 0);
+	}
+	/**
+	* Update records in a table and report how many rows the statement affected.
+	*
+	* The count is the whole return value, mirroring `delete`. `update` cannot answer this: without
+	* `returning` it discards the driver's count, and WITH `returning` on a dialect that lacks
+	* RETURNING it re-SELECTs using the same WHERE — so a conditional update that just changed a
+	* column named in that WHERE reads back zero rows and a write that landed reports as unmatched.
+	* Reading the driver's own count has no second query to disagree with the first.
+	*
+	* 🔴 MySQL reports CHANGED rows, not matched rows: an UPDATE that matches a row but writes values
+	* identical to what it holds counts zero. A caller using this as a compare-and-set must therefore
+	* include a column the write always moves — a version bump, a timestamp with enough resolution —
+	* so that matched implies changed. Postgres (`rowCount`) and SQLite (`changes`) count matched
+	* rows and do not need the precaution, which is exactly why it cannot be dropped: the dialect
+	* where the distinction exists is the one with no RETURNING to fall back on.
+	*/
+	async updateCount(table, data, where, executor) {
+		const tableObj = this.getTableObject(table);
+		if (tableObj) try {
+			const db = executor ?? this.getDrizzle();
+			const mappedData = this.mapDataToColumnNames(tableObj, data);
+			const statement = db.update(tableObj).set(mappedData);
+			const whereCondition = buildDrizzleWhere(tableObj, where);
+			return affectedRowCount(await (whereCondition ? statement.where(whereCondition) : statement));
+		} catch (error) {
+			throw this.handleQueryError(error, "update", table);
+		}
+		throw this.createDatabaseError("query", `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`, void 0);
+	}
+	/**
+	* Delete records from a table.
+	*
+	* @remarks
+	* Default implementation builds a DELETE query with WHERE clause.
+	* Returns the number of deleted records.
+	*
+	* @param table - Table name
+	* @param where - Conditions for records to delete
+	* @param options - Delete options
+	* @returns Number of deleted records
+	*
+	* @throws {DatabaseError} If delete fails
+	*
+	* @example
+	* ```typescript
+	* const count = await adapter.delete('users', {
+	*   and: [{ column: 'status', op: '=', value: 'inactive' }]
+	* });
+	* console.log(`Deleted ${count} users`);
+	* ```
+	*/
+	async delete(table, where, _options, executor) {
+		const tableObj = this.getTableObject(table);
+		if (tableObj) try {
+			let query = (executor ?? this.getDrizzle()).delete(tableObj);
+			const whereCondition = buildDrizzleWhere(tableObj, where);
+			if (whereCondition) query = query.where(whereCondition);
+			return affectedRowCount(await query);
+		} catch (error) {
+			throw this.handleQueryError(error, "delete", table);
+		}
+		throw this.createDatabaseError("query", `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`, void 0);
+	}
+	/**
+	* Upsert (INSERT or UPDATE) a record.
+	*
+	* @remarks
+	* Default implementation uses dialect-specific ON CONFLICT syntax.
+	* PostgreSQL/SQLite: ON CONFLICT ... DO UPDATE
+	* MySQL: the MySQL adapter overrides this, resolving the conflict by the
+	* conflict columns (see its `upsert`)
+	*
+	* @param table - Table name
+	* @param data - Record data
+	* @param options - Upsert options (must specify conflict columns)
+	* @returns Upserted record (with RETURNING columns if specified)
+	*
+	* @throws {DatabaseError} If upsert fails
+	*
+	* @example
+	* ```typescript
+	* const user = await adapter.upsert('users', {
+	*   email: 'user@example.com',
+	*   name: 'Updated Name'
+	* }, {
+	*   conflictColumns: ['email'],
+	*   updateColumns: ['name'],
+	*   returning: ['id', 'email', 'name']
+	* });
+	* ```
+	*/
+	async upsert(table, data, options, executor) {
+		const tableObj = this.getTableObject(table);
+		if (tableObj) try {
+			const db = executor ?? this.getDrizzle();
+			const caps = this.getCapabilities();
+			const columns = (0, drizzle_orm.getColumns)(tableObj);
+			const conflictTarget = options.conflictColumns.map((col) => columns[col]).filter(Boolean);
+			const conflictSet = new Set(options.conflictColumns);
+			const updateData = {};
+			const updateColumns = options.updateColumns ?? Object.keys(data);
+			for (const key of updateColumns) if (!conflictSet.has(key) && key in data) updateData[key] = data[key];
+			const keepExisting = Object.keys(updateData).length === 0;
+			this.assertUpsertTarget(table, data, options, keepExisting);
+			let query;
+			if (caps.supportsOnConflict) {
+				const inserted = db.insert(tableObj).values(data);
+				query = keepExisting ? inserted.onConflictDoNothing({ target: conflictTarget }) : inserted.onConflictDoUpdate({
+					target: conflictTarget,
+					set: updateData
+				});
+			} else query = db.insert(tableObj).values(data);
+			if (caps.supportsReturning) {
+				const result = await query.returning();
+				const row = Array.isArray(result) ? result[0] : result;
+				if (row !== void 0) return row;
+			} else await query;
+			const conflictValues = options.conflictColumns.map((column) => [column, data[column]]);
+			if (conflictValues.length > 0 && conflictValues.every(([, value]) => value !== void 0)) return await this.selectOne(table, { where: { and: conflictValues.map(([column, value]) => ({
+				column,
+				op: "=",
+				value
+			})) } }, executor);
+			return data;
+		} catch (error) {
+			throw this.handleQueryError(error, "upsert", table);
+		}
+		throw this.createDatabaseError("query", `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`, void 0);
+	}
+	/**
+	* Run pending migrations.
+	*
+	* @remarks
+	* Default implementation is a placeholder. Subclasses should implement
+	* migration tracking and execution logic.
+	*
+	* @param migrations - Array of migrations to run
+	* @returns Migration result with applied and pending migrations
+	*
+	* @throws {DatabaseError} If migration fails
+	*/
+	async migrate(_migrations) {
+		throw this.createDatabaseError("query", "migrate() must be implemented by dialect-specific adapter. Use PostgresAdapter, MySqlAdapter, or SqliteAdapter.", void 0);
+	}
+	/**
+	* Rollback the last migration.
+	*
+	* @remarks
+	* Default implementation is a placeholder. Subclasses should implement
+	* migration rollback logic.
+	*
+	* @returns Migration result after rollback
+	*
+	* @throws {DatabaseError} If rollback fails
+	*/
+	async rollback() {
+		throw this.createDatabaseError("query", "rollback() must be implemented by dialect-specific adapter. Use PostgresAdapter, MySqlAdapter, or SqliteAdapter.", void 0);
+	}
+	/**
+	* Get migration status.
+	*
+	* @remarks
+	* Default implementation is a placeholder. Subclasses should implement
+	* migration status checking.
+	*
+	* @returns Current migration status
+	*
+	* @throws {DatabaseError} If status check fails
+	*/
+	async getMigrationStatus() {
+		try {
+			const applied = (await this.executeQuery(`SELECT * FROM "__drizzle_migrations" ORDER BY created_at ASC`)).map((r) => ({
+				id: String(r.id),
+				name: r.hash,
+				appliedAt: new Date(r.created_at),
+				checksum: r.hash
+			}));
+			return {
+				applied,
+				pending: [],
+				current: applied.length > 0 ? applied[applied.length - 1].id : null
+			};
+		} catch {
+			return {
+				applied: [],
+				pending: [],
+				current: null
+			};
+		}
+	}
+	/**
+	* Create a new table.
+	*
+	* @remarks
+	* Default implementation is a placeholder. Subclasses should implement
+	* table creation logic.
+	*
+	* @param definition - Table definition
+	* @param options - Creation options
+	*
+	* @throws {DatabaseError} If table creation fails
+	*/
+	async createTable(definition, options) {
+		const columnDefs = definition.columns.map((col) => {
+			let colSql = `${this.escapeIdentifier(col.name)} ${col.type.toUpperCase()}`;
+			if (col.primaryKey) colSql += " PRIMARY KEY";
+			if (col.nullable === false) colSql += " NOT NULL";
+			if (col.unique) colSql += " UNIQUE";
+			if (col.default !== void 0) colSql += ` DEFAULT ${renderDefaultValue(col.default, col.name)}`;
+			return colSql;
+		});
+		const query = `CREATE TABLE ${options?.ifNotExists !== false ? "IF NOT EXISTS " : ""}${this.escapeIdentifier(definition.name)} (\n  ${columnDefs.join(",\n  ")}\n)`;
+		try {
+			await this.executeQuery(query);
+		} catch (error) {
+			throw this.handleQueryError(error, "createTable", definition.name);
+		}
+	}
+	/**
+	* Drop a table.
+	*
+	* @remarks
+	* Default implementation is a placeholder. Subclasses should implement
+	* table dropping logic.
+	*
+	* @param tableName - Name of table to drop
+	* @param options - Drop options
+	*
+	* @throws {DatabaseError} If table drop fails
+	*/
+	async dropTable(tableName, options) {
+		const ifExists = options?.ifExists !== false ? "IF EXISTS " : "";
+		const cascade = options?.cascade ? " CASCADE" : "";
+		const query = `DROP TABLE ${ifExists}${this.escapeIdentifier(tableName)}${cascade}`;
+		try {
+			await this.executeQuery(query);
+		} catch (error) {
+			throw this.handleQueryError(error, "dropTable", tableName);
+		}
+	}
+	/**
+	* Alter an existing table.
+	*
+	* @remarks
+	* Default implementation is a placeholder. Subclasses should implement
+	* table alteration logic.
+	*
+	* @param tableName - Name of table to alter
+	* @param operations - Alteration operations
+	* @param options - Alter options
+	*
+	* @throws {DatabaseError} If table alteration fails
+	*/
+	async alterTable(tableName, operations, _options) {
+		const quotedTable = this.escapeIdentifier(tableName);
+		for (const op of operations) {
+			let query;
+			switch (op.kind) {
+				case "add_column": {
+					let colDef = `${this.escapeIdentifier(op.column.name)} ${op.column.type.toUpperCase()}`;
+					if (op.column.nullable === false) colDef += " NOT NULL";
+					if (op.column.unique) colDef += " UNIQUE";
+					if (op.column.default !== void 0) {
+						const defaultVal = typeof op.column.default === "object" && op.column.default !== null && "sql" in op.column.default ? op.column.default.sql : typeof op.column.default === "string" ? `'${op.column.default}'` : String(op.column.default);
+						colDef += ` DEFAULT ${defaultVal}`;
+					}
+					query = `ALTER TABLE ${quotedTable} ADD COLUMN ${colDef}`;
+					break;
+				}
+				case "drop_column": {
+					const cascade = op.cascade ? " CASCADE" : "";
+					query = `ALTER TABLE ${quotedTable} DROP COLUMN ${this.escapeIdentifier(op.columnName)}${cascade}`;
+					break;
+				}
+				case "rename_column":
+					query = `ALTER TABLE ${quotedTable} RENAME COLUMN ${this.escapeIdentifier(op.from)} TO ${this.escapeIdentifier(op.to)}`;
+					break;
+				case "modify_column":
+					query = `ALTER TABLE ${quotedTable} ALTER COLUMN ${this.escapeIdentifier(op.column.name)} TYPE ${op.column.type.toUpperCase()}`;
+					break;
+				case "add_constraint": {
+					const colList = (op.constraint.columns ?? []).map((c) => this.escapeIdentifier(c)).join(", ");
+					if (op.constraint.type === "check" && op.constraint.expression) query = `ALTER TABLE ${quotedTable} ADD CONSTRAINT ${this.escapeIdentifier(op.constraint.name)} CHECK (${op.constraint.expression})`;
+					else query = `ALTER TABLE ${quotedTable} ADD CONSTRAINT ${this.escapeIdentifier(op.constraint.name)} ${op.constraint.type.toUpperCase()} (${colList})`;
+					break;
+				}
+				case "drop_constraint": {
+					const cascadeConstraint = op.cascade ? " CASCADE" : "";
+					query = `ALTER TABLE ${quotedTable} DROP CONSTRAINT ${this.escapeIdentifier(op.constraintName)}${cascadeConstraint}`;
+					break;
+				}
+				default: throw this.createDatabaseError("query", `Unsupported alter table operation: ${op.kind}`, void 0);
+			}
+			try {
+				await this.executeQuery(query);
+			} catch (error) {
+				throw this.handleQueryError(error, "alterTable", tableName);
+			}
+		}
+	}
+	/**
+	* Check if a table exists in the database.
+	*
+	* @remarks
+	* Uses dialect-specific information schema queries to check table existence.
+	* This is useful for development mode auto-sync to determine whether to
+	* CREATE or DROP/CREATE tables.
+	*
+	* @param tableName - Name of table to check
+	* @param schema - Optional schema name (defaults to 'public' for PostgreSQL)
+	* @returns True if table exists, false otherwise
+	*
+	* @throws {DatabaseError} If query fails
+	*
+	* @example
+	* ```typescript
+	* const exists = await adapter.tableExists('users');
+	* if (exists) {
+	*   await adapter.dropTable('users');
+	* }
+	* await adapter.createTable(userTableDef);
+	* ```
+	*/
+	async tableExists(tableName, schema) {
+		try {
+			let sql;
+			const params = [];
+			switch (this.dialect) {
+				case "postgresql":
+					sql = `
             SELECT EXISTS (
               SELECT FROM information_schema.tables
               WHERE table_schema = COALESCE($1, (
@@ -1760,520 +1868,487 @@ var DrizzleAdapter = class {
               AND table_name = $2
             ) as exists
           `;
-          params.push(schema ?? null, tableName);
-          break;
-        case "mysql":
-          sql6 = `
+					params.push(schema ?? null, tableName);
+					break;
+				case "mysql":
+					sql = `
             SELECT COUNT(*) as count
             FROM information_schema.tables
             WHERE table_schema = DATABASE()
             AND table_name = ?
           `;
-          params.push(tableName);
-          break;
-        case "sqlite":
-          sql6 = `
+					params.push(tableName);
+					break;
+				case "sqlite":
+					sql = `
             SELECT COUNT(*) as count
             FROM sqlite_master
             WHERE type = 'table'
             AND name = ?
           `;
-          params.push(tableName);
-          break;
-        default:
-          throw this.createDatabaseError(
-            "query",
-            `tableExists not implemented for dialect: ${String(this.dialect)}`,
-            void 0
-          );
-      }
-      const results = await this.executeQuery(
-        sql6,
-        params
-      );
-      if (results.length === 0) {
-        return false;
-      }
-      const row = results[0];
-      if ("exists" in row) {
-        return row.exists === true || row.exists === "t" || row.exists === 1;
-      }
-      if ("count" in row) {
-        return Number(row.count) > 0;
-      }
-      return false;
-    } catch (error) {
-      throw this.handleQueryError(error, "tableExists", tableName);
-    }
-  }
-  /**
-   * Get list of all tables in the database.
-   *
-   * @remarks
-   * Uses dialect-specific information schema queries to list tables.
-   * Useful for detecting orphaned tables or validating schema state.
-   *
-   * @param schema - Optional schema name (defaults to 'public' for PostgreSQL)
-   * @returns Array of table names
-   *
-   * @throws {DatabaseError} If query fails
-   */
-  async listTables(schema) {
-    try {
-      let sql6;
-      const params = [];
-      switch (this.dialect) {
-        case "postgresql":
-          sql6 = `
+					params.push(tableName);
+					break;
+				default: throw this.createDatabaseError("query", `tableExists not implemented for dialect: ${String(this.dialect)}`, void 0);
+			}
+			const results = await this.executeQuery(sql, params);
+			if (results.length === 0) return false;
+			const row = results[0];
+			if ("exists" in row) return row.exists === true || row.exists === "t" || row.exists === 1;
+			if ("count" in row) return Number(row.count) > 0;
+			return false;
+		} catch (error) {
+			throw this.handleQueryError(error, "tableExists", tableName);
+		}
+	}
+	/**
+	* Get list of all tables in the database.
+	*
+	* @remarks
+	* Uses dialect-specific information schema queries to list tables.
+	* Useful for detecting orphaned tables or validating schema state.
+	*
+	* @param schema - Optional schema name (defaults to 'public' for PostgreSQL)
+	* @returns Array of table names
+	*
+	* @throws {DatabaseError} If query fails
+	*/
+	async listTables(schema) {
+		try {
+			let sql;
+			const params = [];
+			switch (this.dialect) {
+				case "postgresql":
+					sql = `
             SELECT table_name
             FROM information_schema.tables
             WHERE table_schema = $1
             AND table_type = 'BASE TABLE'
             ORDER BY table_name
           `;
-          params.push(schema ?? "public");
-          break;
-        case "mysql":
-          sql6 = `
+					params.push(schema ?? "public");
+					break;
+				case "mysql":
+					sql = `
             SELECT table_name AS table_name
             FROM information_schema.tables
             WHERE table_schema = DATABASE()
             AND table_type = 'BASE TABLE'
             ORDER BY table_name
           `;
-          break;
-        case "sqlite":
-          sql6 = `
+					break;
+				case "sqlite":
+					sql = `
             SELECT name as table_name
             FROM sqlite_master
             WHERE type = 'table'
             AND name NOT LIKE 'sqlite_%'
             ORDER BY name
           `;
-          break;
-        default:
-          throw this.createDatabaseError(
-            "query",
-            `listTables not implemented for dialect: ${String(this.dialect)}`,
-            void 0
-          );
-      }
-      const results = await this.executeQuery(
-        sql6,
-        params
-      );
-      return results.map((row) => row.table_name);
-    } catch (error) {
-      throw this.handleQueryError(error, "listTables", "");
-    }
-  }
-  // ============================================================
-  // Protected Utilities
-  // ============================================================
-  // Old raw SQL query builders (buildSelectQuery, buildInsertQuery, buildUpdateQuery,
-  // buildDeleteQuery, buildUpsertQuery, buildWhereClause, buildPlaceholder,
-  // buildPlaceholders) have been removed. CRUD methods now use Drizzle query API
-  // via the TableResolver set during boot. See drizzle-where.ts for where clause
-  // translation.
-  // NOTE: The following content up to escapeIdentifier has been removed.
-  // If you're looking for the old query builder methods, see git history
-  // (commit before "refactor: remove dead SQL builder code").
-  /**
-   * Escape a table or column identifier.
-   *
-   * @remarks
-   * Default uses double quotes (SQL standard).
-   * MySQL adapter should override to use backticks.
-   *
-   * @param identifier - Identifier to escape
-   * @returns Escaped identifier
-   *
-   * @protected
-   */
-  escapeIdentifier(identifier) {
-    return `"${identifier.replace(/"/g, '""')}"`;
-  }
-  /**
-   * Create a DatabaseError with proper error kind classification.
-   *
-   * @remarks
-   * Protected helper for subclasses to create consistent errors.
-   * Subclasses can override to add dialect-specific error classification.
-   *
-   * @param kind - Error kind
-   * @param message - Error message
-   * @param cause - Original error
-   * @returns DatabaseError instance
-   *
-   * @protected
-   */
-  createDatabaseError(kind, message, cause) {
-    return createDatabaseError({
-      kind,
-      message,
-      cause
-    });
-  }
-  /**
-   * Helper to create transaction context CRUD forwarding methods.
-   *
-   * @param txDb - Thunk returning the transaction-bound Drizzle executor
-   * @returns Object providing forwarded CRUD and getDrizzle methods
-   *
-   * @protected
-   */
-  createTransactionForwarders(txDb) {
-    return createTransactionForwarders(this, txDb);
-  }
-  /**
-   * The Drizzle handles one transaction hands out; see
-   * `transactionDrizzleHandles`. `build` makes an instance on the
-   * transaction's own connection, with the relations config when given one.
-   *
-   * @protected
-   */
-  transactionDrizzleHandles(build) {
-    return transactionDrizzleHandles(build);
-  }
-  /**
-   * A transaction context's `update`, for each adapter to bind.
-   *
-   * Not forwarded to the pooled `update` the way `select` and `delete` are:
-   * that one goes through the Drizzle query builder, which writes the columns
-   * the runtime MODEL declares, and a transaction's update must reach the
-   * columns the physical TABLE has — the localization transition window
-   * writes a column the model has already moved to a companion table that
-   * does not exist yet. The INSERT half of every transaction context already
-   * builds its own statement for that reason; `update-statement.ts` is the
-   * UPDATE half, spelled once for the three adapters, and this runs it: on
-   * the transaction executor, classified with the operation and table named
-   * as the pooled `update` classifies its failures, and read back through
-   * `select` on the same executor when the caller asked for rows.
-   *
-   * That read is by the rows' IDENTITY where the dialect can report it: on
-   * PostgreSQL and SQLite the statement carries `RETURNING <primary key>`, and
-   * the read-back asks for exactly those rows — so a row another transaction
-   * adds under the same predicate meanwhile is not among them, and an update
-   * whose own write falsifies its predicate still reads its rows back. MySQL
-   * has no RETURNING, so there the read re-runs the predicate, as the pooled
-   * `update` always has on that dialect; a table with no primary key in its
-   * model reads back the same way.
-   *
-   * @param txDb - thunk returning the transaction-bound Drizzle instance
-   * @param run - how this dialect runs a statement on that instance, and the
-   *   rows it returns when the statement carries RETURNING: better-sqlite3
-   *   answers synchronously, the pooled drivers do not
-   * @param bindUnmodeled - how a value binds when the model declares no
-   *   column for it; a declared column binds through its own encoder
-   * @returns the context's `update` method
-   */
-  transactionUpdate(txDb, run, bindUnmodeled) {
-    return async (table, data, where, options) => {
-      const wantsRows = this.updateReturnsRows(options?.returning);
-      const tableObj = this.resolvedTableObject(table);
-      const identity = wantsRows && this.getCapabilities().supportsReturning ? this.identityColumns(tableObj) : [];
-      let reported;
-      try {
-        reported = await run(
-          this.buildTransactionUpdate(tableObj, table, data, where, {
-            bindUnmodeled,
-            returning: identity.map((key) => drizzleOrm.sql`${drizzleOrm.sql.identifier(key.sqlName)}`)
-          }),
-          identity.length > 0
-        );
-      } catch (error) {
-        throw this.handleQueryError(error, "update", table);
-      }
-      if (!wantsRows) return [];
-      if (identity.length === 0 || !Array.isArray(reported)) {
-        return this.select(table, { where }, txDb());
-      }
-      const rows = [];
-      for (let at = 0; at < reported.length; at += IDENTITY_READ_BACK_CHUNK) {
-        rows.push(
-          ...await this.select(
-            table,
-            {
-              where: rowsByIdentity(
-                identity,
-                reported.slice(at, at + IDENTITY_READ_BACK_CHUNK)
-              )
-            },
-            txDb()
-          )
-        );
-      }
-      return rows;
-    };
-  }
-  /**
-   * The columns that identify a row of this table, under both spellings: the
-   * SQL name RETURNING reports and the Drizzle property name the query
-   * builder's WHERE is addressed by. Columns flagged primary first; failing
-   * that, the table-level primary key the dialect's table config carries
-   * (`primaryKey({ columns })` leaves each column's flag false), which each
-   * adapter reads through its own dialect. Empty when the model declares
-   * neither, and the read-back falls back to the caller's predicate.
-   */
-  identityColumns(tableObj) {
-    const columns = Object.entries(drizzleOrm.getColumns(tableObj));
-    const flagged = columns.filter(([, c]) => c.primary === true);
-    const members = flagged.length > 0 ? flagged : columns.filter(
-      ([, c]) => this.compositePrimaryKey(tableObj).includes(c)
-    );
-    return members.flatMap(
-      ([jsName, c]) => typeof c.name === "string" ? [{ jsName, sqlName: c.name }] : []
-    );
-  }
-  /**
-   * How a value binds to a column the model does not declare, on a driver
-   * that binds scalars, dates and binary natively: a structured value goes
-   * as JSON text, since what node-postgres and mysql2 make of a bare object
-   * or array is not JSON. For the adapters to hand `transactionUpdate`.
-   */
-  bindUnmodeledStructuredAsJson(value) {
-    return bindStructuredAsJson(value);
-  }
-  /**
-   * Refuse an upsert target every dialect would not answer alike: a conflict
-   * column named twice, which SQLite rejects as no constraint's target and
-   * MySQL would accept; and, when nothing is to be updated, a conflict column
-   * left for the database to fill, since the row that stands is then read
-   * back by a value the caller never gave. Shared with the dialects that
-   * override `upsert`, so the refusals are one rule.
-   */
-  assertUpsertTarget(table, data, options, keepExisting) {
-    const columns = options.conflictColumns;
-    if (new Set(columns).size !== columns.length) {
-      throw createDatabaseError({
-        kind: "query",
-        message: `upsert on ${table} names a conflict column more than once (${columns.join(", ")}).`
-      });
-    }
-    if (keepExisting && columns.some((column) => data[column] === void 0)) {
-      throw createDatabaseError({
-        kind: "query",
-        message: `upsert on ${table} needs a value for every conflict column (${columns.join(", ")}).`
-      });
-    }
-  }
-  /**
-   * The columns of a table-level `primaryKey({ columns })`, as the dialect's
-   * table config reports them. The base class cannot read that config without
-   * naming a dialect, so each adapter answers for its own; a dialect that does
-   * not answer reports none.
-   */
-  compositePrimaryKey(_tableObj) {
-    return [];
-  }
-  /** The registered table object, or the error every CRUD method throws without one. */
-  resolvedTableObject(table) {
-    const tableObj = this.getTableObject(table);
-    if (!tableObj || typeof tableObj !== "object") {
-      throw this.createDatabaseError(
-        "query",
-        `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
-        void 0
-      );
-    }
-    return tableObj;
-  }
-  /**
-   * The statement `transactionUpdate` runs.
-   *
-   * @throws when nothing would be written — every key `undefined`, or none at
-   *   all. The query builder refused that too ("No values to set"), and a
-   *   patch that names nothing is a caller's mistake rather than a write of
-   *   nothing.
-   */
-  buildTransactionUpdate(tableObj, table, data, where, binding) {
-    const statement = buildUpdateStatement({
-      tableObj,
-      data,
-      where,
-      bindUnmodeled: binding.bindUnmodeled,
-      returning: binding.returning
-    });
-    if (!statement) {
-      throw this.createDatabaseError(
-        "query",
-        `No values to set: the update of "${table}" names no column with a defined value.`,
-        void 0
-      );
-    }
-    return statement;
-  }
-  /**
-   * Whether a transaction's `update` reads the rows it changed back: the
-   * caller named columns, or `*`. An empty list, like no option at all, asks
-   * for nothing and `update` answers `[]`, as it always has. The rows come
-   * from a read of the update's own WHERE on its own transaction, so they are
-   * the model's view of the row, decoded as every read is decoded — which is
-   * what the query-builder update returned for them, and why the named list
-   * selects nothing narrower.
-   */
-  updateReturnsRows(returning) {
-    return returning !== void 0 && !(Array.isArray(returning) && returning.length === 0);
-  }
-  /**
-   * The driver's own error inside `error`: the first in its `cause` chain that
-   * `isDriverError` recognises, or `error` itself when none does.
-   *
-   * A query that runs through Drizzle fails with Drizzle's `DrizzleQueryError`,
-   * whose message is the SQL statement and which carries no driver code; the
-   * driver's error, the only object that knows what actually went wrong, is
-   * its `cause`. A dialect's {@link classifyError} classifies from what this
-   * returns, so a failure reads the same whether or not Drizzle wrapped it.
-   *
-   * The walk is bounded, because an error chain can be made cyclic and a
-   * classifier that can hang is worse than one that gives up. Falling back to
-   * `error` keeps an error that carries no code anywhere classified as before.
-   *
-   * @param error - The error as it was caught
-   * @param isDriverError - Whether a link in the chain is the driver's error
-   * @returns The driver's error, or `error` when no link is
-   */
-  driverErrorIn(error, isDriverError) {
-    let cursor = error;
-    for (let depth = 0; depth < 10; depth++) {
-      if (cursor === null || typeof cursor !== "object") break;
-      const candidate = cursor;
-      if (isDriverError(candidate)) return candidate;
-      cursor = candidate.cause;
-    }
-    return error ?? {};
-  }
-  /**
-   * Classify an error into a DatabaseError.
-   *
-   * @remarks
-   * Subclasses can override this method to add dialect-specific error code classification.
-   *
-   * @param error - Original error
-   * @param sql - SQL statement that caused the error (optional)
-   * @returns DatabaseError instance
-   *
-   * @protected
-   */
-  classifyError(error, sql6) {
-    if (isDatabaseError(error)) {
-      return error;
-    }
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return this.createDatabaseError(
-      "query",
-      sql6 ? `Query failed: ${errorMessage}` : errorMessage,
-      error instanceof Error ? error : void 0
-    );
-  }
-  /**
-   * Handle query errors and convert to DatabaseError.
-   *
-   * @remarks
-   * Protected helper for consistent error handling across CRUD operations.
-   * Delegates to `classifyError` and attaches operation and table context if not present.
-   * Subclasses override `classifyError` to provide dialect-specific error code classification.
-   *
-   * @param error - Original error
-   * @param operation - Operation that failed
-   * @param table - Table name
-   * @returns DatabaseError instance
-   *
-   * @protected
-   */
-  handleQueryError(error, operation, table) {
-    const dbError = this.classifyError(error);
-    const context = `${operation} operation failed on table '${table}'`;
-    if (!dbError.message.includes(context)) {
-      dbError.message = `${context}: ${dbError.message}`;
-    }
-    if (!dbError.table) {
-      dbError.table = table;
-    }
-    return dbError;
-  }
+					break;
+				default: throw this.createDatabaseError("query", `listTables not implemented for dialect: ${String(this.dialect)}`, void 0);
+			}
+			return (await this.executeQuery(sql, params)).map((row) => row.table_name);
+		} catch (error) {
+			throw this.handleQueryError(error, "listTables", "");
+		}
+	}
+	/**
+	* Escape a table or column identifier.
+	*
+	* @remarks
+	* Default uses double quotes (SQL standard).
+	* MySQL adapter should override to use backticks.
+	*
+	* @param identifier - Identifier to escape
+	* @returns Escaped identifier
+	*
+	* @protected
+	*/
+	escapeIdentifier(identifier) {
+		return `"${identifier.replace(/"/g, "\"\"")}"`;
+	}
+	/**
+	* Create a DatabaseError with proper error kind classification.
+	*
+	* @remarks
+	* Protected helper for subclasses to create consistent errors.
+	* Subclasses can override to add dialect-specific error classification.
+	*
+	* @param kind - Error kind
+	* @param message - Error message
+	* @param cause - Original error
+	* @returns DatabaseError instance
+	*
+	* @protected
+	*/
+	createDatabaseError(kind, message, cause) {
+		return require_types.createDatabaseError({
+			kind,
+			message,
+			cause
+		});
+	}
+	/**
+	* Helper to create transaction context CRUD forwarding methods.
+	*
+	* @param txDb - Thunk returning the transaction-bound Drizzle executor
+	* @returns Object providing forwarded CRUD and getDrizzle methods
+	*
+	* @protected
+	*/
+	createTransactionForwarders(txDb) {
+		return createTransactionForwarders(this, txDb);
+	}
+	/**
+	* The Drizzle handles one transaction hands out; see
+	* `transactionDrizzleHandles`. `build` makes an instance on the
+	* transaction's own connection, with the relations config when given one.
+	*
+	* @protected
+	*/
+	transactionDrizzleHandles(build) {
+		return transactionDrizzleHandles(build);
+	}
+	/**
+	* A transaction context's `update`, for each adapter to bind.
+	*
+	* Not forwarded to the pooled `update` the way `select` and `delete` are:
+	* that one goes through the Drizzle query builder, which writes the columns
+	* the runtime MODEL declares, and a transaction's update must reach the
+	* columns the physical TABLE has — the localization transition window
+	* writes a column the model has already moved to a companion table that
+	* does not exist yet. The INSERT half of every transaction context already
+	* builds its own statement for that reason; `update-statement.ts` is the
+	* UPDATE half, spelled once for the three adapters, and this runs it: on
+	* the transaction executor, classified with the operation and table named
+	* as the pooled `update` classifies its failures, and read back through
+	* `select` on the same executor when the caller asked for rows.
+	*
+	* That read is by the rows' IDENTITY where the dialect can report it: on
+	* PostgreSQL and SQLite the statement carries `RETURNING <primary key>`, and
+	* the read-back asks for exactly those rows — so a row another transaction
+	* adds under the same predicate meanwhile is not among them, and an update
+	* whose own write falsifies its predicate still reads its rows back. MySQL
+	* has no RETURNING, so there the read re-runs the predicate, as the pooled
+	* `update` always has on that dialect; a table with no primary key in its
+	* model reads back the same way.
+	*
+	* @param txDb - thunk returning the transaction-bound Drizzle instance
+	* @param run - how this dialect runs a statement on that instance, and the
+	*   rows it returns when the statement carries RETURNING: better-sqlite3
+	*   answers synchronously, the pooled drivers do not
+	* @param bindUnmodeled - how a value binds when the model declares no
+	*   column for it; a declared column binds through its own encoder
+	* @returns the context's `update` method
+	*/
+	transactionUpdate(txDb, run, bindUnmodeled) {
+		return async (table, data, where, options) => {
+			const wantsRows = this.updateReturnsRows(options?.returning);
+			const tableObj = this.resolvedTableObject(table);
+			const identity = wantsRows && this.getCapabilities().supportsReturning ? this.identityColumns(tableObj) : [];
+			let reported;
+			try {
+				reported = await run(this.buildTransactionUpdate(tableObj, table, data, where, {
+					bindUnmodeled,
+					returning: identity.map((key) => drizzle_orm.sql`${drizzle_orm.sql.identifier(key.sqlName)}`)
+				}), identity.length > 0);
+			} catch (error) {
+				throw this.handleQueryError(error, "update", table);
+			}
+			if (!wantsRows) return [];
+			if (identity.length === 0 || !Array.isArray(reported)) return this.select(table, { where }, txDb());
+			const rows = [];
+			for (let at = 0; at < reported.length; at += IDENTITY_READ_BACK_CHUNK) rows.push(...await this.select(table, { where: rowsByIdentity(identity, reported.slice(at, at + IDENTITY_READ_BACK_CHUNK)) }, txDb()));
+			return rows;
+		};
+	}
+	/**
+	* The columns that identify a row of this table, under both spellings: the
+	* SQL name RETURNING reports and the Drizzle property name the query
+	* builder's WHERE is addressed by. Columns flagged primary first; failing
+	* that, the table-level primary key the dialect's table config carries
+	* (`primaryKey({ columns })` leaves each column's flag false), which each
+	* adapter reads through its own dialect. Empty when the model declares
+	* neither, and the read-back falls back to the caller's predicate.
+	*/
+	identityColumns(tableObj) {
+		const columns = Object.entries((0, drizzle_orm.getColumns)(tableObj));
+		const flagged = columns.filter(([, c]) => c.primary === true);
+		return (flagged.length > 0 ? flagged : columns.filter(([, c]) => this.compositePrimaryKey(tableObj).includes(c))).flatMap(([jsName, c]) => typeof c.name === "string" ? [{
+			jsName,
+			sqlName: c.name
+		}] : []);
+	}
+	/**
+	* How a value binds to a column the model does not declare, on a driver
+	* that binds scalars, dates and binary natively: a structured value goes
+	* as JSON text, since what node-postgres and mysql2 make of a bare object
+	* or array is not JSON. For the adapters to hand `transactionUpdate`.
+	*/
+	bindUnmodeledStructuredAsJson(value) {
+		return bindStructuredAsJson(value);
+	}
+	/**
+	* Refuse an upsert target every dialect would not answer alike: a conflict
+	* column named twice, which SQLite rejects as no constraint's target and
+	* MySQL would accept; and, when nothing is to be updated, a conflict column
+	* left for the database to fill, since the row that stands is then read
+	* back by a value the caller never gave. Shared with the dialects that
+	* override `upsert`, so the refusals are one rule.
+	*/
+	assertUpsertTarget(table, data, options, keepExisting) {
+		const columns = options.conflictColumns;
+		if (new Set(columns).size !== columns.length) throw require_types.createDatabaseError({
+			kind: "query",
+			message: `upsert on ${table} names a conflict column more than once (${columns.join(", ")}).`
+		});
+		if (keepExisting && columns.some((column) => data[column] === void 0)) throw require_types.createDatabaseError({
+			kind: "query",
+			message: `upsert on ${table} needs a value for every conflict column (${columns.join(", ")}).`
+		});
+	}
+	/**
+	* The columns of a table-level `primaryKey({ columns })`, as the dialect's
+	* table config reports them. The base class cannot read that config without
+	* naming a dialect, so each adapter answers for its own; a dialect that does
+	* not answer reports none.
+	*/
+	compositePrimaryKey(_tableObj) {
+		return [];
+	}
+	/** The registered table object, or the error every CRUD method throws without one. */
+	resolvedTableObject(table) {
+		const tableObj = this.getTableObject(table);
+		if (!tableObj || typeof tableObj !== "object") throw this.createDatabaseError("query", `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`, void 0);
+		return tableObj;
+	}
+	/**
+	* The statement `transactionUpdate` runs.
+	*
+	* @throws when nothing would be written — every key `undefined`, or none at
+	*   all. The query builder refused that too ("No values to set"), and a
+	*   patch that names nothing is a caller's mistake rather than a write of
+	*   nothing.
+	*/
+	buildTransactionUpdate(tableObj, table, data, where, binding) {
+		const statement = buildUpdateStatement({
+			table,
+			tableObj,
+			data,
+			where,
+			bindUnmodeled: binding.bindUnmodeled,
+			returning: binding.returning
+		});
+		if (!statement) throw this.createDatabaseError("query", `No values to set: the update of "${table}" names no column with a defined value.`, void 0);
+		return statement;
+	}
+	/**
+	* Whether a transaction's `update` reads the rows it changed back: the
+	* caller named columns, or `*`. An empty list, like no option at all, asks
+	* for nothing and `update` answers `[]`, as it always has. The rows come
+	* from a read of the update's own WHERE on its own transaction, so they are
+	* the model's view of the row, decoded as every read is decoded — which is
+	* what the query-builder update returned for them, and why the named list
+	* selects nothing narrower.
+	*/
+	updateReturnsRows(returning) {
+		return returning !== void 0 && !(Array.isArray(returning) && returning.length === 0);
+	}
+	/**
+	* The driver's own error inside `error`: the first in its `cause` chain that
+	* `isDriverError` recognises, or `error` itself when none does.
+	*
+	* A query that runs through Drizzle fails with Drizzle's `DrizzleQueryError`,
+	* whose message is the SQL statement and which carries no driver code; the
+	* driver's error, the only object that knows what actually went wrong, is
+	* its `cause`. A dialect's {@link classifyError} classifies from what this
+	* returns, so a failure reads the same whether or not Drizzle wrapped it.
+	*
+	* The walk is bounded, because an error chain can be made cyclic and a
+	* classifier that can hang is worse than one that gives up. Falling back to
+	* `error` keeps an error that carries no code anywhere classified as before.
+	*
+	* @param error - The error as it was caught
+	* @param isDriverError - Whether a link in the chain is the driver's error
+	* @returns The driver's error, or `error` when no link is
+	*/
+	driverErrorIn(error, isDriverError) {
+		let cursor = error;
+		for (let depth = 0; depth < 10; depth++) {
+			if (cursor === null || typeof cursor !== "object") break;
+			const candidate = cursor;
+			if (isDriverError(candidate)) return candidate;
+			cursor = candidate.cause;
+		}
+		return error ?? {};
+	}
+	/**
+	* Classify an error into a DatabaseError.
+	*
+	* @remarks
+	* Subclasses can override this method to add dialect-specific error code classification.
+	*
+	* @param error - Original error
+	* @param sql - SQL statement that caused the error (optional)
+	* @returns DatabaseError instance
+	*
+	* @protected
+	*/
+	classifyError(error, sql) {
+		if (require_types.isDatabaseError(error)) return error;
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		return this.createDatabaseError("query", sql ? `Query failed: ${errorMessage}` : errorMessage, error instanceof Error ? error : void 0);
+	}
+	/**
+	* Handle query errors and convert to DatabaseError.
+	*
+	* @remarks
+	* Protected helper for consistent error handling across CRUD operations.
+	* Delegates to `classifyError` and attaches operation and table context if not present.
+	* Subclasses override `classifyError` to provide dialect-specific error code classification.
+	*
+	* @param error - Original error
+	* @param operation - Operation that failed
+	* @param table - Table name
+	* @returns DatabaseError instance
+	*
+	* @protected
+	*/
+	handleQueryError(error, operation, table) {
+		const dbError = this.classifyError(error);
+		const context = `${operation} operation failed on table '${table}'`;
+		if (!dbError.message.includes(context)) dbError.message = `${context}: ${dbError.message}`;
+		if (!dbError.table) dbError.table = table;
+		return dbError;
+	}
 };
-var IDENTITY_READ_BACK_CHUNK = 200;
+/**
+* How many reported rows one read-back statement names. Well under SQLite's
+* expression-depth limit of a thousand and its default variable limit, and
+* under PostgreSQL's parameter limit, with a composite key of several columns.
+*/
+const IDENTITY_READ_BACK_CHUNK = 200;
+/**
+* The predicate that names exactly the rows a statement reported, addressed
+* by the Drizzle property names the where builder resolves: for a single-
+* column key one `IN` over the reported values; for a composite key one `and`
+* of every key column per row, `or`-ed together, so the key is matched as a
+* whole rather than column by column.
+*/
 function rowsByIdentity(identity, rows) {
-  if (identity.length === 1) {
-    const [key] = identity;
-    return {
-      and: [
-        {
-          column: key.jsName,
-          op: "IN",
-          value: rows.map((row) => row[key.sqlName])
-        }
-      ]
-    };
-  }
-  return {
-    or: rows.map(
-      (row) => ({
-        and: identity.map(
-          (key) => ({
-            column: key.jsName,
-            op: "=",
-            value: row[key.sqlName]
-          })
-        )
-      })
-    )
-  };
+	if (identity.length === 1) {
+		const [key] = identity;
+		return { and: [{
+			column: key.jsName,
+			op: "IN",
+			value: rows.map((row) => row[key.sqlName])
+		}] };
+	}
+	return { or: rows.map((row) => ({ and: identity.map((key) => ({
+		column: key.jsName,
+		op: "=",
+		value: row[key.sqlName]
+	})) })) };
 }
-var ALLOWED_DEFAULT_SQL_EXPRESSIONS = /* @__PURE__ */ new Set([
-  "current_timestamp",
-  "now()",
-  "gen_random_uuid()",
-  "uuid_generate_v4()",
-  "current_date",
-  "current_time"
+/**
+* Render a `ColumnDefinition.default` as a SQL fragment
+* for embedding in a `DEFAULT` clause. DDL is not protected by Drizzle's
+* prepared statements — these expressions are concatenated into raw SQL —
+* so we treat the default as untrusted input even though it currently
+* flows from server-side schema definitions: an admin-defined dynamic
+* collection would otherwise turn into RCE-on-DB instead of just CMS
+* admin.
+*
+* Rules:
+*
+*   - **null / number / boolean** → rendered as a SQL literal.
+*   - **string** → quoted; embedded `'` doubled; `;`, `\`, control
+*     characters, and null bytes rejected so they can't break out of
+*     the surrounding quote pair into adjacent DDL.
+*   - **`{ sql: "…" }`** → only the explicit allowlist of named
+*     functions below is honored (case-insensitive). Anything else is
+*     a hard error: the previous code embedded the raw `sql` string
+*     verbatim, which is the SQL injection primitive the audit flagged.
+*/
+const ALLOWED_DEFAULT_SQL_EXPRESSIONS = /* @__PURE__ */ new Set([
+	"current_timestamp",
+	"now()",
+	"gen_random_uuid()",
+	"uuid_generate_v4()",
+	"current_date",
+	"current_time"
 ]);
 function renderDefaultValue(value, columnName) {
-  if (value === null) return "NULL";
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new Error(
-        `DEFAULT for column "${columnName}" must be a finite number (got ${value}).`
-      );
-    }
-    return String(value);
-  }
-  if (typeof value === "boolean") {
-    return value ? "TRUE" : "FALSE";
-  }
-  if (typeof value === "string") {
-    if (/[;\\\n\r\0]/.test(value)) {
-      throw new Error(
-        `DEFAULT string for column "${columnName}" contains characters that are not allowed in DDL (no semicolons, backslashes, control chars, or null bytes).`
-      );
-    }
-    return `'${value.replace(/'/g, "''")}'`;
-  }
-  if (typeof value === "object" && value !== null && "sql" in value) {
-    const raw = value.sql;
-    if (typeof raw !== "string") {
-      throw new Error(
-        `DEFAULT for column "${columnName}" has a { sql } expression that is not a string.`
-      );
-    }
-    const normalized = raw.trim().toLowerCase();
-    if (!ALLOWED_DEFAULT_SQL_EXPRESSIONS.has(normalized)) {
-      throw new Error(
-        `DEFAULT for column "${columnName}" uses a SQL expression "${raw}" that is not on the allowlist. Allowed: ${[...ALLOWED_DEFAULT_SQL_EXPRESSIONS].join(", ")}.`
-      );
-    }
-    return raw.trim();
-  }
-  throw new Error(
-    `DEFAULT for column "${columnName}" has an unsupported type (${typeof value}).`
-  );
+	if (value === null) return "NULL";
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error(`DEFAULT for column "${columnName}" must be a finite number (got ${value}).`);
+		return String(value);
+	}
+	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+	if (typeof value === "string") {
+		if (/[;\\\n\r\0]/.test(value)) throw new Error(`DEFAULT string for column "${columnName}" contains characters that are not allowed in DDL (no semicolons, backslashes, control chars, or null bytes).`);
+		return `'${value.replace(/'/g, "''")}'`;
+	}
+	if (typeof value === "object" && value !== null && "sql" in value) {
+		const raw = value.sql;
+		if (typeof raw !== "string") throw new Error(`DEFAULT for column "${columnName}" has a { sql } expression that is not a string.`);
+		const normalized = raw.trim().toLowerCase();
+		if (!ALLOWED_DEFAULT_SQL_EXPRESSIONS.has(normalized)) throw new Error(`DEFAULT for column "${columnName}" uses a SQL expression "${raw}" that is not on the allowlist. Allowed: ${[...ALLOWED_DEFAULT_SQL_EXPRESSIONS].join(", ")}.`);
+		return raw.trim();
+	}
+	throw new Error(`DEFAULT for column "${columnName}" has an unsupported type (${typeof value}).`);
 }
-
 // src/index.ts
-var version = "0.1.0";
-
+/**
+* @nextly/adapter-drizzle
+*
+* Shared Drizzle ORM adapter logic for Nextly database adapters.
+* This package provides the base adapter class and utilities used by
+* dialect-specific adapters (PostgreSQL, MySQL, SQLite).
+*
+* @remarks
+* This is the main entry point that exports only the core adapter class.
+* Specialized utilities are available via subpath exports for optimal tree-shaking.
+*
+* ## Subpath Exports
+*
+* **Types:**
+* ```typescript
+* import type {
+*   DatabaseCapabilities,
+*   TransactionContext,
+*   WhereClause,
+*   SelectOptions,
+* } from '@nextly/adapter-drizzle/types';
+* ```
+*
+* **Query Builder:**
+* ```typescript
+* import { QueryBuilder } from '@nextly/adapter-drizzle/query-builder';
+* ```
+*
+* **Migrations:**
+* ```typescript
+* import {
+*   calculateChecksum,
+*   sortMigrations,
+*   migrationHelpers,
+* } from '@nextly/adapter-drizzle/migrations';
+* ```
+*
+* **Schema Utilities:**
+* ```typescript
+* import { schemaUtils } from '@nextly/adapter-drizzle/schema';
+* ```
+*
+* @packageDocumentation
+*/
+/**
+* Package version
+* @public
+*/
+const version = "0.1.0";
 exports.DrizzleAdapter = DrizzleAdapter;
 exports.version = version;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map