@happyvertical/sql 0.102.2 → 0.102.3

package/dist/chunks/connection-cache-Da5UcY5u.js

@@ -1,1305 +0,0 @@
-import { DatabaseError } from "@happyvertical/utils";
-//#region src/shared/utils.ts
-/**
-* Shared SQL utilities that work in both browser and Node.js environments
-*/
-/**
-* Formats a database error to include its useful non-secret details.
-*
-* Database drivers often include additional properties beyond just `message`:
-* - PostgreSQL: code, detail, hint, severity
-* - DuckDB: may include additional context
-* - SQLite/LibSQL: may include errno, code
-*
-* This function extracts an allowlist of driver properties and redacts
-* credential-shaped text. When parameter values are available, prefer
-* {@link wrapDatabaseError}; it also redacts values echoed by the driver.
-*
-* @param error - The caught error object
-* @returns Formatted error string with all available error details
-*/
-function formatDbError(error) {
-	return formatDbErrorWithSecrets(error, []);
-}
-var DRIVER_ERROR_FIELDS = [
-	"code",
-	"detail",
-	"hint",
-	"severity",
-	"errno"
-];
-var SENSITIVE_CONTEXT_KEY = /^(?:args?|parameters?|params?|queries|query|sql|values?)$/i;
-var CREDENTIAL_KEY_PART = /^(?:credential|credentials|passphrase|password|pwd|secret|token)$/i;
-var CREDENTIAL_KEY_QUALIFIER = /^(?:access|api|auth|client|private|refresh|service|signing)$/i;
-var DATABASE_USER_KEY = /^(?:user(?:name)?|(?:database|db|pg|postgres|postgresql)[._-]?user(?:name)?)$/i;
-var DATABASE_URL_USERINFO = /\b((?:https?|libsql|postgres|postgresql):\/\/)[^\s/@]+@/giu;
-var DATABASE_URL = /\b(?:https?|libsql|postgres|postgresql):\/\/[^\s"'`<>()]+/giu;
-var CREDENTIAL_ASSIGNMENT = /(?<![\p{L}\p{N}_-])(["']?)([\p{L}\p{N}_.-]+(?: key)?)\1(\s*[:=]\s*)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s,;}\]]+)/giu;
-var BEARER_CREDENTIAL = /\bbearer\s+[^\s,;]+/giu;
-var SQL_NUMERIC_LITERAL = /(?<![\p{L}\p{N}_$])[-+]?(?:\d(?:_?\d)*(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:e[-+]?\d(?:_?\d)*)?(?![\p{L}\p{N}_$])/giu;
-var POSTGRES_KEY_VALUE = /(\bKey\s*\([^\r\n)]*\)\s*=\s*\()([\s\S]*?)(\)\s*(?:already exists|is duplicated)\b)/giu;
-var POSTGRES_FAILING_ROW = /(\bFailing row contains\s*\()([\s\S]*)(\)(?:\.|$))/giu;
-var CAST_INPUT_VALUE = /(\bwith value\s+)([\s\S]*?)(\s+(?:can't|cannot)\s+be cast\b)/giu;
-function isCredentialKey(key) {
-	if (DATABASE_USER_KEY.test(key)) return true;
-	const parts = key.replace(/([\p{Ll}\p{N}])(\p{Lu})/gu, "$1 $2").split(/[^\p{L}\p{N}]+/u).filter(Boolean);
-	if (parts.length === 1 && /^(?:auth|credential|key|pass)$/i.test(parts[0])) return true;
-	if (parts.some((part) => CREDENTIAL_KEY_PART.test(part))) return true;
-	return parts.some((part, index) => /^(?:key|auth)$/i.test(part) && index > 0 && CREDENTIAL_KEY_QUALIFIER.test(parts[index - 1]));
-}
-function toDriverError(error) {
-	return error && (typeof error === "object" || typeof error === "function") ? error : {};
-}
-function redactUrl(value) {
-	try {
-		const url = new URL(value);
-		if (url.username) url.username = "[redacted]";
-		if (url.password) url.password = "[redacted]";
-		for (const key of url.searchParams.keys()) if (isCredentialKey(key)) url.searchParams.set(key, "[redacted]");
-		if (url.hash) url.hash = "[redacted]";
-		return url.toString();
-	} catch {
-		return value.replace(/\/\/[^/@\s]+@/u, "//[redacted]@");
-	}
-}
-function redactKnownValue(input, value) {
-	if (!value || !input.includes(value)) return input;
-	if (!/^[\p{L}\p{N}_-]+$/u.test(value)) return input.split(value).join("[redacted]");
-	const identifierCharacter = /^[\p{L}\p{N}_-]$/u;
-	let cursor = 0;
-	let redacted = "";
-	let match = input.indexOf(value);
-	while (match !== -1) {
-		const end = match + value.length;
-		const before = [...input.slice(Math.max(0, match - 2), match)].at(-1);
-		const afterCodePoint = input.codePointAt(end);
-		const after = afterCodePoint === void 0 ? void 0 : String.fromCodePoint(afterCodePoint);
-		const bounded = (!before || !identifierCharacter.test(before)) && (!after || !identifierCharacter.test(after));
-		redacted += input.slice(cursor, match);
-		redacted += bounded ? "[redacted]" : value;
-		cursor = end;
-		match = input.indexOf(value, cursor);
-	}
-	return redacted + input.slice(cursor);
-}
-function redactDatabaseErrorText(value, knownSecrets) {
-	let redacted = value.replace(DATABASE_URL_USERINFO, "$1[redacted]@").replace(DATABASE_URL, redactUrl).replace(CREDENTIAL_ASSIGNMENT, (assignment, quote, key, delimiter) => isCredentialKey(key) ? `${quote}${key}${quote}${delimiter}[redacted]` : assignment).replace(BEARER_CREDENTIAL, "Bearer [redacted]").replace(POSTGRES_KEY_VALUE, (_match, prefix, _value, suffix) => `${prefix}[redacted]${suffix}`).replace(POSTGRES_FAILING_ROW, (_match, prefix, _value, suffix) => `${prefix}[redacted]${suffix}`).replace(CAST_INPUT_VALUE, (_match, prefix, _value, suffix) => `${prefix}[redacted]${suffix}`);
-	for (const secret of [...new Set(knownSecrets)].sort((left, right) => right.length - left.length)) redacted = redactKnownValue(redacted, secret);
-	return redacted;
-}
-function collectSensitiveValues(value, output, seen) {
-	if (typeof value === "string") {
-		if (value) output.add(value);
-		return;
-	}
-	if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
-		output.add(String(value));
-		return;
-	}
-	if (!value || typeof value !== "object" || seen.has(value)) return;
-	seen.add(value);
-	try {
-		if (value instanceof Date) {
-			output.add(value.toISOString());
-			return;
-		}
-		if (ArrayBuffer.isView(value)) {
-			const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-			if (bytes.length > 0) {
-				const hex = [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-				output.add([...bytes].join(","));
-				output.add(hex);
-				output.add(`\\x${hex}`);
-				output.add(`\\x${hex.toUpperCase()}`);
-				output.add(`<Buffer ${[...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join(" ")}>`);
-				if (typeof Buffer !== "undefined") output.add(Buffer.from(bytes).toString("base64"));
-			}
-			return;
-		}
-	} catch {
-		return;
-	}
-	try {
-		const serialized = JSON.stringify(value);
-		if (serialized && serialized !== "{}" && serialized !== "[]") output.add(serialized);
-	} catch {}
-	let descriptors;
-	try {
-		descriptors = Object.getOwnPropertyDescriptors(value);
-	} catch {
-		return;
-	}
-	for (const [key, descriptor] of Object.entries(descriptors)) if (key !== "length" && "value" in descriptor) collectSensitiveValues(descriptor.value, output, seen);
-}
-function collectSqlLiterals(sql, output) {
-	if (sql) output.add(sql);
-	for (const match of sql.matchAll(/'((?:''|[^'])*)'/gu)) {
-		const literal = match[1].replaceAll("''", "'");
-		if (literal) output.add(literal);
-	}
-	for (const match of sql.matchAll(/\$\$([\s\S]*?)\$\$/gu)) if (match[1]) output.add(match[1]);
-	for (const match of sql.matchAll(/\$([A-Za-z_][A-Za-z0-9_]*)\$([\s\S]*?)\$\1\$/gu)) if (match[2]) output.add(match[2]);
-	for (const match of sql.matchAll(SQL_NUMERIC_LITERAL)) {
-		output.add(match[0]);
-		output.add(match[0].replaceAll("_", ""));
-	}
-}
-function contextSecrets(context) {
-	const output = /* @__PURE__ */ new Set();
-	for (const [key, value] of Object.entries(context)) if (/^(?:args?|parameters?|params?|values?)$/i.test(key)) collectSensitiveValues(value, output, /* @__PURE__ */ new Set());
-	else if (/^(?:queries|query|sql)$/i.test(key) && typeof value === "string") collectSqlLiterals(value, output);
-	return [...output];
-}
-function sanitizeContextValue(value, knownSecrets, seen) {
-	if (typeof value === "string") return redactDatabaseErrorText(value, knownSecrets);
-	if (!value || typeof value !== "object") return value;
-	if (seen.has(value)) return "[circular]";
-	seen.add(value);
-	if (Array.isArray(value)) return value.map((entry) => sanitizeContextValue(entry, knownSecrets, seen));
-	return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, isCredentialKey(key) ? "[redacted]" : sanitizeContextValue(entry, knownSecrets, seen)]));
-}
-function sanitizeDatabaseErrorContext(context, knownSecrets) {
-	return Object.fromEntries(Object.entries(context).map(([key, value]) => [key, SENSITIVE_CONTEXT_KEY.test(key) || isCredentialKey(key) ? "[redacted]" : sanitizeContextValue(value, knownSecrets, /* @__PURE__ */ new WeakSet())]));
-}
-function formatDbErrorWithSecrets(error, knownSecrets) {
-	const dbError = toDriverError(error);
-	const parts = [];
-	if (dbError.message) parts.push(redactDatabaseErrorText(dbError.message, knownSecrets));
-	if (dbError.code) parts.push(`code=${redactDatabaseErrorText(dbError.code, knownSecrets)}`);
-	if (dbError.detail) parts.push(`detail=${redactDatabaseErrorText(dbError.detail, knownSecrets)}`);
-	if (dbError.hint) parts.push(`hint=${redactDatabaseErrorText(dbError.hint, knownSecrets)}`);
-	if (dbError.severity) parts.push(`severity=${redactDatabaseErrorText(dbError.severity, knownSecrets)}`);
-	if (dbError.errno !== void 0) parts.push(`errno=${dbError.errno}`);
-	return parts.length > 0 ? parts.join(", ") : redactDatabaseErrorText(String(error), knownSecrets);
-}
-function safeDatabaseCause(error, knownSecrets) {
-	const dbError = toDriverError(error);
-	const message = dbError.message ? redactDatabaseErrorText(dbError.message, knownSecrets) : formatDbErrorWithSecrets(error, knownSecrets);
-	const cause = new Error(message);
-	cause.name = dbError.name ? redactDatabaseErrorText(dbError.name, knownSecrets) : "DatabaseDriverError";
-	for (const field of DRIVER_ERROR_FIELDS) {
-		const value = dbError[field];
-		if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") Object.defineProperty(cause, field, {
-			configurable: true,
-			enumerable: true,
-			value: typeof value === "string" ? redactDatabaseErrorText(value, knownSecrets) : value,
-			writable: true
-		});
-	}
-	return cause;
-}
-/**
-* Wraps an engine failure in a serializable, secret-safe DatabaseError.
-*
-* Raw SQL and parameter values are replaced in context. The native `cause` is
-* a sanitized driver-error snapshot rather than the original object so normal
-* Error inspection cannot bypass the same redaction applied to messages and
-* JSON serialization.
-*/
-function wrapDatabaseError(message, error, context = {}) {
-	const knownSecrets = contextSecrets(context);
-	const originalError = formatDbErrorWithSecrets(error, knownSecrets);
-	return new DatabaseError(`${message}: ${originalError}`, {
-		...sanitizeDatabaseErrorContext(context, knownSecrets),
-		originalError
-	}, safeDatabaseCause(error, knownSecrets));
-}
-/**
-* Resolves the column list for a multi-row INSERT and rejects batches whose
-* records disagree on it.
-*
-* A batch INSERT emits one column list for the whole statement, so it can only
-* come from the first record. That leaves two ways for a later record to be
-* written wrongly, both of them silent:
-*
-* - Its keys are the same but in a different insertion order. Callers that
-*   bound values with `Object.values(record)` bound them by position, so the
-*   values cross-assigned into each other's columns. Projecting each record
-*   through the returned column list — `keys.map((key) => record[key])` — is
-*   what makes key order irrelevant, and every caller must do it.
-* - Its key set genuinely differs. An extra key has no column to go to and a
-*   missing one has no value, so the record cannot be expressed by this
-*   statement at all. Guessing (dropping the extra, writing NULL for the
-*   missing) is what makes the failure invisible, so this throws instead.
-*
-* A key whose value is `undefined` counts as absent. Adapters that serialize
-* records first drop such keys before this point while the rest pass them
-* through, so comparing raw key lists would make the same batch throw on some
-* adapters and silently write NULL on others. Only the comparison ignores them;
-* the returned column list is untouched, so each adapter keeps its own
-* single-record handling of `undefined`.
-*
-* @param table - Table being inserted into, for error context
-* @param records - Non-empty batch, as the adapter will bind it
-* @returns Column list taken from the first record
-* @throws DatabaseError if any later record's key set differs from the first's
-*/
-function resolveInsertColumns(table, records) {
-	const definedKeys = (record) => new Set(Object.keys(record).filter((key) => record[key] !== void 0));
-	const keys = Object.keys(records[0]);
-	const expected = definedKeys(records[0]);
-	for (let index = 1; index < records.length; index++) {
-		const recordKeys = definedKeys(records[index]);
-		const missing = [...expected].filter((key) => !recordKeys.has(key));
-		const extra = [...recordKeys].filter((key) => !expected.has(key));
-		if (missing.length === 0 && extra.length === 0) continue;
-		const problems = [missing.length > 0 ? `missing ${missing.join(", ")}` : "", extra.length > 0 ? `unexpected ${extra.join(", ")}` : ""].filter(Boolean);
-		throw new DatabaseError(`Batch insert records must all have the same keys; record ${index} has ${problems.join(" and ")} relative to record 0 (${[...expected].join(", ")})`, {
-			table,
-			recordIndex: index,
-			expectedKeys: keys,
-			recordKeys: [...recordKeys],
-			missing,
-			extra,
-			hint: "A batch INSERT writes one column list for every row, taken from the first record, so record 0 defines the columns even when it is the one that looks wrong. A key whose value is undefined counts as absent. Split records with differing keys into separate insert() calls, or fill the gaps explicitly with null."
-		});
-	}
-	return keys;
-}
-/**
-* Map of valid SQL operators for use in WHERE clauses
-*/
-var VALID_OPERATORS = {
-	"=": "=",
-	">": ">",
-	">=": ">=",
-	"<": "<",
-	"<=": "<=",
-	"!=": "!=",
-	like: "LIKE",
-	contains: "CONTAINS",
-	in: "IN",
-	"not in": "NOT IN"
-};
-function isSimpleSqlIdentifier(field) {
-	return /^[a-zA-Z0-9_.]+$/.test(field);
-}
-/**
-* Marks a condition key as caller-authored SQL text.
-*
-* A fixed, non-secret sentinel rather than a random per-process token. A random
-* token has to travel inside the key, which means it reaches every place a key
-* is echoed — error messages, logs, each adapter's `DatabaseError` context — and
-* one disclosure would let a caller mint raw keys for the life of the process.
-* A registry of minted expressions avoids that but is not referentially
-* transparent: it would make `raw('revenue >')` in one query change what the
-* plain key `'revenue >'` means in every other one.
-*
-* The NUL delimiters cannot appear in an identifier or in SQL a developer would
-* write, so the marker never collides with a legitimate key.
-*/
-var RAW_KEY_PREFIX = "\0hv-sql-raw\0";
-/**
-* Marks a WHERE-clause key as SQL expression text rather than an identifier.
-*
-* {@link buildWhere} validates every condition key as a plain identifier. Wrap a
-* key in `raw()` to opt one condition out of that check:
-*
-* ```typescript
-* buildWhere({
-*   status: 'paid',                 // validated as an identifier
-*   [raw('SUM(total) >')]: 100,     // caller-authored SQL, not validated
-* });
-* ```
-*
-* Never build the argument from end-user input. `raw()` is an assertion that
-* the caller, not the request, authored this SQL.
-*
-* The returned key carries a marker, so it is a distinct string from the bare
-* expression: minting `raw('revenue >')` never changes what the plain key
-* `'revenue >'` means anywhere else.
-*
-* The marker is a fixed sentinel, not a secret. It stops an expression key being
-* used by accident — the shape of the key no longer grants raw access, a call to
-* `raw()` does — but a caller that controls a whole key string verbatim,
-* including the NUL-delimited marker, can still reproduce it. Validate at your
-* own trust boundary; do not rely on this as the only barrier against hostile
-* input.
-*
-* Enforcement is at runtime: `WhereClause` keys are plain `string`, so a
-* computed key widens and TypeScript will not reject an unmarked expression key
-* at the call site.
-*
-* A trailing operator is recognised only if it is one of `=`, `!=`, `>`, `>=`,
-* `<`, `<=`, `like`, `contains`, `in`, `not in`. Any other trailing token is
-* treated as part of the expression and `=` is appended, so
-* `raw('name ILIKE')` silently emits `name ILIKE = $1`, which the database then
-* rejects. Fold an unsupported operator into the expression instead:
-* `raw('LOWER(name) like')`.
-*
-* @param expression - SQL field or expression text, optionally ending in a
-*   supported operator (for example `SUM(total) >`)
-* @returns A branded key for use in a {@link WhereClause}
-* @throws If the expression is empty
-*/
-function raw(expression) {
-	const trimmed = unwrapRawKey(expression).key.trim();
-	if (!trimmed) throw new Error("raw() requires a non-empty SQL expression");
-	return `${RAW_KEY_PREFIX}${trimmed}`;
-}
-/**
-* Splits the raw marker off a condition key.
-* @internal
-*/
-function unwrapRawKey(fullKey) {
-	return fullKey.startsWith(RAW_KEY_PREFIX) ? {
-		key: fullKey.slice(12),
-		isRaw: true
-	} : {
-		key: fullKey,
-		isRaw: false
-	};
-}
-function parseConditionKey(fullKey) {
-	const trimmed = fullKey.trim();
-	const lower = trimmed.toLowerCase();
-	for (const operator of [
-		"not in",
-		"contains",
-		"like",
-		"in",
-		"!=",
-		">=",
-		"<=",
-		">",
-		"<",
-		"="
-	]) if (lower.endsWith(` ${operator}`)) return {
-		field: trimmed.slice(0, -(operator.length + 1)).trim(),
-		operator
-	};
-	return {
-		field: trimmed,
-		operator: "="
-	};
-}
-/**
-* Builds a single condition for a WHERE clause
-* @internal
-*/
-var buildCondition = (fullKey, value, currIndex, adapterType) => {
-	const { key, isRaw } = unwrapRawKey(fullKey);
-	const { field, operator } = parseConditionKey(key);
-	if (!isRaw && !isSimpleSqlIdentifier(field)) throw new Error(`Invalid SQL identifier: ${field}. Condition keys must be plain identifiers; wrap developer-authored SQL expressions in raw().`);
-	const sqlOperator = VALID_OPERATORS[operator] || "=";
-	const values = [];
-	let sql;
-	if (sqlOperator === "CONTAINS") {
-		if (!adapterType) throw new Error("CONTAINS requires an adapter type so buildWhere can preserve case-sensitive semantics");
-		if (typeof value !== "string") throw new Error("CONTAINS requires a string value");
-		const placeholder = `$${currIndex.value++}`;
-		sql = `${adapterType === "sqlite" ? "instr" : "strpos"}(${field}, ${placeholder}) > 0`;
-		values.push(value);
-	} else if (value === null) sql = `${field} IS ${sqlOperator === "=" ? "NULL" : "NOT NULL"}`;
-	else if ((sqlOperator === "IN" || sqlOperator === "NOT IN") && Array.isArray(value)) {
-		if (value.length === 0) throw new Error(`${sqlOperator} requires at least one value`);
-		sql = `${field} ${sqlOperator} (${value.map(() => `$${currIndex.value++}`).join(", ")})`;
-		values.push(...value);
-	} else if (value instanceof Date) {
-		if (adapterType === "duckdb" || adapterType === "json") sql = `${field} ${sqlOperator} CAST($${currIndex.value++} AS TIMESTAMP)${sqlOperator === "LIKE" ? " ESCAPE '\\'" : ""}`;
-		else sql = `${field} ${sqlOperator} $${currIndex.value++}${sqlOperator === "LIKE" ? " ESCAPE '\\'" : ""}`;
-		values.push(value.toISOString());
-	} else {
-		sql = `${field} ${sqlOperator} $${currIndex.value++}${sqlOperator === "LIKE" ? " ESCAPE '\\'" : ""}`;
-		values.push(value);
-	}
-	return {
-		sql,
-		values
-	};
-};
-/**
-* Builds a SQL WHERE clause with parameterized values and flexible operators
-*
-* @param where - Conditions as object (AND-only) or 2D array (OR/AND compound)
-* @param startIndex - Starting index for parameter numbering (default: 1)
-* @param adapterType - Database adapter type. Controls Date and `contains`
-*   handling:
-*   - `'duckdb'` / `'json'`: Wraps Date values in `CAST($N AS TIMESTAMP)` to
-*     prevent DuckDB ANY-type inference issues.
-*   - `'sqlite'` / `'postgres'` / `undefined`: Passes ISO strings directly
-*     (these adapters handle ISO timestamp strings natively).
-*   - Required for `contains`, whose case-sensitive literal substring SQL is
-*     emitted with adapter-specific functions.
-*
-* Every condition key is validated as a plain SQL identifier, with or without
-* an operator suffix. To use expression text as a key, wrap it in {@link raw}:
-*
-* ```typescript
-* buildWhere({ [raw('LOWER(status) =')]: 'paid' });
-* ```
-*
-* `raw()` is the only way to reach expression text, so mapping untrusted input
-* into a condition key throws rather than emitting attacker-controlled SQL.
-*
-* @returns Object containing the SQL clause and array of values
-* @throws If a key that is not wrapped in {@link raw} is not a plain identifier
-*
-* @example Basic Usage (Object format - AND-only):
-* ```typescript
-* buildWhere({
-*   'status': 'active',           // equals operator is default
-*   'price >': 100,              // greater than
-*   'stock <=': 5,               // less than or equal
-*   'category in': ['A', 'B'],   // IN clause for arrays
-*   'name like': '%shirt%',      // LIKE pattern; backslash escapes `%` / `_`
-*   'notes contains': '100% off' // literal, case-sensitive substring
-* });
-* ```
-*
-* @example 2D Array Format (OR/AND compound logic):
-* ```typescript
-* // WHERE (status = 'active' AND price > 100) OR (status = 'pending' AND priority = 'high')
-* buildWhere([
-*   [{ status: 'active' }, { 'price >': 100 }],
-*   [{ status: 'pending' }, { priority: 'high' }]
-* ]);
-* ```
-*
-* @example NULL Handling:
-* ```typescript
-* buildWhere({
-*   'deleted_at': null,          // becomes "deleted_at IS NULL"
-*   'updated_at !=': null,       // becomes "updated_at IS NOT NULL"
-*   'status': 'active'           // regular comparison
-* });
-* ```
-*
-* @example Common Patterns:
-* ```typescript
-* // Price range
-* buildWhere({
-*   'price >=': 10,
-*   'price <': 100
-* });
-*
-* // Date filtering
-* buildWhere({
-*   'created_at >': startDate,
-*   'created_at <=': endDate,
-*   'deleted_at': null
-* });
-*
-* // Search with LIKE
-* buildWhere({
-*   'title like': '%search%',
-*   'description like': '%search%',
-*   'status': 'published'
-* });
-*
-* // Multiple values with IN
-* buildWhere({
-*   'role in': ['admin', 'editor'],
-*   'active': true,
-*   'last_login !=': null
-* });
-* ```
-*
-* The function handles:
-* - Standard comparisons (=, >, >=, <, <=, !=)
-* - NULL checks (IS NULL, IS NOT NULL)
-* - IN clauses for arrays
-* - LIKE for pattern matching with an explicit backslash escape character
-* - Case-sensitive literal substring matching with `contains`
-* - Object format: Multiple conditions combined with AND
-* - 2D array format: Inner arrays ANDed, outer array ORed
-*/
-var buildWhere = (where, startIndex = 1, adapterType) => {
-	let sql = "";
-	const values = [];
-	const currIndex = { value: startIndex };
-	if (Array.isArray(where)) {
-		if (where.length === 0) return {
-			sql: "",
-			values: []
-		};
-		const orGroups = [];
-		for (const andGroup of where) {
-			if (!Array.isArray(andGroup) || andGroup.length === 0) continue;
-			const andConditions = [];
-			for (const conditionObj of andGroup) for (const [fullKey, value] of Object.entries(conditionObj)) {
-				const result = buildCondition(fullKey, value, currIndex, adapterType);
-				andConditions.push(result.sql);
-				values.push(...result.values);
-			}
-			if (andConditions.length > 0) orGroups.push(`(${andConditions.join(" AND ")})`);
-		}
-		if (orGroups.length > 0) sql = `WHERE ${orGroups.join(" OR ")}`;
-		return {
-			sql,
-			values
-		};
-	}
-	if (where && Object.keys(where).length > 0) {
-		sql = "WHERE ";
-		for (const [fullKey, value] of Object.entries(where)) {
-			const result = buildCondition(fullKey, value, currIndex, adapterType);
-			if (sql !== "WHERE ") sql += " AND ";
-			sql += result.sql;
-			values.push(...result.values);
-		}
-	}
-	return {
-		sql,
-		values
-	};
-};
-//#endregion
-//#region src/schema-manager.ts
-/**
-* Manages schema initialization from JSON manifests with dependency resolution
-*
-* Handles topological sorting of schema dependencies, table creation,
-* index and trigger setup, and version tracking to avoid redundant re-initialization.
-*/
-var DatabaseSchemaManager = class DatabaseSchemaManager {
-	static initializationLock = /* @__PURE__ */ new Map();
-	initializedSchemas = /* @__PURE__ */ new Set();
-	schemaVersions = /* @__PURE__ */ new Map();
-	/**
-	* Initializes database schemas from a JSON manifest with dependency resolution
-	*
-	* Schemas are topologically sorted by their declared dependencies and
-	* initialized in order. Supports legacy raw-SQL schemas via the `schema` option,
-	* JSON manifests via the `manifest` option, and schema overrides for extending
-	* base schemas.
-	*
-	* @param db - Database interface to execute DDL against
-	* @param options - Schema initialization options (manifest, overrides, force, debug)
-	* @returns Result with lists of initialized/skipped schemas, errors, and execution time
-	*/
-	async initializeSchemas(db, options) {
-		const startTime = Date.now();
-		const result = {
-			initialized: [],
-			skipped: [],
-			errors: [],
-			executionTime: 0
-		};
-		try {
-			let schemas = {};
-			if (options.schema) {
-				console.log("[schema] Legacy SQL schema provided, converting to manifest format");
-				if (db.syncSchema) {
-					await db.syncSchema(options.schema);
-					result.initialized.push("legacy-sql");
-				}
-				result.executionTime = Date.now() - startTime;
-				return result;
-			}
-			if (options.manifest) schemas = { ...options.manifest.schemas };
-			if (options.overrides) schemas = {
-				...schemas,
-				...options.overrides
-			};
-			if (Object.keys(schemas).length === 0) {
-				console.warn("[schema] No schemas provided for initialization");
-				result.executionTime = Date.now() - startTime;
-				return result;
-			}
-			const dependencyGraph = this.buildDependencyGraph(schemas);
-			const initializationOrder = this.resolveDependencies(dependencyGraph);
-			if (options.debug) console.log("[schema] Initialization order:", initializationOrder);
-			for (const schemaName of initializationOrder) {
-				const schema = schemas[schemaName];
-				if (!schema) continue;
-				try {
-					await this.initializeSchema(db, schemaName, schema, {
-						force: options.force,
-						debug: options.debug
-					});
-					result.initialized.push(schemaName);
-				} catch (error) {
-					const errorMessage = error instanceof Error ? error.message : String(error);
-					result.errors.push({
-						schema: schemaName,
-						error: errorMessage
-					});
-					if (options.debug) console.error(`[schema] Failed to initialize ${schemaName}:`, error);
-				}
-			}
-			result.executionTime = Date.now() - startTime;
-			if (options.debug) console.log("[schema] Initialization complete:", result);
-			return result;
-		} catch (error) {
-			result.executionTime = Date.now() - startTime;
-			const errorMessage = error instanceof Error ? error.message : String(error);
-			result.errors.push({
-				schema: "dependency-resolution",
-				error: errorMessage
-			});
-			return result;
-		}
-	}
-	/**
-	* Initialize a single schema
-	*/
-	async initializeSchema(db, schemaName, schema, options) {
-		const { tableName, version } = schema;
-		const lockKey = `${schemaName}:${tableName}`;
-		if (DatabaseSchemaManager.initializationLock.has(lockKey)) {
-			await DatabaseSchemaManager.initializationLock.get(lockKey);
-			return;
-		}
-		if (!options.force && this.isSchemaUpToDate(schemaName, version)) {
-			if (options.debug) console.log(`[schema] Skipping ${schemaName} - already up to date`);
-			return;
-		}
-		const initPromise = this.performSchemaInitialization(db, schemaName, schema, options);
-		DatabaseSchemaManager.initializationLock.set(lockKey, initPromise);
-		try {
-			await initPromise;
-			this.markSchemaInitialized(schemaName, version);
-		} finally {
-			DatabaseSchemaManager.initializationLock.delete(lockKey);
-		}
-	}
-	/**
-	* Perform the actual schema initialization
-	*/
-	async performSchemaInitialization(db, schemaName, schema, options) {
-		const { tableName, columns, indexes, triggers } = schema;
-		if (options.debug) console.log(`[schema] Initializing ${schemaName} (${tableName})`);
-		if (!await db.tableExists(tableName)) {
-			await this.createTable(db, schema);
-			for (const index of indexes) await this.createIndex(db, tableName, index);
-			for (const trigger of triggers) await this.createTrigger(db, trigger);
-		} else if (options.force) {
-			await db.query(`DROP TABLE IF EXISTS ${tableName}`);
-			await this.createTable(db, schema);
-			for (const index of indexes) await this.createIndex(db, tableName, index);
-			for (const trigger of triggers) await this.createTrigger(db, trigger);
-		} else await this.updateSchemaIfNeeded(db, schema);
-	}
-	/**
-	* Create table from schema definition
-	*/
-	async createTable(db, schema) {
-		const { tableName, columns, foreignKeys } = schema;
-		const columnDefinitions = [];
-		for (const [columnName, columnDef] of Object.entries(columns)) {
-			let def = `${columnName} ${columnDef.type}`;
-			if (columnDef.primaryKey) def += " PRIMARY KEY";
-			if (columnDef.unique && !columnDef.primaryKey) def += " UNIQUE";
-			if (columnDef.notNull) def += " NOT NULL";
-			if (columnDef.defaultValue !== void 0) def += ` DEFAULT ${columnDef.defaultValue}`;
-			if (columnDef.check) def += ` CHECK (${columnDef.check})`;
-			columnDefinitions.push(def);
-		}
-		for (const fk of foreignKeys) {
-			let fkDef = `FOREIGN KEY (${fk.column}) REFERENCES ${fk.referencesTable}(${fk.referencesColumn})`;
-			if (fk.onDelete) fkDef += ` ON DELETE ${fk.onDelete}`;
-			if (fk.onUpdate) fkDef += ` ON UPDATE ${fk.onUpdate}`;
-			columnDefinitions.push(fkDef);
-		}
-		const createTableSQL = `CREATE TABLE ${tableName} (\n  ${columnDefinitions.join(",\n  ")}\n)`;
-		await db.query(createTableSQL);
-	}
-	/**
-	* Create index from definition
-	*/
-	async createIndex(db, tableName, index) {
-		const uniqueClause = index.unique ? "UNIQUE " : "";
-		const whereClause = index.where ? ` WHERE ${index.where}` : "";
-		const createIndexSQL = `CREATE ${uniqueClause}INDEX ${index.name} ON ${tableName} (${index.columns.join(", ")})${whereClause}`;
-		await db.query(createIndexSQL);
-	}
-	/**
-	* Create trigger from definition
-	*/
-	async createTrigger(db, trigger) {
-		const conditionClause = trigger.condition ? ` WHEN ${trigger.condition}` : "";
-		const createTriggerSQL = `CREATE TRIGGER ${trigger.name} ${trigger.when} ${trigger.event} ON ${trigger.table}${conditionClause} BEGIN ${trigger.body} END`;
-		await db.query(createTriggerSQL);
-	}
-	/**
-	* Update schema if changes are detected
-	*/
-	async updateSchemaIfNeeded(_db, schema) {
-		console.log(`[schema] Schema update logic not yet implemented for ${schema.tableName}`);
-	}
-	/**
-	* Build dependency graph from schemas
-	*/
-	buildDependencyGraph(schemas) {
-		const graph = /* @__PURE__ */ new Map();
-		for (const [schemaName, schema] of Object.entries(schemas)) {
-			const dependencies = schema.dependencies.filter((dep) => Object.values(schemas).some((s) => s.tableName === dep));
-			graph.set(schemaName, dependencies.map((dep) => Object.entries(schemas).find(([_, s]) => s.tableName === dep)?.[0] || dep));
-		}
-		return graph;
-	}
-	/**
-	* Resolve dependencies using topological sort
-	*/
-	resolveDependencies(graph) {
-		const resolved = [];
-		const visited = /* @__PURE__ */ new Set();
-		const visiting = /* @__PURE__ */ new Set();
-		const visit = (node) => {
-			if (visiting.has(node)) throw new Error(`Circular dependency detected involving ${node}`);
-			if (visited.has(node)) return;
-			visiting.add(node);
-			const dependencies = graph.get(node) || [];
-			for (const dep of dependencies) if (graph.has(dep)) visit(dep);
-			visiting.delete(node);
-			visited.add(node);
-			resolved.push(node);
-		};
-		for (const node of graph.keys()) if (!visited.has(node)) visit(node);
-		return resolved;
-	}
-	/**
-	* Check if schema is up to date
-	*/
-	isSchemaUpToDate(schemaName, version) {
-		return this.initializedSchemas.has(schemaName) && this.schemaVersions.get(schemaName) === version;
-	}
-	/**
-	* Mark schema as initialized
-	*/
-	markSchemaInitialized(schemaName, version) {
-		this.initializedSchemas.add(schemaName);
-		this.schemaVersions.set(schemaName, version);
-	}
-	/**
-	* Reset initialization state (for testing)
-	*/
-	reset() {
-		this.initializedSchemas.clear();
-		this.schemaVersions.clear();
-		DatabaseSchemaManager.initializationLock.clear();
-	}
-};
-//#endregion
-//#region src/shared/alter-utils.ts
-/**
-* Generates an ALTER TABLE ADD COLUMN statement
-*
-* @param table - Table name
-* @param column - Column definition with name
-* @param dialect - Database dialect
-* @returns SQL statement string
-*
-* @example
-* ```typescript
-* const sql = generateAddColumnStatement('users', {
-*   name: 'email',
-*   type: 'TEXT',
-*   unique: true,
-*   notNull: false
-* }, 'sqlite');
-* // Returns: "ALTER TABLE users ADD COLUMN email TEXT UNIQUE"
-* ```
-*/
-function generateAddColumnStatement(table, column, _dialect) {
-	const parts = [column.name, column.type];
-	if (column.primaryKey) parts.push("PRIMARY KEY");
-	if (column.notNull) parts.push("NOT NULL");
-	if (column.unique) parts.push("UNIQUE");
-	if (column.defaultValue !== void 0) {
-		const defaultClause = generateDefaultClause(column.type, column.defaultValue);
-		parts.push(`DEFAULT ${defaultClause}`);
-	}
-	if (column.check) parts.push(`CHECK (${column.check})`);
-	if (column.foreignKey) {
-		const fk = column.foreignKey;
-		const fkParts = [`REFERENCES ${fk.table}(${fk.column})`];
-		if (fk.onDelete) fkParts.push(`ON DELETE ${fk.onDelete}`);
-		if (fk.onUpdate) fkParts.push(`ON UPDATE ${fk.onUpdate}`);
-		parts.push(fkParts.join(" "));
-	}
-	return `ALTER TABLE ${table} ADD COLUMN ${parts.join(" ")}`;
-}
-/**
-* Generates a DEFAULT clause for a column definition
-*
-* Handles proper formatting and escaping of default values based on column type.
-*
-* @param columnType - SQL column type (TEXT, INTEGER, BOOLEAN, etc.)
-* @param defaultValue - Default value to format
-* @returns Formatted default value string
-*
-* @example
-* ```typescript
-* generateDefaultClause('TEXT', 'hello'); // Returns: "'hello'"
-* generateDefaultClause('INTEGER', 42);   // Returns: "42"
-* generateDefaultClause('BOOLEAN', true); // Returns: "true"
-* generateDefaultClause('TEXT', null);    // Returns: "NULL"
-* ```
-*/
-function generateDefaultClause(columnType, defaultValue) {
-	if (defaultValue === null) return "NULL";
-	const typeUpper = columnType.toUpperCase();
-	if (typeUpper.includes("TEXT") || typeUpper.includes("CHAR") || typeUpper.includes("VARCHAR") || typeUpper.includes("STRING")) {
-		if (defaultValue === "") return "''";
-		return `'${String(defaultValue).replace(/'/g, "''")}'`;
-	}
-	if (typeUpper.includes("BOOL")) return defaultValue ? "true" : "false";
-	if (typeUpper.includes("INT") || typeUpper.includes("REAL") || typeUpper.includes("FLOAT") || typeUpper.includes("DOUBLE") || typeUpper.includes("NUMERIC") || typeUpper.includes("DECIMAL")) return String(defaultValue);
-	if (typeUpper.includes("JSON")) {
-		if (typeof defaultValue === "string") return `'${defaultValue.replace(/'/g, "''")}'`;
-		return `'${JSON.stringify(defaultValue).replace(/'/g, "''")}'`;
-	}
-	if (typeUpper.includes("DATE") || typeUpper.includes("TIME") || typeUpper.includes("TIMESTAMP")) {
-		if (defaultValue instanceof Date) return `'${defaultValue.toISOString()}'`;
-		return `'${String(defaultValue).replace(/'/g, "''")}'`;
-	}
-	if (typeof defaultValue === "string") return `'${defaultValue.replace(/'/g, "''")}'`;
-	return String(defaultValue);
-}
-/**
-* Generates a CREATE INDEX statement
-*
-* @param table - Table name
-* @param index - Index definition
-* @returns SQL CREATE INDEX statement
-*
-* @example
-* ```typescript
-* const sql = generateCreateIndexStatement('users', {
-*   name: 'idx_users_email',
-*   columns: ['email'],
-*   unique: true
-* });
-* // Returns: "CREATE UNIQUE INDEX idx_users_email ON users (email)"
-* ```
-*/
-function generateCreateIndexStatement(table, index) {
-	const parts = ["CREATE"];
-	if (index.unique) parts.push("UNIQUE");
-	parts.push("INDEX");
-	parts.push(index.name);
-	parts.push(`ON ${table}`);
-	const columns = index.columns.join(", ");
-	parts.push(`(${columns})`);
-	if (index.where) parts.push(`WHERE ${index.where}`);
-	return parts.join(" ");
-}
-/**
-* Validates a table name to prevent SQL injection
-*
-* The argument must be a primitive string. `RegExp.prototype.test` coerces its
-* argument with `toString`, so an object whose `toString` returns a valid name
-* on the call the validator makes and a different one on the call the caller's
-* `${table}` interpolation makes would pass here and then reach SQL. Rejecting
-* non-strings up front closes that gap: the value validated is the value
-* interpolated, because a primitive string cannot observe how many times it is
-* read.
-*
-* @param tableName - Table name to validate
-* @throws Error if the value is not a string or contains invalid characters
-*/
-function validateTableName(tableName) {
-	if (typeof tableName !== "string" || !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tableName)) throw new Error(`Invalid table name: ${tableName}. Table names must be a string that starts with a letter or underscore and contains only alphanumeric characters and underscores.`);
-}
-/**
-* Validates a column name to prevent SQL injection
-*
-* Rejects non-strings for the same reason as {@link validateTableName}: a value
-* whose `toString` differs between the validation read and the interpolation
-* read would otherwise slip a different identifier into SQL than the one
-* checked here.
-*
-* @param columnName - Column name to validate
-* @throws Error if the value is not a string or contains invalid characters
-*/
-function validateColumnName(columnName) {
-	if (typeof columnName !== "string" || !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(columnName)) throw new Error(`Invalid column name: ${columnName}. Column names must be a string that starts with a letter or underscore and contains only alphanumeric characters and underscores.`);
-}
-/**
-* Validates every identifier in a column list to prevent SQL injection
-*
-* Column names reaching the CRUD methods come from `Object.keys(data)` and the
-* caller's `conflictColumns`, both of which are interpolated into SQL. The
-* accepted shape has no character that can end an identifier. Adapters may
-* render a validated name bare, or quote it under an adapter-specific contract.
-* PostgreSQL upsert uses {@link quotePostgresColumnName}, which canonicalizes
-* the name before quoting so its established unquoted case-folding semantics
-* do not change.
-*
-* @param columnNames - Column names to validate
-* @throws Error if any column name contains invalid characters
-*/
-function validateColumnNames(columnNames) {
-	for (const columnName of columnNames) validateColumnName(columnName);
-}
-/**
-* Quotes a validated column name using PostgreSQL's historic case semantics.
-*
-* PostgreSQL folds every unquoted identifier to lowercase. The CRUD API has
-* always accepted mixed-case inputs while rendering them unquoted, so quoting
-* the caller's spelling directly would silently change which physical column
-* is addressed. Validate the existing plain-identifier contract first, then
-* lowercase before quoting: `mixedCase` still addresses `mixedcase`, while a
-* reserved word such as `end` is no longer parsed as SQL syntax.
-*
-* @param columnName - Plain column name to render for PostgreSQL
-* @returns A lowercase, double-quoted PostgreSQL identifier
-* @throws Error if the column name is outside the CRUD identifier contract
-*/
-function quotePostgresColumnName(columnName) {
-	validateColumnName(columnName);
-	return `"${columnName.toLowerCase()}"`;
-}
-/**
-* Escapes an identifier for interpolation inside double quotes
-*
-* For the positions that already quote the identifier — the DuckDB and JSON
-* upsert statements, which quote to match their schema generator — quoting is
-* what makes the identifier safe, so the only thing that has to be handled is
-* a quote character inside the name. Doubling it is the SQL escape.
-*
-* This is deliberately more permissive than {@link validateColumnName}: those
-* adapters accept column names that are not plain identifiers (`Full Name`,
-* `user-id`, `2024_total`), which matters most for the JSON adapter, whose
-* columns come straight from the keys of whatever JSON it was pointed at.
-* Rejecting them would break working code to fix an injection that quoting
-* already prevents.
-*
-* @param identifier - Identifier to place inside double quotes
-* @returns The identifier with embedded quotes doubled
-* @throws Error if the identifier is empty or contains a NUL byte
-*/
-function escapeQuotedIdentifier(identifier) {
-	const value = String(identifier);
-	if (value.length === 0 || value.includes("\0")) throw new Error(`Invalid column name: ${JSON.stringify(value)}. Column names must be non-empty and must not contain a NUL byte.`);
-	return value.replaceAll("\"", "\"\"");
-}
-/**
-* Escapes a value for interpolation inside a single-quoted SQL string literal
-*
-* The DuckDB-backed adapters read JSON through `read_json_auto('<path>')`, and
-* a file path is not something an identifier validator can check — paths
-* legitimately contain spaces, dots and, on Linux and macOS, quotes. Doubling
-* the quote is the SQL escape, and it is what keeps a file named `x'.json`
-* from ending the literal and starting a statement.
-*
-* @param value - Value to place inside single quotes
-* @returns The value with embedded single quotes doubled
-* @throws Error if the value contains a NUL byte
-*/
-function escapeStringLiteral(value) {
-	const text = String(value);
-	if (text.includes("\0")) throw new Error(`Invalid SQL string literal: ${JSON.stringify(text)}. Values must not contain a NUL byte.`);
-	return text.replaceAll("'", "''");
-}
-/**
-* Validates an index name to prevent SQL injection
-*
-* @param indexName - Index name to validate
-* @throws Error if index name contains invalid characters
-*/
-function validateIndexName(indexName) {
-	if (typeof indexName !== "string" || !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(indexName)) throw new Error(`Invalid index name: ${indexName}. Index names must be a string that starts with a letter or underscore and contains only alphanumeric characters and underscores.`);
-}
-//#endregion
-//#region src/shared/connection-cache.ts
-var CACHED_VALIDATION_CAPABILITY = Symbol.for("@happyvertical/sql/connection-cache-cached-validation/v1");
-/** Race-safe async resource cache used by database adapters. */
-var ConnectionCache = class {
-	[CACHED_VALIDATION_CAPABILITY] = true;
-	#connections = /* @__PURE__ */ new Map();
-	#pending = /* @__PURE__ */ new Map();
-	#evictions = /* @__PURE__ */ new Map();
-	#requests = /* @__PURE__ */ new Map();
-	#clearing = /* @__PURE__ */ new Map();
-	#failedClosures = /* @__PURE__ */ new Map();
-	async getOrCreate(key, options, create, close, validateCached) {
-		validateDatabaseCacheOptions(options);
-		const request = key && options.cache !== false ? this.#registerRequest(key) : void 0;
-		try {
-			this.#throwIfCancelled(request);
-			if (key && options.clearCache) {
-				await this.evict(key, close);
-				this.#throwIfCancelled(request);
-			}
-			if (key) this.#throwIfFailedClosure(key);
-			if (!key || options.cache === false) return create();
-			while (true) {
-				if (this.#evictions.has(key)) {
-					await this.#waitForEviction(key);
-					this.#throwIfCancelled(request);
-				}
-				this.#throwIfFailedClosure(key);
-				const cached = this.#connections.get(key);
-				if (cached !== void 0) {
-					if (!validateCached) return cached;
-					const isValid = await validateCached(cached);
-					this.#throwIfCancelled(request);
-					if (isValid && this.#connections.get(key) === cached && !this.#evictions.has(key)) return cached;
-					if (!isValid && this.#connections.get(key) === cached && !this.#evictions.has(key)) {
-						await this.evict(key, close);
-						this.#throwIfCancelled(request);
-					}
-					continue;
-				}
-				let pending = this.#pending.get(key);
-				if (!pending) {
-					this.#throwIfCancelled(request);
-					pending = {
-						invalidated: false,
-						promise: create()
-					};
-					this.#pending.set(key, pending);
-				}
-				let connection;
-				try {
-					connection = await pending.promise;
-				} catch (error) {
-					if (this.#pending.get(key) === pending) this.#pending.delete(key);
-					throw error;
-				}
-				if (pending.invalidated || this.#evictions.has(key)) {
-					if (this.#evictions.has(key)) await this.#waitForEviction(key);
-					this.#throwIfCancelled(request);
-					if (pending.invalidated === "clear") throw this.#clearError();
-					continue;
-				}
-				this.#throwIfCancelled(request);
-				if (this.#pending.get(key) === pending) this.#pending.delete(key);
-				this.#connections.set(key, connection);
-				return connection;
-			}
-		} finally {
-			if (request && key) this.#finishRequest(key, request);
-		}
-	}
-	async evict(key, close, invalidation = "evict") {
-		const previous = this.#evictions.get(key);
-		const state = previous?.state ?? {
-			invalidated: /* @__PURE__ */ new Set(),
-			invalidation
-		};
-		if (invalidation === "clear") {
-			state.invalidation = "clear";
-			for (const pending of state.invalidated) pending.invalidated = "clear";
-		}
-		const eviction = (previous?.promise ?? Promise.resolve()).then(async () => {
-			const resources = new Set(this.#failedClosures.get(key)?.resources ?? []);
-			this.#failedClosures.delete(key);
-			const cached = this.#connections.get(key);
-			this.#connections.delete(key);
-			if (cached) resources.add(cached);
-			const pending = this.#pending.get(key);
-			this.#pending.delete(key);
-			if (pending) {
-				state.invalidated.add(pending);
-				pending.invalidated = state.invalidation;
-				const initialized = await pending.promise.catch(() => void 0);
-				if (initialized !== void 0) resources.add(initialized);
-			}
-			const closeResults = await Promise.allSettled([...resources].map(async (resource) => {
-				await close(resource);
-				return resource;
-			}));
-			const failures = closeResults.filter((result) => result.status === "rejected");
-			if (failures.length) {
-				const resourceList = [...resources];
-				const failedResources = /* @__PURE__ */ new Set();
-				closeResults.forEach((result, index) => {
-					if (result.status === "rejected") failedResources.add(resourceList[index]);
-				});
-				const error = failures.length === 1 ? failures[0].reason : new AggregateError(failures.map((failure) => failure.reason), "Multiple database connections failed to close");
-				this.#failedClosures.set(key, {
-					error,
-					resources: failedResources
-				});
-				throw error;
-			}
-		});
-		const chain = {
-			promise: eviction,
-			state
-		};
-		this.#evictions.set(key, chain);
-		try {
-			await eviction;
-		} finally {
-			if (this.#evictions.get(key) === chain) this.#evictions.delete(key);
-		}
-	}
-	async clear(close) {
-		const keys = /* @__PURE__ */ new Set([
-			...this.#connections.keys(),
-			...this.#pending.keys(),
-			...this.#evictions.keys(),
-			...this.#requests.keys(),
-			...this.#clearing.keys(),
-			...this.#failedClosures.keys()
-		]);
-		const failures = (await Promise.allSettled([...keys].map((key) => this.#clearKey(key, close)))).filter((result) => result.status === "rejected");
-		if (failures.length === 1) throw failures[0].reason;
-		if (failures.length > 1) throw new AggregateError(failures.map((failure) => failure.reason), "Multiple database connection cache entries failed to clear");
-	}
-	forget(connection) {
-		for (const [key, cached] of this.#connections) if (cached === connection) this.#connections.delete(key);
-	}
-	/** @internal Test-only visibility; includes every retained namespace. */
-	get size() {
-		return this.#connections.size + this.#pending.size + this.#evictions.size + this.#requests.size + this.#clearing.size + this.#failedClosures.size;
-	}
-	async #clearKey(key, close) {
-		this.#clearing.set(key, (this.#clearing.get(key) ?? 0) + 1);
-		try {
-			this.#cancelRequests(key);
-			await this.evict(key, close, "clear");
-			while (this.#requests.get(key)?.size) {
-				this.#cancelRequests(key);
-				await Promise.all([...this.#requests.get(key) ?? []].map((request) => request.done));
-			}
-		} finally {
-			const remaining = (this.#clearing.get(key) ?? 1) - 1;
-			if (remaining === 0) this.#clearing.delete(key);
-			else this.#clearing.set(key, remaining);
-		}
-	}
-	#cancelRequests(key) {
-		for (const request of this.#requests.get(key) ?? []) request.cancelled = true;
-	}
-	#clearError() {
-		return /* @__PURE__ */ new Error("Database connection initialization was cancelled by cache clear");
-	}
-	#finishRequest(key, request) {
-		const requests = this.#requests.get(key);
-		requests?.delete(request);
-		if (requests?.size === 0) this.#requests.delete(key);
-		request.finish();
-	}
-	#registerRequest(key) {
-		let finish = () => {};
-		const done = new Promise((resolve) => {
-			finish = resolve;
-		});
-		const request = {
-			cancelled: this.#clearing.has(key),
-			done,
-			finish
-		};
-		const requests = this.#requests.get(key) ?? /* @__PURE__ */ new Set();
-		requests.add(request);
-		this.#requests.set(key, requests);
-		return request;
-	}
-	#throwIfCancelled(request) {
-		if (request?.cancelled) throw this.#clearError();
-	}
-	#throwIfFailedClosure(key) {
-		const failure = this.#failedClosures.get(key);
-		if (failure) throw failure.error;
-	}
-	async #waitForEviction(key) {
-		while (true) {
-			const eviction = this.#evictions.get(key);
-			if (!eviction) return;
-			await eviction.promise;
-		}
-	}
-};
-/**
-* Adds cached-resource validation to a shared cache created by an older module.
-*
-* JSON connection caches live on `globalThis`, so a compatible older SDK copy
-* can create the shared object before this module loads. Mutating that object
-* preserves one cache for both module copies while upgrading its four-argument
-* `getOrCreate` method to the current validation contract.
-*/
-function enableCachedValidation(cache) {
-	if (cache[CACHED_VALIDATION_CAPABILITY]) return cache;
-	const legacyGetOrCreate = cache.getOrCreate.bind(cache);
-	const legacyClear = cache.clear.bind(cache);
-	const locks = /* @__PURE__ */ new Map();
-	let clearGeneration = 0;
-	let activeClear;
-	const runLocked = async (key, work) => {
-		const previous = locks.get(key) ?? Promise.resolve();
-		let release;
-		const current = new Promise((resolve) => {
-			release = resolve;
-		});
-		const chain = previous.then(() => current, () => current);
-		locks.set(key, chain);
-		await previous.catch(() => {});
-		try {
-			return await work();
-		} finally {
-			release();
-			if (locks.get(key) === chain) locks.delete(key);
-		}
-	};
-	Object.defineProperty(cache, "getOrCreate", {
-		configurable: true,
-		value: async (key, options, create, close, validateCached) => {
-			if (!key || options.cache === false) return legacyGetOrCreate(key, options, create, close);
-			const requestGeneration = clearGeneration;
-			const throwIfCleared = () => {
-				if (activeClear || requestGeneration !== clearGeneration) throw new Error("Database connection initialization was cancelled by cache clear");
-			};
-			return runLocked(key, async () => {
-				throwIfCleared();
-				let requestOptions = options;
-				while (true) {
-					throwIfCleared();
-					const candidate = await legacyGetOrCreate(key, requestOptions, create, close);
-					throwIfCleared();
-					if (!validateCached) return candidate;
-					const isValid = await validateCached(candidate);
-					throwIfCleared();
-					if (isValid) {
-						const confirmed = await legacyGetOrCreate(key, {
-							...requestOptions,
-							clearCache: false
-						}, create, close);
-						throwIfCleared();
-						if (confirmed === candidate) return candidate;
-					} else await cache.evict(key, close);
-					requestOptions = {
-						...options,
-						clearCache: false
-					};
-				}
-			});
-		},
-		writable: true
-	});
-	Object.defineProperty(cache, "clear", {
-		configurable: true,
-		value: async (close) => {
-			if (activeClear) return activeClear;
-			clearGeneration += 1;
-			const clearing = (async () => {
-				let clearError;
-				let clearFailed = false;
-				try {
-					await legacyClear(close);
-				} catch (error) {
-					clearFailed = true;
-					clearError = error;
-				}
-				while (locks.size > 0) await Promise.allSettled([...locks.values()]);
-				if (clearFailed) throw clearError;
-			})();
-			activeClear = clearing;
-			try {
-				await clearing;
-			} finally {
-				if (activeClear === clearing) activeClear = void 0;
-			}
-		},
-		writable: true
-	});
-	Object.defineProperty(cache, CACHED_VALIDATION_CAPABILITY, {
-		configurable: false,
-		enumerable: false,
-		value: true,
-		writable: false
-	});
-	return cache;
-}
-function validateDatabaseCacheOptions(options) {
-	if (options.dbid === "") throw new Error("Database cache dbid must be a non-empty string");
-}
-//#endregion
-export { raw as _, escapeStringLiteral as a, wrapDatabaseError as b, quotePostgresColumnName as c, validateIndexName as d, validateTableName as f, parseConditionKey as g, formatDbError as h, escapeQuotedIdentifier as i, validateColumnName as l, buildWhere as m, enableCachedValidation as n, generateAddColumnStatement as o, DatabaseSchemaManager as p, validateDatabaseCacheOptions as r, generateCreateIndexStatement as s, ConnectionCache as t, validateColumnNames as u, resolveInsertColumns as v, unwrapRawKey as y };
-
-//# sourceMappingURL=connection-cache-Da5UcY5u.js.map