tempest-db-js 0.7.0 → 0.9.0

package/dist/chunk-4AWUP7BM.js

@@ -1,3076 +0,0 @@
-import { createRequire } from 'module';
-
-// src/conditions.ts
-var CONDITION = /* @__PURE__ */ Symbol.for("tempest-db-js.condition");
-function isCondition(value) {
-  return typeof value === "object" && value !== null && value[CONDITION] === true;
-}
-function toCondNode(input) {
-  return isCondition(input) ? input.node : { kind: "fields", fields: input };
-}
-function wrap(node) {
-  return { [CONDITION]: true, node };
-}
-function toExprNode(operand) {
-  return isExpression(operand) ? operand.node : { kind: "value", value: operand };
-}
-function assertValueOperands(op, operands) {
-  if (operands.some(isExpression)) {
-    throw new Error(
-      `The "${op}" operator binds its operands, so it takes values, not expressions.`
-    );
-  }
-}
-function isExpression(value) {
-  return value instanceof Expression;
-}
-var Expression = class {
-  constructor(node) {
-    this.node = node;
-  }
-  node;
-  /** Compare this expression against another expression or a bound value. */
-  compare(op, operand) {
-    return wrap({ kind: "compare", left: this.node, op, right: toExprNode(operand) });
-  }
-  /** `=` (or `IS NULL` for a null value). */
-  eq(operand) {
-    return this.compare("eq", operand);
-  }
-  /** `<>` (or `IS NOT NULL` for a null value). */
-  ne(operand) {
-    return this.compare("ne", operand);
-  }
-  /** `>`. */
-  gt(operand) {
-    return this.compare("gt", operand);
-  }
-  /** `>=`. */
-  gte(operand) {
-    return this.compare("gte", operand);
-  }
-  /** `<`. */
-  lt(operand) {
-    return this.compare("lt", operand);
-  }
-  /** `<=`. */
-  lte(operand) {
-    return this.compare("lte", operand);
-  }
-  /** `LIKE` — `%` and `_` in the operand are wildcards. */
-  like(pattern) {
-    return this.compare("like", pattern);
-  }
-  /** `ILIKE` — case-insensitive **pattern** matching, wildcards included. */
-  ilike(pattern) {
-    return this.compare("ilike", pattern);
-  }
-  /** Case-insensitive equality (`lower(a) = lower(b)`), with no wildcards. */
-  ieq(operand) {
-    return this.compare("ieq", operand);
-  }
-  /**
-   * `IN (...)` over a list of values.
-   *
-   * @param values The values to test against.
-   * @returns The condition.
-   * @throws Error When an entry is an {@link Expression} — a list operand is
-   *   bound, so an expression there would be serialized as a parameter instead of
-   *   rendered as SQL.
-   */
-  in(values) {
-    assertValueOperands("in", values);
-    return this.compare("in", values);
-  }
-  /**
-   * `NOT IN (...)` over a list of values.
-   *
-   * @param values The values to exclude.
-   * @returns The condition.
-   * @throws Error When an entry is an {@link Expression} (see {@link Expression.in}).
-   */
-  notIn(values) {
-    assertValueOperands("notIn", values);
-    return this.compare("notIn", values);
-  }
-  /**
-   * `BETWEEN lo AND hi` (inclusive).
-   *
-   * @param lo The lower bound.
-   * @param hi The upper bound.
-   * @returns The condition.
-   * @throws Error When a bound is an {@link Expression} (see {@link Expression.in}).
-   */
-  between(lo, hi) {
-    assertValueOperands("between", [lo, hi]);
-    return this.compare("between", [lo, hi]);
-  }
-  /** `IS NULL` (true) / `IS NOT NULL` (false). */
-  isNull(value = true) {
-    return this.compare("isNull", value);
-  }
-};
-function col(name) {
-  return new Expression({ kind: "column", name });
-}
-function val(value) {
-  return new Expression({ kind: "value", value });
-}
-var FUNCTION_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function toArg(arg) {
-  return typeof arg === "string" ? { kind: "column", name: arg } : arg.node;
-}
-function call(name, ...args) {
-  if (!FUNCTION_NAME.test(name)) {
-    throw new Error(
-      `fn.call() takes a plain SQL function name; got ${JSON.stringify(name)}.`
-    );
-  }
-  return new Expression({ kind: "fn", name, args: args.map(toArg) });
-}
-var fn = {
-  /** `lower(x)`. */
-  lower: (arg) => call("lower", arg),
-  /** `upper(x)`. */
-  upper: (arg) => call("upper", arg),
-  /** `trim(x)`. */
-  trim: (arg) => call("trim", arg),
-  /** `length(x)`. */
-  length: (arg) => call("length", arg),
-  /** `abs(x)`. */
-  abs: (arg) => call("abs", arg),
-  /** `coalesce(a, b, ...)`. */
-  coalesce: (...args) => call("coalesce", ...args),
-  /**
-   * Any other SQL function, by name. Portability is the caller's problem —
-   * `date_trunc` is PostgreSQL, `strftime` is SQLite.
-   */
-  call
-};
-function and(...inputs) {
-  return wrap({
-    kind: "and",
-    parts: inputs.map((i) => toCondNode(i))
-  });
-}
-function or(...inputs) {
-  return wrap({
-    kind: "or",
-    parts: inputs.map((i) => toCondNode(i))
-  });
-}
-function not(input) {
-  return wrap({ kind: "not", part: toCondNode(input) });
-}
-
-// src/query.ts
-function isSubquery(value) {
-  return typeof value === "object" && value !== null && value.node?.kind === "select";
-}
-var OPERATORS = [
-  "eq",
-  "ne",
-  "gt",
-  "gte",
-  "lt",
-  "lte",
-  "like",
-  "ilike",
-  "ieq",
-  "in",
-  "notIn",
-  "between",
-  "isNull",
-  "contains",
-  "containedBy",
-  "overlaps"
-];
-var Agg = class {
-  constructor(fn2, column2) {
-    this.fn = fn2;
-    this.column = column2;
-  }
-  fn;
-  column;
-};
-function count() {
-  return new Agg("count", "*");
-}
-function sum(column2) {
-  return new Agg("sum", column2);
-}
-function avg(column2) {
-  return new Agg("avg", column2);
-}
-function min(column2) {
-  return new Agg("min", column2);
-}
-function max(column2) {
-  return new Agg("max", column2);
-}
-var SelectBuilder = class _SelectBuilder {
-  constructor(node, source) {
-    this.node = node;
-    this.source = source;
-  }
-  node;
-  source;
-  with(patch) {
-    return new _SelectBuilder(
-      { ...this.node, ...patch },
-      this.source
-    );
-  }
-  /** Add a WHERE filter: the object form (keys typed) or an `and`/`or`/`not`. */
-  where(input) {
-    return this.with({ where: toCondNode(input) });
-  }
-  /**
-   * Filter by the result of the aggregation (`HAVING`).
-   *
-   * Only available on a grouped builder — `.having()` before `.aggregate()` is a
-   * compile error, not invalid SQL at runtime. Keys are the aggregate aliases you
-   * named plus the grouped columns; `WHERE` still filters rows *before* grouping,
-   * which is a different question.
-   *
-   * @param input The condition, keyed by alias or grouped column.
-   * @returns A builder carrying the `HAVING` clause.
-   *
-   * @example
-   * ```ts
-   * select(Outbound)
-   *   .where({ status: "queued" })
-   *   .aggregate(["consumer"], { n: count() })
-   *   .having({ n: { gt: 100 } });
-   * // ... GROUP BY "consumer" HAVING COUNT(*) > $2
-   * ```
-   */
-  having(input) {
-    return new _SelectBuilder(
-      { ...this.node, having: toCondNode(input) },
-      this.source
-    );
-  }
-  /** Emit `SELECT DISTINCT` — drop duplicate rows. */
-  distinct() {
-    return this.with({ distinct: true });
-  }
-  /**
-   * Group by columns and compute aggregates. The result row is the grouped
-   * columns (typed from the model) plus one field per aggregate alias.
-   *
-   * @param groupBy The columns to group by (checked against the model). Pass `[]`
-   *   for a whole-table aggregate.
-   * @param spec A map of result alias → aggregate expression ({@link count},
-   *   {@link sum}, {@link avg}, {@link min}, {@link max}).
-   * @returns A builder whose row is `Pick<Full, K> & { [alias]: aggResult }`.
-   *
-   * @example
-   * ```ts
-   * select(Order).aggregate(["status"], { n: count(), total: sum("amount") });
-   * // rows: { status: string; n: number; total: number | null }[]
-   * ```
-   */
-  aggregate(groupBy, spec) {
-    const aggregates = Object.entries(spec).map(([alias, agg]) => ({
-      fn: agg.fn,
-      column: agg.column,
-      alias
-    }));
-    return new _SelectBuilder(
-      { ...this.node, aggregates, groupBy },
-      this.source
-    );
-  }
-  /**
-   * Order by a column of the model, or — on a grouped query — by an aggregate
-   * alias. Unlike `HAVING`, every dialect accepts the output alias in `ORDER BY`,
-   * so the alias is emitted as written.
-   *
-   * @param column A model column, or a projected alias.
-   * @param direction `"asc"` (default) or `"desc"`.
-   * @returns A builder carrying the ordering term.
-   */
-  orderBy(column2, direction = "asc") {
-    return this.with({
-      orderBy: [...this.node.orderBy, { column: column2, direction }]
-    });
-  }
-  /** Limit the number of rows. */
-  limit(n) {
-    return this.with({ limit: n });
-  }
-  /** Skip the first `n` rows. */
-  offset(n) {
-    return this.with({ offset: n });
-  }
-  /**
-   * Narrow this SELECT to a single column and mark it as a subquery, so it can be
-   * the operand of `in` / `notIn`.
-   *
-   * The whole query — `where`, `orderBy`, `limit`, and a locking clause — is
-   * embedded in the outer statement, which is what collapses the claim-a-batch
-   * pattern into one round trip instead of selecting ids and sending them back.
-   *
-   * @param column The single column to project (checked against the model).
-   * @returns A subquery carrying that column's type.
-   *
-   * @example
-   * ```ts
-   * update(Outbound)
-   *   .set({ status: "sending", attempts: sql.raw("attempts + 1") })
-   *   .where({
-   *     id: {
-   *       in: select(Outbound)
-   *         .where({ status: "queued" })
-   *         .orderBy("nextAttemptAt")
-   *         .limit(10)
-   *         .forUpdate({ skipLocked: true })
-   *         .asSubquery("id"),
-   *     },
-   *   })
-   *   .returning();
-   * ```
-   */
-  asSubquery(column2) {
-    return { node: { ...this.node, columns: [column2] } };
-  }
-  /**
-   * Lock the selected rows for update (`SELECT ... FOR UPDATE`), à la
-   * SQLAlchemy's `with_for_update()`.
-   *
-   * `{ skipLocked: true }` is the job-queue claim: competing workers each take a
-   * disjoint batch instead of blocking on — or worse, double-processing — the
-   * same rows.
-   *
-   * PostgreSQL and MySQL 8.0+ only. SQLite has no row-level locking, and its
-   * dialect throws rather than emitting a `SELECT` that silently locks nothing —
-   * a lock that does not exist only fails under production concurrency.
-   *
-   * @param options `skipLocked` / `noWait` wait behavior, and `of` to restrict
-   *   the lock to specific tables.
-   * @returns A builder carrying the locking clause.
-   * @throws Error When both `skipLocked` and `noWait` are set.
-   *
-   * @example
-   * ```ts
-   * const batch = await session.execute(
-   *   select(Outbound)
-   *     .where({ status: "queued" })
-   *     .orderBy("nextAttemptAt")
-   *     .limit(10)
-   *     .forUpdate({ skipLocked: true }),
-   * ).all();
-   * ```
-   */
-  forUpdate(options) {
-    return this.with({ lock: buildLock("update", options) });
-  }
-  /**
-   * Take a shared read lock on the selected rows (`SELECT ... FOR SHARE`), the
-   * weaker counterpart of {@link SelectBuilder.forUpdate}.
-   *
-   * @param options `skipLocked` / `noWait` wait behavior, and `of` tables.
-   * @returns A builder carrying the locking clause.
-   * @throws Error When both `skipLocked` and `noWait` are set.
-   */
-  forShare(options) {
-    return this.with({ lock: buildLock("share", options) });
-  }
-};
-function buildLock(strength, options) {
-  if (options?.skipLocked && options?.noWait) {
-    throw new Error("forUpdate/forShare accept skipLocked or noWait, not both.");
-  }
-  const wait = options?.skipLocked ? "skipLocked" : options?.noWait ? "noWait" : "block";
-  return { strength, wait, of: options?.of ?? [] };
-}
-function select(model, columns) {
-  return new SelectBuilder(
-    {
-      kind: "select",
-      table: model.tablename,
-      columns: columns ?? "*",
-      distinct: false,
-      aggregates: [],
-      groupBy: [],
-      where: void 0,
-      orderBy: [],
-      limit: void 0,
-      offset: void 0,
-      names: columnNamesOf(model) ?? void 0
-    },
-    model
-  );
-}
-
-// src/serialize.ts
-var ValidationError = class extends Error {
-  constructor(table, issues) {
-    super(`Validation failed for ${table}:
-  - ${issues.join("\n  - ")}`);
-    this.table = table;
-    this.issues = issues;
-    this.name = "ValidationError";
-  }
-  table;
-  issues;
-};
-function toBase64(bytes) {
-  if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
-  let binary = "";
-  for (const byte of bytes) binary += String.fromCharCode(byte);
-  return btoa(binary);
-}
-function fromBase64(value) {
-  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(value, "base64"));
-  const binary = atob(value);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-  return bytes;
-}
-function encodeValue(column2, value) {
-  if (value === null || value === void 0) return null;
-  switch (column2.type.kind) {
-    case "bigint":
-      return typeof value === "bigint" ? value.toString() : value;
-    case "date":
-    case "datetime":
-    case "timestamp":
-      return value instanceof Date ? value.toISOString() : value;
-    case "blob":
-      return value instanceof Uint8Array ? toBase64(value) : value;
-    default:
-      return value;
-  }
-}
-function decodeValue(column2, value) {
-  if (value === null || value === void 0) return null;
-  switch (column2.type.kind) {
-    case "bigint":
-      return typeof value === "bigint" ? value : BigInt(value);
-    case "date":
-    case "datetime":
-    case "timestamp":
-      return value instanceof Date ? value : new Date(value);
-    case "blob":
-      return value instanceof Uint8Array ? value : fromBase64(value);
-    case "json":
-      return typeof value === "string" ? JSON.parse(value) : value;
-    case "array": {
-      const element = column2.type.meta.element;
-      const items = typeof value === "string" ? JSON.parse(value) : value;
-      if (!Array.isArray(items)) return items;
-      if (!element) return items;
-      return items.map((item) => decodeValue({ type: element }, item));
-    }
-    case "numeric":
-      return typeof value === "string" ? value : String(value);
-    case "boolean":
-      return typeof value === "boolean" ? value : value === 1 || value === "true";
-    case "smallint":
-    case "integer":
-    case "real":
-    case "double":
-      return typeof value === "number" ? value : Number(value);
-    default:
-      return value;
-  }
-}
-function toDict(model, row) {
-  const columns = columnsOf(model);
-  const out = {};
-  for (const name of Object.keys(columns)) {
-    out[name] = row[name] ?? null;
-  }
-  return out;
-}
-function toJSON(model, row) {
-  const columns = columnsOf(model);
-  const out = {};
-  for (const [name, col2] of Object.entries(columns)) {
-    out[name] = encodeValue(col2, row[name] ?? null);
-  }
-  return out;
-}
-function stringify(model, row) {
-  return JSON.stringify(toJSON(model, row));
-}
-function fromDict(model, data) {
-  const columns = columnsOf(model);
-  const out = {};
-  const issues = [];
-  for (const [name, col2] of Object.entries(columns)) {
-    const present = name in data && data[name] !== void 0 && data[name] !== null;
-    if (!present) {
-      const required = col2.flags.notNull && !col2.flags.hasDefault;
-      if (required) {
-        issues.push(`missing required column "${name}"`);
-        continue;
-      }
-      out[name] = null;
-      continue;
-    }
-    try {
-      out[name] = decodeValue(col2, data[name]);
-    } catch (error) {
-      issues.push(`column "${name}": ${error.message}`);
-    }
-  }
-  if (issues.length > 0) {
-    throw new ValidationError(model.tablename, issues);
-  }
-  return out;
-}
-function parse(model, json) {
-  return fromDict(model, JSON.parse(json));
-}
-function decoderFor(type) {
-  switch (type.kind) {
-    case "bigint":
-      return (v) => v == null ? null : typeof v === "bigint" ? v : BigInt(v);
-    case "date":
-    case "datetime":
-    case "timestamp":
-      return (v) => v == null ? null : v instanceof Date ? v : new Date(v);
-    case "blob":
-      return (v) => v == null ? null : v instanceof Uint8Array ? v : fromBase64(v);
-    case "json":
-      return (v) => v == null ? null : typeof v === "string" ? JSON.parse(v) : v;
-    case "array": {
-      const element = type.meta.element;
-      const inner = element ? decoderFor(element) : null;
-      if (!inner) return null;
-      return (v) => v == null ? null : Array.isArray(v) ? v.map(inner) : v;
-    }
-    case "numeric":
-      return (v) => v == null ? null : typeof v === "string" ? v : String(v);
-    case "boolean":
-      return (v) => v == null ? null : typeof v === "boolean" ? v : v === 1 || v === "true";
-    case "smallint":
-    case "integer":
-    case "real":
-    case "double":
-      return (v) => v == null ? null : typeof v === "number" ? v : Number(v);
-    default:
-      return null;
-  }
-}
-var mapperCache = /* @__PURE__ */ new WeakMap();
-function mapperFor(model) {
-  const cached = mapperCache.get(model);
-  if (cached) return cached;
-  const props = columnPropsOf(model);
-  const names = props ? Object.fromEntries(Object.entries(props).map(([db, prop]) => [prop, db])) : null;
-  const decoders = /* @__PURE__ */ new Map();
-  for (const [prop, col2] of Object.entries(columnsOf(model))) {
-    const decoder = decoderFor(col2.type);
-    if (decoder) decoders.set(names?.[prop] ?? prop, decoder);
-  }
-  const mapper = { props, decoders };
-  mapperCache.set(model, mapper);
-  return mapper;
-}
-function coerceRow(model, raw) {
-  const { props, decoders } = mapperFor(model);
-  const out = {};
-  for (const name of Object.keys(raw)) {
-    const decode2 = decoders.get(name);
-    out[props?.[name] ?? name] = decode2 ? decode2(raw[name]) : raw[name];
-  }
-  return out;
-}
-
-// src/mutations.ts
-var STRUCTURED_KINDS = /* @__PURE__ */ new Set(["json", "array", "blob"]);
-function isBindableScalar(value) {
-  if (value === null || value === void 0) return true;
-  const type = typeof value;
-  if (type === "string" || type === "number" || type === "bigint" || type === "boolean") {
-    return true;
-  }
-  return value instanceof Date || value instanceof Uint8Array;
-}
-function assertWritableValues(model, values, clause) {
-  const columns = columnsOf(model);
-  const issues = [];
-  for (const [key, value] of Object.entries(values)) {
-    const col2 = columns[key];
-    if (!col2) {
-      issues.push(`${clause}: "${key}" is not a column of ${model.tablename}`);
-      continue;
-    }
-    if (isSqlExpression(value) || isBindableScalar(value)) continue;
-    if (typeof value === "object" && STRUCTURED_KINDS.has(col2.type.kind)) continue;
-    issues.push(
-      `${clause}: "${key}" got ${describeValue(value)}, which cannot be bound to a ${col2.type.kind} column \u2014 use sql.raw()/sql.expr\`...\` for a SQL expression`
-    );
-  }
-  if (issues.length > 0) throw new ValidationError(model.tablename, issues);
-}
-function assertConsistentRows(model, rows) {
-  if (rows.length < 2) return;
-  const union = /* @__PURE__ */ new Set();
-  for (const row of rows) for (const key of Object.keys(row)) union.add(key);
-  const inconsistent = [...union].filter((key) => rows.some((row) => !(key in row)));
-  if (inconsistent.length === 0) return;
-  const columns = columnsOf(model);
-  const defaulted = inconsistent.filter((key) => columns[key]?.flags.hasDefault);
-  if (defaulted.length === 0) return;
-  const named = defaulted.map((c) => `"${c}"`).join(", ");
-  const verb = defaulted.length === 1 ? "has" : "have";
-  throw new ValidationError(model.tablename, [
-    `values: ${named} ${verb} a default but is missing from some rows of this multi-row insert \u2014 every row shares one column list, so the omitting rows would be written as NULL instead of taking the default. Give the column in every row, or insert the rows separately.`
-  ]);
-}
-function describeValue(value) {
-  if (typeof value === "function") return "a function";
-  if (Array.isArray(value)) return "an array";
-  if (typeof value === "symbol") return "a symbol";
-  return "an object";
-}
-var InsertBuilder = class _InsertBuilder {
-  constructor(node, source) {
-    this.node = node;
-    this.source = source;
-  }
-  node;
-  source;
-  with(patch) {
-    return new _InsertBuilder({ ...this.node, ...patch }, this.source);
-  }
-  /**
-   * Provide one row or many rows to insert, typed by the insert shape.
-   *
-   * @param rows One row, or an array of rows.
-   * @returns A builder carrying the rows.
-   * @throws ValidationError When a value is not a column value the dialect can
-   *   bind (see the `sql` helpers for writing an expression instead), or when the
-   *   rows of a multi-row insert disagree about a column that has a default.
-   */
-  values(rows) {
-    const list = Array.isArray(rows) ? rows : [rows];
-    for (const row of list) assertWritableValues(this.source, row, "values");
-    assertConsistentRows(this.source, list);
-    return this.with({ values: list });
-  }
-  /**
-   * On a unique/PK conflict on `target`, do nothing (skip the row).
-   *
-   * @param target The conflicting column(s) — a unique or primary key.
-   * @param options Pass `where` to name the predicate of a **partial** unique
-   *   index, which PostgreSQL requires in order to match it as a conflict target.
-   * @returns A builder carrying the conflict clause.
-   *
-   * @example
-   * ```ts
-   * insert(Outbound)
-   *   .values(data)
-   *   .onConflictDoNothing(["consumer", "idempotencyKey"], {
-   *     where: { idempotencyKey: { isNull: false } },
-   *   })
-   *   .returning();
-   * ```
-   */
-  onConflictDoNothing(target, options) {
-    return this.with({
-      onConflict: {
-        target,
-        update: "nothing",
-        targetWhere: options?.where ? toCondNode(options.where) : void 0
-      }
-    });
-  }
-  /**
-   * On a unique/PK conflict on `target`, overwrite the given columns (upsert).
-   *
-   * @param target The conflicting column(s) — a unique or primary key.
-   * @param set The columns to update with new values.
-   * @param options `indexWhere` names the predicate of a partial unique index
-   *   (the conflict target); `updateWhere` further restricts which conflicting
-   *   rows are rewritten.
-   * @returns A builder carrying the conflict clause.
-   * @throws ValidationError When a `set` value cannot be bound.
-   */
-  onConflictDoUpdate(target, set, options) {
-    assertWritableValues(this.source, set, "set");
-    return this.with({
-      onConflict: {
-        target,
-        update: set,
-        targetWhere: options?.indexWhere ? toCondNode(options.indexWhere) : void 0,
-        updateWhere: options?.updateWhere ? toCondNode(options.updateWhere) : void 0
-      }
-    });
-  }
-  returning(columns) {
-    return this.with({ returning: columns ?? "*" });
-  }
-};
-function insert(model) {
-  return new InsertBuilder(
-    {
-      kind: "insert",
-      table: model.tablename,
-      values: [],
-      returning: null,
-      names: columnNamesOf(model) ?? void 0
-    },
-    model
-  );
-}
-var UpdateBuilder = class _UpdateBuilder {
-  constructor(node, source) {
-    this.node = node;
-    this.source = source;
-  }
-  node;
-  source;
-  with(patch) {
-    return new _UpdateBuilder({ ...this.node, ...patch }, this.source);
-  }
-  /**
-   * The columns to write. Partial — only the given columns change.
-   *
-   * A value is bound as a parameter unless it is a {@link sql} expression, which
-   * is rendered inline instead — that is how a counter is written without a
-   * read-modify-write race.
-   *
-   * @param values The column → value map.
-   * @returns A builder carrying the assignments.
-   * @throws ValidationError When a value is not a column value the dialect can
-   *   bind (a bare object, an array on a scalar column, a function).
-   *
-   * @example
-   * ```ts
-   * update(Outbound)
-   *   .set({ attempts: sql.raw("attempts + 1"), updatedAt: sql.now() })
-   *   .where({ id });
-   * ```
-   */
-  set(values) {
-    assertWritableValues(this.source, values, "set");
-    return this.with({ set: values });
-  }
-  /** Restrict the rows to update. Marks the builder safe to execute. */
-  where(input) {
-    return this.with({
-      where: toCondNode(input),
-      guarded: true
-    });
-  }
-  /** Explicit opt-in to update EVERY row. Use deliberately. */
-  unguarded() {
-    return this.with({ guarded: true });
-  }
-  returning(columns) {
-    return this.with({ returning: columns ?? "*" });
-  }
-};
-function update(model) {
-  return new UpdateBuilder(
-    {
-      kind: "update",
-      table: model.tablename,
-      set: {},
-      where: void 0,
-      guarded: false,
-      returning: null,
-      names: columnNamesOf(model) ?? void 0
-    },
-    model
-  );
-}
-var DeleteBuilder = class _DeleteBuilder {
-  constructor(node, source) {
-    this.node = node;
-    this.source = source;
-  }
-  node;
-  source;
-  with(patch) {
-    return new _DeleteBuilder({ ...this.node, ...patch }, this.source);
-  }
-  /** Restrict the rows to delete. Marks the builder safe to execute. */
-  where(input) {
-    return this.with({
-      where: toCondNode(input),
-      guarded: true
-    });
-  }
-  /** Explicit opt-in to delete EVERY row. Use deliberately. */
-  unguarded() {
-    return this.with({ guarded: true });
-  }
-  returning(columns) {
-    return this.with({ returning: columns ?? "*" });
-  }
-};
-function del(model) {
-  return new DeleteBuilder(
-    {
-      kind: "delete",
-      table: model.tablename,
-      where: void 0,
-      guarded: false,
-      returning: null,
-      names: columnNamesOf(model) ?? void 0
-    },
-    model
-  );
-}
-
-// src/url.ts
-var InvalidDatabaseUrl = class extends Error {
-  constructor(url, reason) {
-    super(`Invalid database URL ${JSON.stringify(url)}: ${reason}`);
-    this.name = "InvalidDatabaseUrl";
-  }
-};
-var DIALECT_ALIASES = {
-  sqlite: "sqlite",
-  sqlite3: "sqlite",
-  postgresql: "postgresql",
-  postgres: "postgresql",
-  pg: "postgresql",
-  mysql: "mysql",
-  mariadb: "mysql"
-};
-function splitScheme(scheme) {
-  const plus = scheme.indexOf("+");
-  if (plus === -1) return { base: scheme.toLowerCase(), driver: null };
-  return {
-    base: scheme.slice(0, plus).toLowerCase(),
-    driver: scheme.slice(plus + 1) || null
-  };
-}
-function decode(value) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-function parseSqlite(raw, driver, rest) {
-  let database;
-  if (rest.endsWith(":memory:")) {
-    database = ":memory:";
-  } else if (rest.startsWith("///")) {
-    database = rest.slice(3) || ":memory:";
-  } else if (rest.startsWith("//")) {
-    database = rest.slice(2) || ":memory:";
-  } else {
-    database = rest || ":memory:";
-  }
-  return {
-    dialect: "sqlite",
-    driver,
-    host: null,
-    port: null,
-    user: null,
-    password: null,
-    database: decode(database),
-    options: {},
-    raw
-  };
-}
-function parseNetworkUrl(raw, driver, rest, dialect) {
-  let parsed;
-  try {
-    parsed = new URL(`${dialect}:${rest}`);
-  } catch {
-    throw new InvalidDatabaseUrl(raw, "could not parse host/credentials");
-  }
-  const database = decode(parsed.pathname.replace(/^\//, "")) || null;
-  const options = {};
-  for (const [key, value] of parsed.searchParams) options[key] = value;
-  return {
-    dialect,
-    driver,
-    host: parsed.hostname || null,
-    port: parsed.port ? Number(parsed.port) : null,
-    user: parsed.username ? decode(parsed.username) : null,
-    password: parsed.password ? decode(parsed.password) : null,
-    database,
-    options,
-    raw
-  };
-}
-function parseDatabaseUrl(url) {
-  const schemeEnd = url.indexOf(":");
-  if (schemeEnd === -1) {
-    throw new InvalidDatabaseUrl(
-      url,
-      "missing scheme (expected e.g. sqlite:// or postgresql://)"
-    );
-  }
-  const { base, driver } = splitScheme(url.slice(0, schemeEnd));
-  const dialect = DIALECT_ALIASES[base];
-  if (!dialect) {
-    throw new InvalidDatabaseUrl(url, `unknown dialect ${JSON.stringify(base)}`);
-  }
-  const rest = url.slice(schemeEnd + 1);
-  if (dialect === "sqlite") return parseSqlite(url, driver, rest);
-  return parseNetworkUrl(url, driver, rest, dialect);
-}
-function detectDialect(url) {
-  return parseDatabaseUrl(url).dialect;
-}
-
-// src/expressions.ts
-function renderPortableToken(token, dialect) {
-  switch (token) {
-    case "now":
-      return dialect === "postgresql" ? "now()" : "CURRENT_TIMESTAMP";
-    case "current_date":
-      return "CURRENT_DATE";
-    case "current_time":
-      return "CURRENT_TIME";
-    case "uuidv4":
-      if (dialect === "postgresql") return "gen_random_uuid()";
-      if (dialect === "mysql") return "(UUID())";
-      return "(lower(hex(randomblob(16))))";
-  }
-}
-
-// src/dialect.ts
-var OPERATOR_SET = new Set(OPERATORS);
-function isOperatorObject(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Date || value instanceof Uint8Array) {
-    return false;
-  }
-  const keys = Object.keys(value);
-  return keys.length > 0 && keys.every((k) => OPERATOR_SET.has(k));
-}
-var Params = class {
-  constructor(placeholder) {
-    this.placeholder = placeholder;
-  }
-  placeholder;
-  values = [];
-  bind(value) {
-    this.values.push(value);
-    return this.placeholder(this.values.length);
-  }
-};
-function insertColumns(rows) {
-  const columns = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const row of rows) {
-    for (const key of Object.keys(row)) {
-      if (seen.has(key)) continue;
-      seen.add(key);
-      columns.push(key);
-    }
-  }
-  return columns;
-}
-function insertHasExpression(node) {
-  for (const row of node.values) {
-    for (const value of Object.values(row)) {
-      if (isSqlExpression(value)) return true;
-    }
-  }
-  const update2 = node.onConflict?.update;
-  if (update2 && update2 !== "nothing") {
-    for (const value of Object.values(update2)) {
-      if (isSqlExpression(value)) return true;
-    }
-  }
-  return false;
-}
-var BaseDialect = class _BaseDialect {
-  /**
-   * INSERT SQL templates keyed by structure (dialect|table|columns|rowCount|
-   * returning). Shared across dialect instances — the key namespaces by dialect
-   * name, and the placeholder text is dialect-specific but structure-determined.
-   */
-  static insertTemplates = /* @__PURE__ */ new Map();
-  /** Quoted-identifier cache (see {@link quoteId}). Shared across dialects. */
-  static quotedIds = /* @__PURE__ */ new Map();
-  /**
-   * Validate a subquery operand before it is rendered, for dialects that restrict
-   * what an `IN (SELECT ...)` may contain. The default accepts everything.
-   *
-   * @param _node The subquery's AST.
-   * @throws Error When the dialect cannot execute this subquery.
-   */
-  checkSubquery(_node) {
-  }
-  /**
-   * The SQL operator for an array containment/overlap test.
-   *
-   * Only PostgreSQL has native arrays; the other dialects throw rather than
-   * emitting an operator that means something else there.
-   *
-   * @param op The array operator name.
-   * @returns The SQL operator text.
-   * @throws Error On a dialect without native array support.
-   */
-  arrayOperator(op) {
-    throw new Error(
-      `The "${op}" operator needs native array support, which ${this.name} does not have.`
-    );
-  }
-  /**
-   * Quote an identifier (column/table) for the active dialect.
-   *
-   * Memoized: identifiers form a small, stable set (column/table names), but this
-   * runs for every identifier on every compile. Caching the quoted form removes a
-   * regex-replace + string allocation from the hot path. The standard double-quote
-   * form is identical across both dialects, so one shared cache is correct.
-   */
-  quoteId(name) {
-    const cached = _BaseDialect.quotedIds.get(name);
-    if (cached !== void 0) return cached;
-    const quoted = `"${name.replace(/"/g, '""')}"`;
-    _BaseDialect.quotedIds.set(name, quoted);
-    return quoted;
-  }
-  /** Compile any node to `{ sql, params }`. */
-  compile(node) {
-    const params = new Params((i) => this.placeholder(i));
-    let sql2;
-    switch (node.kind) {
-      case "select":
-        sql2 = this.compileSelect(node, params);
-        break;
-      case "insert":
-        sql2 = this.compileInsert(node, params);
-        break;
-      case "update":
-        sql2 = this.compileUpdate(node, params);
-        break;
-      case "delete":
-        sql2 = this.compileDelete(node, params);
-        break;
-      case "join_select":
-        sql2 = this.compileJoin(node, params);
-        break;
-    }
-    return { sql: sql2, params: params.values };
-  }
-  /**
-   * Render a qualified `alias.column` ref as `"alias"."column"`, translating the
-   * property name to the real column name for that alias's model.
-   *
-   * @param ref The `alias.property` reference (a bare name is left unqualified).
-   * @param names The node's per-alias name maps, if any source renames columns.
-   * @returns The quoted, qualified identifier.
-   */
-  qualify(ref, names) {
-    const dot = ref.indexOf(".");
-    if (dot === -1) return this.quoteId(ref);
-    const alias = ref.slice(0, dot);
-    const prop = ref.slice(dot + 1);
-    return `${this.quoteId(alias)}.${this.columnId(prop, names?.[alias])}`;
-  }
-  /**
-   * Quote a column identifier, translating the model property name to the real
-   * database column name first.
-   *
-   * `names` is `undefined` for a model that renames nothing — the overwhelmingly
-   * common case — so this stays a single lookup plus the memoized quote.
-   *
-   * @param prop The model property name as written in the builder.
-   * @param names The node's property → column map, if any.
-   * @returns The quoted database identifier.
-   */
-  columnId(prop, names) {
-    return this.quoteId(names?.[prop] ?? prop);
-  }
-  /**
-   * Render a {@link SqlExpression} inline, binding the parameters it carries.
-   *
-   * This is what keeps `set({ attempts: sql.raw("attempts + 1") })` an expression
-   * instead of a bound object: the fragment goes into the statement text, and
-   * only a `sql.expr` template's interpolations become parameters.
-   *
-   * @param expr The branded expression.
-   * @param params The parameter collector for the statement being compiled.
-   * @returns The SQL text of the expression.
-   */
-  renderExpression(expr, params) {
-    const token = expr.expression;
-    if (typeof token === "string") return renderPortableToken(token, this.name);
-    if ("raw" in token) return token.raw;
-    const parts = token.parts;
-    let sql2 = parts[0] ?? "";
-    for (let i = 1; i < parts.length; i++) {
-      sql2 += `${params.bind(expr.params[i - 1])}${parts[i]}`;
-    }
-    return sql2;
-  }
-  /** Render one write value: a SQL expression inline, anything else as a parameter. */
-  renderValue(value, params) {
-    return isSqlExpression(value) ? this.renderExpression(value, params) : params.bind(value);
-  }
-  /**
-   * Render a row-level locking clause (`FOR UPDATE ...`).
-   *
-   * Standard on PostgreSQL and MySQL 8.0+; SQLite overrides it to throw.
-   *
-   * @param lock The locking clause from the node.
-   * @returns The SQL text, leading space included.
-   */
-  renderLock(lock) {
-    const strength = lock.strength === "update" ? "FOR UPDATE" : "FOR SHARE";
-    const of = lock.of.length > 0 ? ` OF ${lock.of.map((t) => this.quoteId(t)).join(", ")}` : "";
-    const wait = lock.wait === "skipLocked" ? " SKIP LOCKED" : lock.wait === "noWait" ? " NOWAIT" : "";
-    return ` ${strength}${of}${wait}`;
-  }
-  // ---- statements -------------------------------------------------------
-  /**
-   * Compile a SELECT.
-   *
-   * Two alias rules differ between clauses and are handled here: PostgreSQL does
-   * NOT accept a `SELECT` alias in `HAVING`, so an aggregate key is re-emitted as
-   * its expression (`COUNT(*) > $1`), a form every dialect accepts; `ORDER BY`,
-   * by contrast, accepts the output alias everywhere, so it is emitted as
-   * written.
-   *
-   * @param node The select AST.
-   * @param params The parameter collector.
-   * @returns The SQL text.
-   */
-  compileSelect(node, params) {
-    const names = node.names;
-    let cols;
-    if (node.aggregates.length > 0) {
-      const groupSel = node.groupBy.map((c) => this.columnId(c, names));
-      const aggSel = node.aggregates.map((a) => {
-        const inner = a.column === "*" ? "*" : this.columnId(a.column, names);
-        return `${a.fn.toUpperCase()}(${inner}) AS ${this.quoteId(a.alias)}`;
-      });
-      cols = [...groupSel, ...aggSel].join(", ");
-    } else {
-      cols = node.columns === "*" ? "*" : node.columns.map((c) => this.columnId(c, names)).join(", ");
-    }
-    let sql2 = `SELECT ${node.distinct ? "DISTINCT " : ""}${cols} FROM ${this.quoteId(node.table)}`;
-    const where = this.compileCondition(
-      node.where,
-      params,
-      (k) => this.columnId(k, names)
-    );
-    if (where) sql2 += ` WHERE ${where}`;
-    if (node.groupBy.length > 0) {
-      sql2 += ` GROUP BY ${node.groupBy.map((c) => this.columnId(c, names)).join(", ")}`;
-    }
-    const aggByAlias = new Map(node.aggregates.map((a) => [a.alias, a]));
-    if (node.having) {
-      const having = this.compileCondition(node.having, params, (key) => {
-        const agg = aggByAlias.get(key);
-        if (!agg) return this.columnId(key, names);
-        const inner = agg.column === "*" ? "*" : this.columnId(agg.column, names);
-        return `${agg.fn.toUpperCase()}(${inner})`;
-      });
-      if (having) sql2 += ` HAVING ${having}`;
-    }
-    if (node.orderBy.length > 0) {
-      const terms = node.orderBy.map((t) => {
-        const id = aggByAlias.has(t.column) ? this.quoteId(t.column) : this.columnId(t.column, names);
-        return `${id} ${t.direction === "desc" ? "DESC" : "ASC"}`;
-      }).join(", ");
-      sql2 += ` ORDER BY ${terms}`;
-    }
-    if (node.limit !== void 0) sql2 += ` LIMIT ${params.bind(node.limit)}`;
-    if (node.offset !== void 0) sql2 += ` OFFSET ${params.bind(node.offset)}`;
-    if (node.lock) {
-      if (node.distinct || node.groupBy.length > 0 || node.aggregates.length > 0) {
-        throw new Error(
-          "FOR UPDATE / FOR SHARE cannot be combined with DISTINCT or an aggregate query \u2014 lock the underlying rows in a separate SELECT."
-        );
-      }
-      sql2 += this.renderLock(node.lock);
-    }
-    return sql2;
-  }
-  /**
-   * Compile an INSERT.
-   *
-   * Takes the cached fast path only when the statement text is a pure function of
-   * its structure. A SQL expression among the values, or a conflict predicate,
-   * makes the text depend on the values themselves — those compile uncached, in
-   * SQL order, so placeholder positions stay correct.
-   */
-  compileInsert(node, params) {
-    const columns = insertColumns(node.values);
-    const conflict = node.onConflict;
-    const cacheable = conflict?.targetWhere === void 0 && conflict?.updateWhere === void 0 && !insertHasExpression(node);
-    if (!cacheable) return this.compileInsertDirect(node, columns, params);
-    for (const row of node.values) {
-      for (const c of columns) params.bind(row[c] ?? null);
-    }
-    const conflictCols = conflict && conflict.update !== "nothing" ? Object.keys(conflict.update) : [];
-    for (const c of conflictCols) {
-      params.bind((conflict?.update)[c]);
-    }
-    return this.insertTemplate(node, columns, conflictCols, params);
-  }
-  /**
-   * Compile an INSERT without the template cache, rendering clauses in statement
-   * order so every parameter is bound at the position it appears.
-   *
-   * @param node The insert node.
-   * @param columns The column keys shared by every row.
-   * @param params The parameter collector.
-   * @returns The SQL text.
-   */
-  compileInsertDirect(node, columns, params) {
-    const names = node.names;
-    const colSql = columns.map((c) => this.columnId(c, names)).join(", ");
-    const rowsSql = node.values.map((row) => {
-      const cells = columns.map(
-        (c) => this.renderValue(row[c] ?? null, params)
-      );
-      return `(${cells.join(", ")})`;
-    }).join(", ");
-    let sql2 = `INSERT INTO ${this.quoteId(node.table)} (${colSql}) VALUES ${rowsSql}`;
-    if (node.onConflict) {
-      const update2 = node.onConflict.update;
-      const conflictCols = update2 === "nothing" ? [] : Object.keys(update2);
-      let cursor = 0;
-      sql2 += this.renderConflict(
-        node.onConflict,
-        conflictCols,
-        () => {
-          const key = conflictCols[cursor++];
-          return this.renderValue(update2[key], params);
-        },
-        names,
-        params
-      );
-    }
-    sql2 += this.compileReturning(node.returning, names);
-    return sql2;
-  }
-  /**
-   * The INSERT SQL template for a given structure, cached across calls.
-   *
-   * The text depends only on (dialect, table, columns, row count, returning,
-   * conflict shape) — never on the bound values — and placeholder positions are
-   * deterministic from the counts (a fresh statement always starts binding at 1).
-   * So a per-row insert loop compiles the string once and reuses it every row.
-   */
-  insertTemplate(node, columns, conflictCols, params) {
-    const returningKey = node.returning === null ? "" : node.returning === "*" ? "*" : node.returning.join(",");
-    const conflictKey = node.onConflict ? `${node.onConflict.target.join(",")}>${node.onConflict.update === "nothing" ? "nothing" : conflictCols.join(",")}` : "";
-    const key = `${this.name}|${node.table}|${columns.join(",")}|${node.values.length}|${returningKey}|${conflictKey}`;
-    const cached = _BaseDialect.insertTemplates.get(key);
-    if (cached !== void 0) return cached;
-    const names = node.names;
-    const colSql = columns.map((c) => this.columnId(c, names)).join(", ");
-    let position = 0;
-    const rowsSql = node.values.map(() => `(${columns.map(() => this.placeholder(++position)).join(", ")})`).join(", ");
-    let sql2 = `INSERT INTO ${this.quoteId(node.table)} (${colSql}) VALUES ${rowsSql}`;
-    if (node.onConflict) {
-      sql2 += this.renderConflict(
-        node.onConflict,
-        conflictCols,
-        () => this.placeholder(++position),
-        names,
-        params
-      );
-    }
-    sql2 += this.compileReturning(node.returning, names);
-    _BaseDialect.insertTemplates.set(key, sql2);
-    return sql2;
-  }
-  /**
-   * Render the conflict-handling clause. Standard SQL (SQLite/PostgreSQL) uses
-   * `ON CONFLICT (...) [WHERE predicate] DO NOTHING | DO UPDATE SET ... [WHERE ...]`;
-   * MySQL overrides this.
-   *
-   * The index predicate is rendered before the `DO UPDATE` assignments because
-   * that is where it sits in the statement, so its parameters bind first.
-   *
-   * @param onConflict The conflict clause from the node.
-   * @param conflictCols The columns to overwrite on `DO UPDATE` (empty for nothing).
-   * @param nextValue Yields the SQL for the next `DO UPDATE` assignment value.
-   * @param names The node's property → column map, if any.
-   * @param params The parameter collector, for the predicates.
-   * @returns The SQL text, leading space included.
-   */
-  renderConflict(onConflict, conflictCols, nextValue, names, params) {
-    const idFor = (key) => this.columnId(key, names);
-    const target = onConflict.target.map(idFor).join(", ");
-    const indexWhere = this.compileCondition(onConflict.targetWhere, params, idFor);
-    const targetSql = indexWhere ? `(${target}) WHERE ${indexWhere}` : `(${target})`;
-    if (onConflict.update === "nothing") return ` ON CONFLICT ${targetSql} DO NOTHING`;
-    const assignments = conflictCols.map((c) => `${idFor(c)} = ${nextValue()}`).join(", ");
-    let sql2 = ` ON CONFLICT ${targetSql} DO UPDATE SET ${assignments}`;
-    const updateWhere = this.compileCondition(onConflict.updateWhere, params, idFor);
-    if (updateWhere) sql2 += ` WHERE ${updateWhere}`;
-    return sql2;
-  }
-  compileUpdate(node, params) {
-    const names = node.names;
-    const sets = Object.entries(node.set).map(
-      ([col2, value]) => `${this.columnId(col2, names)} = ${this.renderValue(value, params)}`
-    ).join(", ");
-    let sql2 = `UPDATE ${this.quoteId(node.table)} SET ${sets}`;
-    const where = this.compileCondition(
-      node.where,
-      params,
-      (k) => this.columnId(k, names)
-    );
-    if (where) sql2 += ` WHERE ${where}`;
-    sql2 += this.compileReturning(node.returning, names);
-    return sql2;
-  }
-  compileDelete(node, params) {
-    const names = node.names;
-    let sql2 = `DELETE FROM ${this.quoteId(node.table)}`;
-    const where = this.compileCondition(
-      node.where,
-      params,
-      (k) => this.columnId(k, names)
-    );
-    if (where) sql2 += ` WHERE ${where}`;
-    sql2 += this.compileReturning(node.returning, names);
-    return sql2;
-  }
-  compileJoin(node, params) {
-    const names = node.names;
-    const cols = node.selections.map((s) => {
-      const ref = `${s.alias}.${s.column}`;
-      return `${this.qualify(ref, names)} AS ${this.quoteId(ref)}`;
-    }).join(", ");
-    let sql2 = `SELECT ${cols} FROM ${this.quoteId(node.base.table)} AS ${this.quoteId(node.base.alias)}`;
-    for (const j of node.joins) {
-      const kw = j.kind === "left" ? "LEFT JOIN" : "INNER JOIN";
-      const on = j.on.map(([l, r]) => `${this.qualify(l, names)} = ${this.qualify(r, names)}`).join(" AND ");
-      sql2 += ` ${kw} ${this.quoteId(j.table)} AS ${this.quoteId(j.alias)} ON ${on}`;
-    }
-    const where = this.compileCondition(
-      node.where,
-      params,
-      (k) => this.qualify(k, names)
-    );
-    if (where) sql2 += ` WHERE ${where}`;
-    if (node.orderBy.length > 0) {
-      const terms = node.orderBy.map(
-        (t) => `${this.qualify(t.ref, names)} ${t.direction === "desc" ? "DESC" : "ASC"}`
-      ).join(", ");
-      sql2 += ` ORDER BY ${terms}`;
-    }
-    if (node.limit !== void 0) sql2 += ` LIMIT ${params.bind(node.limit)}`;
-    if (node.offset !== void 0) sql2 += ` OFFSET ${params.bind(node.offset)}`;
-    return sql2;
-  }
-  // ---- clauses ----------------------------------------------------------
-  compileReturning(returning, names) {
-    if (returning === null) return "";
-    if (returning === "*") return " RETURNING *";
-    return ` RETURNING ${returning.map((c) => this.columnId(c, names)).join(", ")}`;
-  }
-  /**
-   * Compile a condition tree (fields / and / or / not) to SQL. `idFor` renders a
-   * key to a quoted identifier — `quoteId` for single-table, `qualify` for joins —
-   * so select/update/delete/join all share this one compiler.
-   */
-  compileCondition(node, params, idFor) {
-    if (!node) return "";
-    switch (node.kind) {
-      case "fields": {
-        const conditions = [];
-        for (const [key, value] of Object.entries(node.fields)) {
-          const id = idFor(key);
-          if (isOperatorObject(value)) {
-            for (const [op, operand] of Object.entries(value)) {
-              conditions.push(this.compileOperator(id, op, operand, params));
-            }
-          } else {
-            conditions.push(
-              value === null ? `${id} IS NULL` : `${id} = ${params.bind(value)}`
-            );
-          }
-        }
-        return conditions.join(" AND ");
-      }
-      case "and":
-      case "or": {
-        const parts = node.parts.map((p) => this.compileCondition(p, params, idFor)).filter((s) => s.length > 0);
-        if (parts.length === 0) return "";
-        const sep = node.kind === "and" ? " AND " : " OR ";
-        return parts.map((p) => `(${p})`).join(sep);
-      }
-      case "not": {
-        const inner = this.compileCondition(node.part, params, idFor);
-        return inner ? `NOT (${inner})` : "";
-      }
-      case "compare": {
-        const left = this.renderExpr(node.left, params, idFor);
-        if (node.right.kind === "value") {
-          return this.compileOperator(left, node.op, node.right.value, params);
-        }
-        return this.compileExprOperator(
-          left,
-          node.op,
-          this.renderExpr(node.right, params, idFor)
-        );
-      }
-    }
-  }
-  /**
-   * Render one side of a comparison.
-   *
-   * A column reference goes through `idFor`, so an explicit `.name()` mapping and
-   * join qualification apply here exactly as they do in the object form of
-   * `where` — `col()` is not a way around them. Only a `value` node binds.
-   *
-   * @param node The expression AST.
-   * @param params The parameter collector.
-   * @param idFor The identifier resolver for the enclosing statement.
-   * @returns The SQL text of the expression.
-   */
-  renderExpr(node, params, idFor) {
-    switch (node.kind) {
-      case "column":
-        return idFor(node.name);
-      case "value":
-        return params.bind(node.value);
-      case "fn": {
-        const args = node.args.map((a) => this.renderExpr(a, params, idFor)).join(", ");
-        return `${node.name}(${args})`;
-      }
-    }
-  }
-  /**
-   * Compile a comparison whose right-hand side is another expression rather than
-   * a bound value (`total > paid`, `lower(a) = lower(b)`).
-   *
-   * The list and null operators are excluded: `IN`, `BETWEEN` and `IS NULL` take
-   * a value operand, and accepting an expression there would silently compile to
-   * something else.
-   *
-   * @param left The rendered left-hand side.
-   * @param op The operator name.
-   * @param right The rendered right-hand side.
-   * @returns The SQL text of the predicate.
-   * @throws Error When the operator needs a value operand.
-   */
-  compileExprOperator(left, op, right) {
-    switch (op) {
-      case "eq":
-        return `${left} = ${right}`;
-      case "ne":
-        return `${left} <> ${right}`;
-      case "gt":
-        return `${left} > ${right}`;
-      case "gte":
-        return `${left} >= ${right}`;
-      case "lt":
-        return `${left} < ${right}`;
-      case "lte":
-        return `${left} <= ${right}`;
-      case "like":
-        return `${left} LIKE ${right}`;
-      case "ilike":
-        return this.ilike(left, right);
-      case "ieq":
-        return `lower(${left}) = lower(${right})`;
-      case "contains":
-      case "containedBy":
-      case "overlaps":
-        return `${left} ${this.arrayOperator(op)} ${right}`;
-      default:
-        throw new Error(`The "${op}" operator takes a value operand, not an expression.`);
-    }
-  }
-  compileOperator(id, op, operand, params) {
-    switch (op) {
-      case "eq":
-        return operand === null ? `${id} IS NULL` : `${id} = ${params.bind(operand)}`;
-      case "ne":
-        return operand === null ? `${id} IS NOT NULL` : `${id} <> ${params.bind(operand)}`;
-      case "gt":
-        return `${id} > ${params.bind(operand)}`;
-      case "gte":
-        return `${id} >= ${params.bind(operand)}`;
-      case "lt":
-        return `${id} < ${params.bind(operand)}`;
-      case "lte":
-        return `${id} <= ${params.bind(operand)}`;
-      case "like":
-        return `${id} LIKE ${params.bind(operand)}`;
-      case "ilike":
-        return this.ilike(id, params.bind(operand));
-      case "ieq":
-        return operand === null ? `${id} IS NULL` : `lower(${id}) = lower(${params.bind(operand)})`;
-      case "contains":
-        return `${id} ${this.arrayOperator("contains")} ${params.bind(operand)}`;
-      case "containedBy":
-        return `${id} ${this.arrayOperator("containedBy")} ${params.bind(operand)}`;
-      case "overlaps":
-        return `${id} ${this.arrayOperator("overlaps")} ${params.bind(operand)}`;
-      case "in":
-        return this.compileIn(id, operand, params, false);
-      case "notIn":
-        return this.compileIn(id, operand, params, true);
-      case "between": {
-        const [lo, hi] = operand;
-        return `${id} BETWEEN ${params.bind(lo)} AND ${params.bind(hi)}`;
-      }
-      case "isNull":
-        return operand ? `${id} IS NULL` : `${id} IS NOT NULL`;
-      default:
-        throw new Error(`Unknown operator ${JSON.stringify(op)}`);
-    }
-  }
-  /**
-   * Compile `IN` / `NOT IN`, whose operand is either a value list or a
-   * single-column subquery.
-   *
-   * The subquery is rendered at the position it appears in the outer statement
-   * and shares the same parameter collector, so its own placeholders land in the
-   * right order — and it keeps its own `names` map, since the inner model may use
-   * a different naming convention than the outer one.
-   *
-   * @param id The quoted column identifier being tested.
-   * @param operand A list of values, or a {@link Subquery}.
-   * @param params The parameter collector for the statement being compiled.
-   * @param negate True for `NOT IN`.
-   * @returns The SQL text of the predicate.
-   */
-  compileIn(id, operand, params, negate) {
-    const keyword = negate ? "NOT IN" : "IN";
-    if (isSubquery(operand)) {
-      this.checkSubquery(operand.node);
-      return `${id} ${keyword} (${this.compileSelect(operand.node, params)})`;
-    }
-    const values = operand;
-    if (values.length === 0) {
-      return negate ? "1 = 1" : "1 = 0";
-    }
-    const list = values.map((v) => params.bind(v)).join(", ");
-    return `${id} ${keyword} (${list})`;
-  }
-};
-var SqliteDialect = class extends BaseDialect {
-  name = "sqlite";
-  placeholder() {
-    return "?";
-  }
-  ilike(column2, param) {
-    return `${column2} LIKE ${param}`;
-  }
-  /**
-   * SQLite has no row-level locking, so a lock request is an error rather than a
-   * silently unlocked `SELECT` — a lock that does not exist only shows up as
-   * duplicated work under production concurrency.
-   */
-  renderLock() {
-    throw new Error(
-      "SQLite has no row-level locking \u2014 FOR UPDATE / FOR SHARE is unsupported. Serialize the claim inside a transaction instead."
-    );
-  }
-};
-var PostgresDialect = class extends BaseDialect {
-  name = "postgresql";
-  placeholder(index) {
-    return `$${index}`;
-  }
-  ilike(column2, param) {
-    return `${column2} ILIKE ${param}`;
-  }
-  arrayOperator(op) {
-    if (op === "contains") return "@>";
-    if (op === "containedBy") return "<@";
-    return "&&";
-  }
-};
-var mysqlQuotedIds = /* @__PURE__ */ new Map();
-var MysqlDialect = class extends BaseDialect {
-  name = "mysql";
-  placeholder() {
-    return "?";
-  }
-  ilike(column2, param) {
-    return `${column2} LIKE ${param}`;
-  }
-  quoteId(name) {
-    const cached = mysqlQuotedIds.get(name);
-    if (cached !== void 0) return cached;
-    const quoted = `\`${name.replace(/`/g, "``")}\``;
-    mysqlQuotedIds.set(name, quoted);
-    return quoted;
-  }
-  /**
-   * MySQL rejects `LIMIT` inside an `IN` subquery with
-   * `ER_NOT_SUPPORTED_YET: This version of MySQL doesn't yet support
-   * 'LIMIT & IN/ALL/ANY/SOME subquery'`. Failing at compile time names the fix
-   * instead of surfacing that error from the driver at runtime.
-   */
-  checkSubquery(node) {
-    if (node.limit !== void 0 || node.offset !== void 0) {
-      throw new Error(
-        "MySQL does not support LIMIT/OFFSET inside an IN subquery. Select the ids first and pass them as a list, or wrap the subquery in a derived table."
-      );
-    }
-  }
-  renderConflict(onConflict, conflictCols, nextValue, names) {
-    if (onConflict.targetWhere || onConflict.updateWhere) {
-      throw new Error(
-        "MySQL's ON DUPLICATE KEY UPDATE has no conflict-target predicate \u2014 a partial unique index is PostgreSQL/SQLite only."
-      );
-    }
-    if (onConflict.update === "nothing") {
-      const col2 = this.columnId(onConflict.target[0] ?? "id", names);
-      return ` ON DUPLICATE KEY UPDATE ${col2} = ${col2}`;
-    }
-    const assignments = conflictCols.map((c) => `${this.columnId(c, names)} = ${nextValue()}`).join(", ");
-    return ` ON DUPLICATE KEY UPDATE ${assignments}`;
-  }
-  /**
-   * MySQL has no `RETURNING`, so it cannot be compiled into a statement.
-   *
-   * `session.execute()` still honors `.returning()` on a **single-row INSERT** by
-   * running the insert and reading the row back by key on the same connection —
-   * that is execution, not compilation, so it never reaches here. Compiling a
-   * node with `returning` directly is an error, rather than SQL that silently
-   * returns nothing.
-   */
-  compileReturning(returning) {
-    if (returning === null) return "";
-    throw new Error(
-      "RETURNING cannot be compiled for MySQL. session.execute() reads a single-row INSERT back by key (LAST_INSERT_ID()); UPDATE/DELETE have no equivalent \u2014 run a SELECT yourself."
-    );
-  }
-};
-function getDialect(name) {
-  switch (name) {
-    case "sqlite":
-      return new SqliteDialect();
-    case "postgresql":
-      return new PostgresDialect();
-    case "mysql":
-      return new MysqlDialect();
-  }
-}
-
-// src/join.ts
-function selectionsFor(alias, model) {
-  return Object.keys(columnsOf(model)).map((column2) => ({ alias, column: column2 }));
-}
-function withAliasNames(current, alias, model) {
-  const names = columnNamesOf(model);
-  if (!names) return current;
-  return { ...current ?? {}, [alias]: names };
-}
-var JoinBuilder = class _JoinBuilder {
-  constructor(node, sources) {
-    this.node = node;
-    this.sources = sources;
-  }
-  node;
-  sources;
-  add(clause, model) {
-    return new _JoinBuilder(
-      {
-        ...this.node,
-        joins: [...this.node.joins, clause],
-        selections: [...this.node.selections, ...selectionsFor(clause.alias, model)],
-        names: withAliasNames(this.node.names, clause.alias, model)
-      },
-      { ...this.sources, [clause.alias]: model }
-    );
-  }
-  clause(kind, model, alias, on) {
-    return {
-      kind,
-      table: model.tablename,
-      alias,
-      on: Object.entries(on)
-    };
-  }
-  /** Inner join another model under `alias`. */
-  innerJoin(model, alias, on) {
-    return this.add(
-      this.clause("inner", model, alias, on),
-      model
-    );
-  }
-  /** Left (outer) join another model under `alias` — its side becomes nullable. */
-  leftJoin(model, alias, on) {
-    return this.add(
-      this.clause("left", model, alias, on),
-      model
-    );
-  }
-  /** Filter by `alias.column` references (object form) or an `and`/`or`/`not`. */
-  where(input) {
-    return new _JoinBuilder(
-      { ...this.node, where: toCondNode(input) },
-      this.sources
-    );
-  }
-  /** Order by an `alias.column` reference. */
-  orderBy(ref, direction = "asc") {
-    return new _JoinBuilder(
-      {
-        ...this.node,
-        orderBy: [...this.node.orderBy, { ref, direction }]
-      },
-      this.sources
-    );
-  }
-  limit(n) {
-    return new _JoinBuilder({ ...this.node, limit: n }, this.sources);
-  }
-  offset(n) {
-    return new _JoinBuilder({ ...this.node, offset: n }, this.sources);
-  }
-};
-function join(model, alias) {
-  return new JoinBuilder(
-    {
-      kind: "join_select",
-      base: { table: model.tablename, alias },
-      joins: [],
-      selections: selectionsFor(alias, model),
-      where: void 0,
-      orderBy: [],
-      limit: void 0,
-      offset: void 0,
-      names: withAliasNames(void 0, alias, model)
-    },
-    { [alias]: model }
-  );
-}
-
-// src/repository.ts
-var RecordNotFound = class extends Error {
-  constructor(table, id) {
-    super(`${table} not found for id ${JSON.stringify(id)}`);
-    this.name = "RecordNotFound";
-  }
-};
-function primaryKeyOf(model) {
-  for (const [name, col2] of Object.entries(columnsOf(model))) {
-    if (col2.flags.primaryKey) return name;
-  }
-  throw new Error(`${model.tablename} has no primary key`);
-}
-var BaseRepository = class {
-  constructor(model, session) {
-    this.model = model;
-    this.session = session;
-    this.pk = primaryKeyOf(model);
-  }
-  model;
-  session;
-  pk;
-  /** All rows matching `filters` (or everything). Empty list when none match. */
-  async list(filters) {
-    const query = filters ? select(this.model).where(filters) : select(this.model);
-    return this.session.execute(query).all();
-  }
-  /** The first row matching `filters`, or `null`. */
-  async first(filters) {
-    const query = filters ? select(this.model).where(filters) : select(this.model);
-    return this.session.execute(query).first();
-  }
-  /** A single row by primary key, or `null`. */
-  async getByIdOrNull(id) {
-    return this.session.execute(select(this.model).where({ [this.pk]: id })).first();
-  }
-  /** A single row by primary key; throws `RecordNotFound` when absent. */
-  async getById(id) {
-    const row = await this.getByIdOrNull(id);
-    if (row === null) throw new RecordNotFound(this.model.tablename, id);
-    return row;
-  }
-  /** Whether any row matches `filters`. */
-  async exists(filters) {
-    return await this.first(filters) !== null;
-  }
-  /** How many rows match `filters` (or the whole table). */
-  async count(filters) {
-    const query = filters ? select(this.model, [this.pk]).where(filters) : select(this.model, [this.pk]);
-    return (await this.session.execute(query).all()).length;
-  }
-  /** Insert one row, returning the created row. */
-  async create(data) {
-    return this.session.execute(insert(this.model).values(data).returning()).one();
-  }
-  /** Insert many rows, returning the created rows. */
-  async createMany(data) {
-    if (data.length === 0) return [];
-    return this.session.execute(insert(this.model).values(data).returning()).all();
-  }
-  /** Update rows matching `filters`; returns the number of rows affected. */
-  async update(filters, set) {
-    return this.session.execute(update(this.model).set(set).where(filters)).rowsAffected();
-  }
-  /** Delete rows matching `filters`; returns the number of rows affected. */
-  async delete(filters) {
-    return this.session.execute(del(this.model).where(filters)).rowsAffected();
-  }
-  /**
-   * A page of rows plus metadata. `total` counts all matching rows.
-   *
-   * @param filter Page, size, ordering and filters.
-   * @returns The page and pagination metadata.
-   */
-  async paginate(filter = {}) {
-    const page = Math.max(1, filter.page ?? 1);
-    const pageSize = Math.max(1, filter.pageSize ?? 20);
-    const where = filter.filters;
-    let query = where ? select(this.model).where(where) : select(this.model);
-    if (filter.orderBy) {
-      query = query.orderBy(filter.orderBy, filter.ascending === false ? "desc" : "asc");
-    }
-    query = query.limit(pageSize).offset((page - 1) * pageSize);
-    const items = await this.session.execute(query).all();
-    const total = await this.count(where);
-    return {
-      items,
-      total,
-      page,
-      pageSize,
-      pages: Math.max(1, Math.ceil(total / pageSize))
-    };
-  }
-};
-
-// src/active-record.ts
-function primaryKeyOf2(model) {
-  for (const [name, col2] of Object.entries(columnsOf(model))) {
-    if (col2.flags.primaryKey) return name;
-  }
-  throw new Error(`${model.tablename} has no primary key`);
-}
-var ActiveRecord = class {
-  constructor(model, session, data) {
-    this.model = model;
-    this.session = session;
-    this.data = data;
-    this.pk = primaryKeyOf2(model);
-  }
-  model;
-  session;
-  data;
-  pk;
-  /** The primary-key value of the wrapped row. */
-  pkValue() {
-    return this.data[this.pk];
-  }
-  pkFilter() {
-    return { [this.pk]: this.pkValue() };
-  }
-  /**
-   * Persist the current `data` — insert if new, otherwise overwrite the existing
-   * row (upsert on the primary key). Refreshes `data` from the returned row.
-   *
-   * @returns This wrapper, for chaining.
-   */
-  async save() {
-    const cols = columnsOf(this.model);
-    const rowData = this.data;
-    const setPatch = {};
-    for (const c of Object.keys(rowData)) {
-      if (c !== this.pk && c in cols) setPatch[c] = rowData[c];
-    }
-    const saved = await this.session.execute(
-      insert(this.model).values(this.data).onConflictDoUpdate(
-        [this.pk],
-        setPatch
-      ).returning()
-    ).one();
-    this.data = saved;
-    return this;
-  }
-  /**
-   * Update the given columns for this row and merge them into `data`.
-   *
-   * @param patch The columns to change.
-   * @returns This wrapper, for chaining.
-   */
-  async update(patch) {
-    await this.session.execute(update(this.model).set(patch).where(this.pkFilter()));
-    this.data = { ...this.data, ...patch };
-    return this;
-  }
-  /**
-   * Delete this row.
-   *
-   * @returns The number of rows affected (0 or 1).
-   */
-  async delete() {
-    return this.session.execute(del(this.model).where(this.pkFilter())).rowsAffected();
-  }
-  /**
-   * Re-fetch this row by primary key and refresh `data`.
-   *
-   * @returns This wrapper, for chaining.
-   * @throws When the row no longer exists.
-   */
-  async reload() {
-    const fresh = await this.session.execute(select(this.model).where(this.pkFilter())).first();
-    if (fresh === null) {
-      throw new Error(
-        `${this.model.tablename} row ${JSON.stringify(this.pkValue())} not found on reload`
-      );
-    }
-    this.data = fresh;
-    return this;
-  }
-};
-function activeRecord(model, session) {
-  const pk = primaryKeyOf2(model);
-  return {
-    wrap: (row) => new ActiveRecord(model, session, row),
-    create: (data) => new ActiveRecord(model, session, data),
-    async get(id) {
-      const row = await session.execute(select(model).where({ [pk]: id })).first();
-      return row === null ? null : new ActiveRecord(model, session, row);
-    }
-  };
-}
-
-// src/relations.ts
-function hasMany(target, keys) {
-  return {
-    kind: "hasMany",
-    target,
-    localKey: keys.localKey,
-    foreignKey: keys.foreignKey
-  };
-}
-function belongsTo(target, keys) {
-  return {
-    kind: "belongsTo",
-    target,
-    localKey: keys.localKey,
-    foreignKey: keys.foreignKey
-  };
-}
-async function loadRelations(session, rows, spec) {
-  const out = rows.map((r) => ({ ...r }));
-  for (const [name, rel] of Object.entries(spec)) {
-    const target = rel.target();
-    const localValues = [...new Set(rows.map((r) => r[rel.localKey]))];
-    const related = localValues.length > 0 ? await session.execute(
-      select(target).where({
-        [rel.foreignKey]: { in: localValues }
-      })
-    ).all() : [];
-    if (rel.kind === "hasMany") {
-      const grouped = /* @__PURE__ */ new Map();
-      for (const row of related) {
-        const key = row[rel.foreignKey];
-        const list = grouped.get(key) ?? [];
-        list.push(row);
-        grouped.set(key, list);
-      }
-      out.forEach((r, i) => {
-        r[name] = grouped.get(rows[i]?.[rel.localKey]) ?? [];
-      });
-    } else {
-      const byKey = /* @__PURE__ */ new Map();
-      for (const row of related) {
-        byKey.set(row[rel.foreignKey], row);
-      }
-      out.forEach((r, i) => {
-        r[name] = byKey.get(rows[i]?.[rel.localKey]) ?? null;
-      });
-    }
-  }
-  return out;
-}
-var nodeRequire = createRequire(import.meta.url);
-function encodeSqliteParam(value) {
-  if (value === void 0 || value === null) return null;
-  if (typeof value === "boolean") return value ? 1 : 0;
-  if (value instanceof Date) return value.toISOString();
-  if (value instanceof Uint8Array) return value;
-  if (typeof value === "object") return JSON.stringify(value);
-  return value;
-}
-var NodeSqliteDriver = class _NodeSqliteDriver {
-  // biome-ignore lint/suspicious/noExplicitAny: node:sqlite DatabaseSync has no shipped types here.
-  db;
-  /**
-   * Prepared-statement cache keyed by SQL text. tempest-db-js always
-   * parameterizes, so a query shape maps to one stable SQL string — reusing the
-   * compiled statement avoids re-`prepare()` on every call (the dominant cost of
-   * per-row inserts and point lookups).
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: node:sqlite StatementSync has no shipped types here.
-  statements = /* @__PURE__ */ new Map();
-  // biome-ignore lint/suspicious/noExplicitAny: accept an already-open DatabaseSync handle.
-  constructor(database) {
-    this.db = database;
-  }
-  /**
-   * Open a `node:sqlite` database at the given path (or `:memory:`).
-   *
-   * @param path The database file, or `":memory:"`.
-   * @param options Passed straight to `DatabaseSync` (`readOnly`, `timeout`, …).
-   * @returns A driver over the open handle.
-   */
-  static open(path, options) {
-    const { DatabaseSync } = nodeRequire("node:sqlite");
-    return new _NodeSqliteDriver(
-      options ? new DatabaseSync(path, { ...options }) : new DatabaseSync(path)
-    );
-  }
-  /** Return the cached prepared statement for `sql`, preparing it on first use. */
-  // biome-ignore lint/suspicious/noExplicitAny: statement type is unavailable here.
-  prepare(sql2) {
-    const cached = this.statements.get(sql2);
-    if (cached) return cached;
-    const stmt = this.db.prepare(sql2);
-    this.statements.set(sql2, stmt);
-    return stmt;
-  }
-  execute(sql2, params) {
-    const stmt = this.prepare(sql2);
-    const bound = params.map(encodeSqliteParam);
-    if (returnsRows(sql2)) {
-      return { rows: stmt.all(...bound), changes: 0 };
-    }
-    const info = stmt.run(...bound);
-    return { rows: [], changes: Number(info.changes ?? 0) };
-  }
-  *iterate(sql2, params) {
-    const stmt = this.prepare(sql2);
-    const bound = params.map(encodeSqliteParam);
-    yield* stmt.iterate(...bound);
-  }
-  close() {
-    this.statements.clear();
-    this.db.close();
-  }
-};
-function returnsRows(sql2) {
-  return /^\s*(select|pragma)/i.test(sql2) || /\breturning\b/i.test(sql2);
-}
-function splitJoinRow(node, sources, raw) {
-  const leftAliases = new Set(
-    node.joins.filter((j) => j.kind === "left").map((j) => j.alias)
-  );
-  const out = {};
-  for (const [alias, model] of Object.entries(sources)) {
-    const sub = {};
-    const names = columnNamesOf(model);
-    let allNull = true;
-    for (const colName of Object.keys(columnsOf(model))) {
-      const value = raw[`${alias}.${colName}`];
-      if (value !== null && value !== void 0) allNull = false;
-      sub[names?.[colName] ?? colName] = value;
-    }
-    out[alias] = leftAliases.has(alias) && allNull ? null : coerceRow(model, sub);
-  }
-  return out;
-}
-function coerceOne(builder, raw) {
-  const node = builder.node;
-  if (node.kind === "join_select") {
-    const b2 = builder;
-    return splitJoinRow(b2.node, b2.sources, raw);
-  }
-  const b = builder;
-  return coerceRow(b.source, raw);
-}
-function mapRows(builder, raw) {
-  return raw.map((r) => coerceOne(builder, r));
-}
-var NoResultError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "NoResultError";
-  }
-};
-function previewParam(value) {
-  if (value === null || value === void 0) return "null";
-  if (value instanceof Uint8Array) return `<${value.length} bytes>`;
-  const text = typeof value === "string" ? value : String(value);
-  return text.length > 64 ? `${text.slice(0, 61)}...` : text;
-}
-var QueryExecutionError = class extends Error {
-  constructor(cause, sql2, params) {
-    const reason = cause instanceof Error ? cause.message : String(cause);
-    super(
-      `Query failed: ${reason}
-  SQL: ${sql2}
-  params: [${params.map(previewParam).join(", ")}]`
-    );
-    this.cause = cause;
-    this.sql = sql2;
-    this.params = params;
-    this.name = "QueryExecutionError";
-  }
-  cause;
-  sql;
-  params;
-};
-function emitLog(logger, sql2, params) {
-  if (!logger) return;
-  try {
-    logger({ sql: sql2, params });
-  } catch {
-  }
-}
-function firstScalar(row) {
-  if (!row) return null;
-  const keys = Object.keys(row);
-  return keys.length > 0 ? row[keys[0]] : null;
-}
-var SyncResult = class {
-  constructor(rows, changes) {
-    this.rows = rows;
-    this.changes = changes;
-  }
-  rows;
-  changes;
-  all() {
-    return this.rows;
-  }
-  first() {
-    return this.rows[0] ?? null;
-  }
-  one() {
-    if (this.rows.length !== 1) {
-      throw new NoResultError(`expected exactly one row, got ${this.rows.length}`);
-    }
-    return this.rows[0];
-  }
-  oneOrNull() {
-    if (this.rows.length > 1) {
-      throw new NoResultError(`expected at most one row, got ${this.rows.length}`);
-    }
-    return this.rows[0] ?? null;
-  }
-  scalar() {
-    return firstScalar(this.rows[0]);
-  }
-  scalars() {
-    return this.rows.map((r) => firstScalar(r));
-  }
-  rowsAffected() {
-    return this.changes;
-  }
-};
-var AsyncResult = class {
-  constructor(inner) {
-    this.inner = inner;
-  }
-  inner;
-  async all() {
-    return (await this.inner).all();
-  }
-  async first() {
-    return (await this.inner).first();
-  }
-  async one() {
-    return (await this.inner).one();
-  }
-  async oneOrNull() {
-    return (await this.inner).oneOrNull();
-  }
-  async scalar() {
-    return (await this.inner).scalar();
-  }
-  async scalars() {
-    return (await this.inner).scalars();
-  }
-  async rowsAffected() {
-    return (await this.inner).rowsAffected();
-  }
-};
-var savepointCounter = 0;
-function needsInsertReadBack(dialect, node) {
-  return dialect.name === "mysql" && node.kind === "insert" && node.returning !== null;
-}
-function singlePrimaryKey(model) {
-  const keys = Object.entries(columnsOf(model)).filter(([, column2]) => column2.flags.primaryKey).map(([name]) => name);
-  if (keys.length !== 1) {
-    throw new Error(
-      `${model.tablename} needs exactly one primary key to read an insert back on a dialect without RETURNING; found ${keys.length}.`
-    );
-  }
-  return keys[0];
-}
-function assertRawParams(params) {
-  if (!Array.isArray(params)) {
-    throw new TypeError(
-      "session.raw(sql, params) takes an array of bound parameters \u2014 never interpolate values into the SQL string."
-    );
-  }
-}
-var SyncSession = class {
-  constructor(driver, dialect, logger) {
-    this.driver = driver;
-    this.dialect = dialect;
-    this.logger = logger;
-  }
-  driver;
-  dialect;
-  logger;
-  /** Log, run, and error-wrap one raw statement. */
-  exec(sql2, params) {
-    emitLog(this.logger, sql2, params);
-    try {
-      return this.driver.execute(sql2, params);
-    } catch (error) {
-      throw new QueryExecutionError(error, sql2, params);
-    }
-  }
-  /**
-   * Run a raw, parameterized SQL statement (synchronous) — the runtime counterpart of the
-   * migrations' `Op.execute`.
-   *
-   * A query builder never covers all of SQL, and without an escape hatch a single
-   * unsupported query forces a whole second database stack alongside this one. Use
-   * it for what the builder cannot yet express, and keep everything else typed.
-   *
-   * The statement goes through the same path as a compiled one: it is logged via
-   * `onQuery`, wrapped in {@link QueryExecutionError} on failure, and runs on the
-   * reserved connection inside `transaction()`.
-   *
-   * @param sql The statement text. Placeholders only (`$1` / `?` per dialect) —
-   *   never interpolate a value into this string.
-   * @param params The bound parameters, in placeholder order.
-   * @param options Pass `as` to coerce the returned rows with a model's column
-   *   types (and its column-name mapping).
-   * @returns The result view over the returned rows.
-   * @throws Error When `params` is not an array — the guard against calling this
-   *   with an interpolated string and no parameters by mistake.
-   *
-   * @example
-   * ```ts
-   * const claimed = await session.raw<OutboundRow>(
-   *   `UPDATE outbound_messages SET status = 'sending'
-   *      WHERE id = ANY($1) RETURNING *`,
-   *   [ids],
-   *   { as: Outbound },
-   * ).all();
-   * ```
-   */
-  raw(sql2, params = [], options) {
-    assertRawParams(params);
-    const result = this.exec(sql2, params);
-    const model = options?.as;
-    const rows = model ? result.rows.map((row) => coerceRow(model, row)) : result.rows;
-    return new SyncResult(rows, result.changes);
-  }
-  /** Compile, run, and coerce a builder into a result. */
-  execute(builder) {
-    const node = builder.node;
-    const { sql: sql2, params } = this.dialect.compile(node);
-    const result = this.exec(sql2, params);
-    const rows = mapRows(builder, result.rows);
-    return new SyncResult(rows, result.changes);
-  }
-  /** Run `fn` inside a transaction: commit on success, rollback on throw. */
-  transaction(fn2) {
-    this.exec("BEGIN", []);
-    try {
-      const out = fn2(this);
-      this.exec("COMMIT", []);
-      return out;
-    } catch (error) {
-      this.exec("ROLLBACK", []);
-      throw error;
-    }
-  }
-  /** Run `fn` inside a SAVEPOINT (nested transaction). */
-  beginNested(fn2) {
-    savepointCounter += 1;
-    const name = `qsp_${savepointCounter}`;
-    this.exec(`SAVEPOINT ${name}`, []);
-    try {
-      const out = fn2(this);
-      this.exec(`RELEASE ${name}`, []);
-      return out;
-    } catch (error) {
-      this.exec(`ROLLBACK TO ${name}`, []);
-      throw error;
-    }
-  }
-  /**
-   * Lazily iterate result rows without materializing them all. Falls back to a
-   * buffered fetch when the driver has no native iteration.
-   */
-  *stream(builder) {
-    const node = builder.node;
-    const { sql: sql2, params } = this.dialect.compile(node);
-    emitLog(this.logger, sql2, params);
-    if (this.driver.iterate) {
-      try {
-        for (const raw of this.driver.iterate(sql2, params)) {
-          yield coerceOne(builder, raw);
-        }
-      } catch (error) {
-        throw new QueryExecutionError(error, sql2, params);
-      }
-      return;
-    }
-    for (const raw of this.exec(sql2, params).rows) {
-      yield coerceOne(builder, raw);
-    }
-  }
-  close() {
-    this.driver.close();
-  }
-  /** `using session = ...` closes the driver when the scope exits. */
-  [Symbol.dispose]() {
-    this.close();
-  }
-};
-var AsyncSession = class _AsyncSession {
-  constructor(driver, dialect, logger) {
-    this.driver = driver;
-    this.dialect = dialect;
-    this.logger = logger;
-  }
-  driver;
-  dialect;
-  logger;
-  /** Log, run, and error-wrap one raw statement. */
-  async exec(sql2, params) {
-    emitLog(this.logger, sql2, params);
-    try {
-      return await this.driver.execute(sql2, params);
-    } catch (error) {
-      throw new QueryExecutionError(error, sql2, params);
-    }
-  }
-  /**
-   * Run a raw, parameterized SQL statement — the runtime counterpart of the
-   * migrations' `Op.execute`.
-   *
-   * A query builder never covers all of SQL, and without an escape hatch a single
-   * unsupported query forces a whole second database stack alongside this one. Use
-   * it for what the builder cannot yet express, and keep everything else typed.
-   *
-   * The statement goes through the same path as a compiled one: it is logged via
-   * `onQuery`, wrapped in {@link QueryExecutionError} on failure, and runs on the
-   * reserved connection inside `transaction()`.
-   *
-   * @param sql The statement text. Placeholders only (`$1` / `?` per dialect) —
-   *   never interpolate a value into this string.
-   * @param params The bound parameters, in placeholder order.
-   * @param options Pass `as` to coerce the returned rows with a model's column
-   *   types (and its column-name mapping).
-   * @returns The result view over the returned rows.
-   * @throws Error When `params` is not an array — the guard against calling this
-   *   with an interpolated string and no parameters by mistake.
-   *
-   * @example
-   * ```ts
-   * const claimed = await session.raw<OutboundRow>(
-   *   `UPDATE outbound_messages SET status = 'sending'
-   *      WHERE id = ANY($1) RETURNING *`,
-   *   [ids],
-   *   { as: Outbound },
-   * ).all();
-   * ```
-   */
-  raw(sql2, params = [], options) {
-    assertRawParams(params);
-    const model = options?.as;
-    const inner = this.exec(sql2, params).then((result) => {
-      const rows = model ? result.rows.map((row) => coerceRow(model, row)) : result.rows;
-      return new SyncResult(rows, result.changes);
-    });
-    return new AsyncResult(inner);
-  }
-  execute(builder) {
-    const node = builder.node;
-    if (needsInsertReadBack(this.dialect, node)) {
-      return new AsyncResult(
-        this.insertAndReadBack(builder, node)
-      );
-    }
-    const { sql: sql2, params } = this.dialect.compile(node);
-    const inner = this.exec(sql2, params).then((result) => {
-      const rows = mapRows(builder, result.rows);
-      return new SyncResult(rows, result.changes);
-    });
-    return new AsyncResult(inner);
-  }
-  /**
-   * Honor `.returning()` on a dialect without `RETURNING`, by inserting and then
-   * reading the row back by key.
-   *
-   * Both statements must run on **one** connection, because `LAST_INSERT_ID()` is
-   * per-connection: outside a transaction the pooled driver is reserved for the
-   * pair; inside one, the session already holds a pinned connection (a reserved
-   * driver exposes no `reserve`), so it runs there directly.
-   *
-   * @param builder The insert builder, for its source model.
-   * @param node The insert AST, whose `returning` drives the read-back.
-   * @returns The result view over the read-back row.
-   * @throws Error When the insert writes more than one row — `LAST_INSERT_ID()`
-   *   identifies only the first, and the rest are consecutive only under some
-   *   auto-increment lock modes.
-   */
-  async insertAndReadBack(builder, node) {
-    if (node.values.length !== 1) {
-      throw new Error(
-        `${this.dialect.name} has no RETURNING, and reading back a multi-row insert is not reliable \u2014 insert one row at a time, or drop .returning().`
-      );
-    }
-    const model = builder.source;
-    const pk = singlePrimaryKey(model);
-    const supplied = node.values[0][pk];
-    const readBack = select(model).where(
-      supplied === void 0 || supplied === null ? col(pk).eq(fn.call("LAST_INSERT_ID")) : { [pk]: supplied }
-    );
-    const insertSql = this.dialect.compile({ ...node, returning: null });
-    const selectSql = this.dialect.compile(
-      node.returning === "*" || node.returning === null ? readBack.node : { ...readBack.node, columns: node.returning }
-    );
-    const run = async (driver) => {
-      const scoped = new _AsyncSession(driver, this.dialect, this.logger);
-      const written = await scoped.exec(insertSql.sql, insertSql.params);
-      const read = await scoped.exec(selectSql.sql, selectSql.params);
-      const rows = read.rows.map((row) => coerceRow(model, row));
-      return new SyncResult(rows, written.changes);
-    };
-    if (!this.driver.reserve) return run(this.driver);
-    const reserved = await this.driver.reserve();
-    try {
-      return await run(reserved);
-    } finally {
-      await reserved.release();
-    }
-  }
-  /** Lazily iterate result rows. Uses driver streaming when available. */
-  async *stream(builder) {
-    const node = builder.node;
-    const { sql: sql2, params } = this.dialect.compile(node);
-    emitLog(this.logger, sql2, params);
-    if (this.driver.iterate) {
-      try {
-        for await (const raw of this.driver.iterate(sql2, params)) {
-          yield coerceOne(builder, raw);
-        }
-      } catch (error) {
-        throw new QueryExecutionError(error, sql2, params);
-      }
-      return;
-    }
-    const result = await this.exec(sql2, params);
-    for (const raw of result.rows) {
-      yield coerceOne(builder, raw);
-    }
-  }
-  async transaction(fn2) {
-    if (this.driver.reserve) {
-      const reserved = await this.driver.reserve();
-      const scoped = new _AsyncSession(reserved, this.dialect, this.logger);
-      try {
-        await scoped.exec("BEGIN", []);
-        const out = await fn2(scoped);
-        await scoped.exec("COMMIT", []);
-        return out;
-      } catch (error) {
-        await scoped.exec("ROLLBACK", []);
-        throw error;
-      } finally {
-        await reserved.release();
-      }
-    }
-    await this.exec("BEGIN", []);
-    try {
-      const out = await fn2(this);
-      await this.exec("COMMIT", []);
-      return out;
-    } catch (error) {
-      await this.exec("ROLLBACK", []);
-      throw error;
-    }
-  }
-  async close() {
-    await this.driver.close();
-  }
-  /** `await using session = ...` closes the driver when the scope exits. */
-  async [Symbol.asyncDispose]() {
-    await this.close();
-  }
-};
-function emitNotice(logger, notice) {
-  if (!logger) return;
-  try {
-    logger(notice);
-  } catch {
-  }
-}
-var SyncEngine = class {
-  constructor(driver, logger) {
-    this.driver = driver;
-    this.logger = logger;
-  }
-  driver;
-  logger;
-  dialect = "sqlite";
-  session() {
-    return new SyncSession(this.driver, getDialect("sqlite"), this.logger);
-  }
-  transaction(fn2) {
-    return this.session().transaction(fn2);
-  }
-  close() {
-    this.driver.close();
-  }
-  /** `using engine = createSyncEngine(...)` closes the pool when the scope exits. */
-  [Symbol.dispose]() {
-    this.close();
-  }
-};
-var AsyncEngine = class {
-  constructor(driver, dialect, logger) {
-    this.driver = driver;
-    this.dialect = dialect;
-    this.logger = logger;
-  }
-  driver;
-  dialect;
-  logger;
-  session() {
-    return new AsyncSession(this.driver, getDialect(this.dialect), this.logger);
-  }
-  transaction(fn2) {
-    return this.session().transaction(fn2);
-  }
-  async close() {
-    await this.driver.close();
-  }
-  /** `await using engine = createEngine(...)` closes the pool when the scope exits. */
-  async [Symbol.asyncDispose]() {
-    await this.close();
-  }
-};
-function toAsyncDriver(driver) {
-  return {
-    async execute(sql2, params) {
-      return await driver.execute(sql2, params);
-    },
-    async close() {
-      await driver.close();
-    }
-  };
-}
-function asAsync(driver) {
-  const syncIterate = driver.iterate?.bind(driver);
-  return {
-    execute: (sql2, params) => Promise.resolve(driver.execute(sql2, params)),
-    close: () => Promise.resolve(driver.close()),
-    ...syncIterate ? {
-      iterate: async function* (sql2, params) {
-        yield* syncIterate(sql2, params);
-      }
-    } : {}
-  };
-}
-function openSqliteDriver(path, options) {
-  return NodeSqliteDriver.open(path, options?.driverOptions);
-}
-function createSyncEngine(url, options) {
-  const parsed = parseDatabaseUrl(url);
-  if (parsed.dialect !== "sqlite") {
-    throw new Error(
-      `createSyncEngine supports only SQLite; ${parsed.dialect} is async-only \u2014 use createEngine.`
-    );
-  }
-  return new SyncEngine(
-    openSqliteDriver(parsed.database ?? ":memory:", options),
-    options?.onQuery
-  );
-}
-function createEngine(url, options) {
-  const parsed = parseDatabaseUrl(url);
-  if (parsed.dialect === "sqlite") {
-    return new AsyncEngine(
-      asAsync(openSqliteDriver(parsed.database ?? ":memory:", options)),
-      "sqlite",
-      options?.onQuery
-    );
-  }
-  if (parsed.dialect === "mysql") {
-    return new AsyncEngine(
-      createMysqlDriver(parsed.raw, options),
-      "mysql",
-      options?.onQuery
-    );
-  }
-  return new AsyncEngine(
-    createPostgresDriver(parsed.raw, options),
-    "postgresql",
-    options?.onQuery
-  );
-}
-function encodeMysqlParam(value) {
-  if (value === void 0 || value === null) return null;
-  if (typeof value === "boolean") return value ? 1 : 0;
-  if (value instanceof Uint8Array) return value;
-  if (value instanceof Date) return value;
-  if (typeof value === "object") return JSON.stringify(value);
-  return value;
-}
-function toMysqlResult(rows) {
-  if (Array.isArray(rows)) {
-    return { rows, changes: 0 };
-  }
-  const header = rows;
-  return { rows: [], changes: header.affectedRows ?? 0 };
-}
-function createMysqlDriver(url, options) {
-  const pool = options?.pool;
-  let poolHandle;
-  const ensure = async () => {
-    if (poolHandle) return;
-    const moduleName = "mysql2/promise";
-    const mod = await import(
-      /* @vite-ignore */
-      moduleName
-    );
-    const opts = { uri: url };
-    if (pool?.size !== void 0) opts.connectionLimit = pool.size;
-    if (pool?.idleTimeoutMs !== void 0) opts.idleTimeout = pool.idleTimeoutMs;
-    if (pool?.connectTimeoutMs !== void 0) opts.connectTimeout = pool.connectTimeoutMs;
-    Object.assign(opts, options?.driverOptions ?? {});
-    poolHandle = mod.createPool(opts);
-  };
-  const runOn = async (queryable, sql2, params) => {
-    const [rows] = await queryable.query(sql2, params.map(encodeMysqlParam));
-    return toMysqlResult(rows);
-  };
-  return {
-    async execute(sql2, params) {
-      await ensure();
-      return runOn(poolHandle, sql2, params);
-    },
-    async reserve() {
-      await ensure();
-      const conn = await poolHandle.getConnection();
-      return {
-        execute: (sql2, params) => runOn(conn, sql2, params),
-        async release() {
-          conn.release();
-        },
-        async close() {
-          conn.release();
-        }
-      };
-    },
-    async close() {
-      if (poolHandle) await poolHandle.end();
-    }
-  };
-}
-function toPostgresResult(rows) {
-  const arr = rows;
-  return { rows: Array.from(arr), changes: arr.count ?? arr.length };
-}
-function createPostgresDriver(url, options) {
-  const pool = options?.pool;
-  let client;
-  const ensure = async () => {
-    if (client) return;
-    const moduleName = "postgres";
-    const mod = await import(
-      /* @vite-ignore */
-      moduleName
-    );
-    const opts = {};
-    if (pool?.size !== void 0) opts.max = pool.size;
-    if (pool?.idleTimeoutMs !== void 0)
-      opts.idle_timeout = Math.ceil(pool.idleTimeoutMs / 1e3);
-    if (pool?.connectTimeoutMs !== void 0) {
-      opts.connect_timeout = Math.ceil(pool.connectTimeoutMs / 1e3);
-    }
-    opts.onnotice = (notice) => emitNotice(options?.onNotice, notice);
-    Object.assign(opts, options?.driverOptions ?? {});
-    client = (mod.default ?? mod)(url, opts);
-  };
-  return {
-    async execute(sql2, params) {
-      await ensure();
-      return toPostgresResult(await client.unsafe(sql2, params));
-    },
-    async reserve() {
-      await ensure();
-      const conn = await client.reserve();
-      return {
-        async execute(sql2, params) {
-          return toPostgresResult(await conn.unsafe(sql2, params));
-        },
-        async release() {
-          conn.release();
-        },
-        async close() {
-          conn.release();
-        }
-      };
-    },
-    async close() {
-      if (client) await client.end();
-    }
-  };
-}
-
-// src/index.ts
-var DEFAULT_FLAGS = {
-  primaryKey: false,
-  notNull: false,
-  hasDefault: false,
-  unique: false
-};
-var EXPRESSION = /* @__PURE__ */ Symbol.for("tempest-db-js.expression");
-function expression(token, params = []) {
-  return { [EXPRESSION]: true, kind: "expression", expression: token, params };
-}
-function isSqlExpression(value) {
-  return typeof value === "object" && value !== null && value[EXPRESSION] === true;
-}
-var sql = {
-  /** Current timestamp at insert (`CURRENT_TIMESTAMP` / `now()`). */
-  now: () => expression("now"),
-  /** Current date. */
-  currentDate: () => expression("current_date"),
-  /** Current time. */
-  currentTime: () => expression("current_time"),
-  /** A freshly generated UUID v4 (`gen_random_uuid()` / portable fallback). */
-  uuidv4: () => expression("uuidv4"),
-  /**
-   * Escape hatch: a verbatim SQL expression rendered as-is, with no parameters.
-   *
-   * The fragment is interpolated into the statement untouched, so it must never
-   * carry user input — use {@link sql.expr} when a value has to be bound.
-   *
-   * @param fragment The SQL text (e.g. `"attempts + 1"`).
-   * @returns The expression, usable as a default and as a write value.
-   */
-  raw: (fragment) => expression({ raw: fragment }),
-  /**
-   * A parameterized SQL expression, written as a tagged template. Static text is
-   * SQL; every `${...}` interpolation becomes a bound parameter, so the fragment
-   * is injection-safe by construction.
-   *
-   * Cannot be used as a column default — a `DEFAULT` clause has nowhere to bind
-   * parameters; use {@link sql.raw} there.
-   *
-   * @param parts The static SQL segments supplied by the template tag.
-   * @param values The interpolated values, bound in order.
-   * @returns The expression, usable as a write value.
-   *
-   * @example
-   * ```ts
-   * update(Account).set({ balance: sql.expr`balance - ${amount}` }).where({ id });
-   * // UPDATE "accounts" SET "balance" = balance - $1 WHERE "id" = $2
-   * ```
-   */
-  expr: (parts, ...values) => expression({ parts: Array.from(parts) }, values)
-};
-function isDefaultValue(value) {
-  return typeof value === "object" && value !== null && "kind" in value && (value.kind === "literal" || value.kind === "expression");
-}
-function bindsParameters(value) {
-  return value.kind === "expression" && typeof value.expression === "object" && "parts" in value.expression;
-}
-function parseReference(ref, options) {
-  const dot = ref.lastIndexOf(".");
-  if (dot <= 0 || dot === ref.length - 1) {
-    throw new Error(`Invalid foreign key reference "${ref}"; expected "table.column".`);
-  }
-  return {
-    table: ref.slice(0, dot),
-    column: ref.slice(dot + 1),
-    onDelete: options?.onDelete,
-    onUpdate: options?.onUpdate
-  };
-}
-var Column = class _Column {
-  constructor(type, flags, defaultValue = null, onUpdateValue = null, reference = null, dbName = null) {
-    this.type = type;
-    this.flags = flags;
-    this.defaultValue = defaultValue;
-    this.onUpdateValue = onUpdateValue;
-    this.reference = reference;
-    this.dbName = dbName;
-  }
-  type;
-  flags;
-  defaultValue;
-  onUpdateValue;
-  reference;
-  dbName;
-  /** Clone this column with one facet replaced, carrying every other over. */
-  derive(patch) {
-    return new _Column(
-      this.type,
-      patch.flags ?? this.flags,
-      patch.defaultValue !== void 0 ? patch.defaultValue : this.defaultValue,
-      patch.onUpdateValue !== void 0 ? patch.onUpdateValue : this.onUpdateValue,
-      patch.reference !== void 0 ? patch.reference : this.reference,
-      patch.dbName !== void 0 ? patch.dbName : this.dbName
-    );
-  }
-  primaryKey() {
-    return this.derive({ flags: { ...this.flags, primaryKey: true, hasDefault: true } });
-  }
-  notNull() {
-    return this.derive({ flags: { ...this.flags, notNull: true } });
-  }
-  /**
-   * Add a `UNIQUE` constraint to the column (mirrors SQLAlchemy's
-   * `mapped_column(unique=True)`). DDL-only — does not change the inferred type.
-   */
-  unique() {
-    return this.derive({ flags: { ...this.flags, unique: true } });
-  }
-  /**
-   * Map this property to a differently-named database column, à la SQLAlchemy's
-   * `mapped_column("consumer_name")` (Django's `db_column`, Prisma's `@map`).
-   *
-   * The override applies everywhere the name reaches SQL — select, insert,
-   * update, delete, where, order by, group by, returning, conflict targets, the
-   * migration IR and the drift check — while the TypeScript row keeps the
-   * property name. Use it to keep a `snake_case` schema behind a `camelCase`
-   * model; {@link Model.naming} does the same for a whole table at once.
-   *
-   * @param dbName The real column name in the database.
-   * @returns A new column bound to that name.
-   * @throws Error When `dbName` is empty.
-   *
-   * @example
-   * ```ts
-   * class ApiKey extends Model {
-   *   static tablename = "api_keys";
-   *   consumerName = column.text().name("consumer_name").notNull();
-   * }
-   * ```
-   */
-  name(dbName) {
-    if (dbName.length === 0) {
-      throw new Error("column.name() requires a non-empty database column name.");
-    }
-    return this.derive({ dbName });
-  }
-  /**
-   * Declare a foreign-key reference to another table's column, à la SQLAlchemy's
-   * `mapped_column(ForeignKey("table.column", ondelete=...))`. DDL-only — does
-   * not change the inferred type.
-   *
-   * @param ref The target as `"table.column"` (e.g. `"users.id"`).
-   * @param options Optional `onDelete` / `onUpdate` referential actions.
-   * @returns A new column carrying the reference.
-   * @throws Error When `ref` is not a valid `"table.column"` string.
-   */
-  references(ref, options) {
-    return this.derive({ reference: parseReference(ref, options) });
-  }
-  /**
-   * Set the insert-time default: a constant value of type `T`, or a portable
-   * server-side expression from {@link sql} (e.g. `sql.now()`, `sql.uuidv4()`).
-   *
-   * @param value The literal default, or a {@link sql} expression.
-   * @returns A new column carrying the default.
-   * @throws Error When given a `sql.expr` fragment — a `DEFAULT` clause has
-   *   nowhere to bind parameters; use `sql.raw()` for a verbatim expression.
-   */
-  default(value) {
-    const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
-    if (bindsParameters(resolved)) {
-      throw new Error(
-        "sql.expr`...` binds parameters and cannot be a column default \u2014 use sql.raw() for a verbatim DEFAULT expression."
-      );
-    }
-    return this.derive({
-      flags: { ...this.flags, hasDefault: true },
-      defaultValue: resolved
-    });
-  }
-  /**
-   * Re-apply a value whenever the row is updated (e.g. an `updated_at` column
-   * with `sql.now()`). Mirrors SQLAlchemy's `onupdate`.
-   *
-   * @param value The literal value, or a {@link sql} expression.
-   * @returns A new column carrying the on-update value.
-   * @throws Error When given a `sql.expr` fragment (see {@link Column.default}).
-   */
-  onUpdate(value) {
-    const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
-    if (bindsParameters(resolved)) {
-      throw new Error(
-        "sql.expr`...` binds parameters and cannot be an onUpdate default \u2014 use sql.raw() for a verbatim expression."
-      );
-    }
-    return this.derive({ onUpdateValue: resolved });
-  }
-};
-function makeColumn(kind, meta = {}) {
-  return new Column({ kind, meta }, DEFAULT_FLAGS);
-}
-var column = {
-  /** `SMALLINT` → `number`. */
-  smallInteger: () => makeColumn("smallint"),
-  /** `INTEGER` → `number`. */
-  integer: () => makeColumn("integer"),
-  /** `BIGINT` → `bigint` (64-bit precision preserved). */
-  bigInteger: () => makeColumn("bigint"),
-  /** `NUMERIC(precision, scale)` → `string` (exact decimal, no float loss). */
-  numeric: (precision, scale) => makeColumn("numeric", { precision, scale }),
-  /** Alias of {@link column.numeric}. */
-  decimal: (precision, scale) => makeColumn("numeric", { precision, scale }),
-  /** `REAL` → `number`. */
-  real: () => makeColumn("real"),
-  /** `DOUBLE PRECISION` → `number`. */
-  double: () => makeColumn("double"),
-  /** `VARCHAR(length)` → `string`. Distinct from {@link column.text}. */
-  varchar: (length) => makeColumn("varchar", { length }),
-  /** Alias of {@link column.varchar} (SQLAlchemy's `String`). */
-  string: (length) => makeColumn("varchar", { length }),
-  /** `CHAR(length)` → `string` (fixed-width). */
-  char: (length) => makeColumn("char", { length }),
-  /** `TEXT` → `string` (unbounded). Distinct from {@link column.varchar}. */
-  text: () => makeColumn("text"),
-  /** `BOOLEAN` → `boolean`. */
-  boolean: () => makeColumn("boolean"),
-  /** `DATE` → `Date`. */
-  date: () => makeColumn("date"),
-  /** `TIME` → `string`. Pass `{ timezone: true }` for `WITH TIME ZONE`. */
-  time: (options) => makeColumn("time", { withTimezone: options?.timezone }),
-  /**
-   * `DATETIME`/`TIMESTAMP` → `Date` (SQLAlchemy's generic `DateTime`). Pass
-   * `{ timezone: true }` for `WITH TIME ZONE`. Pair with `.default(sql.now())`
-   * and `.onUpdate(sql.now())` for managed `created_at`/`updated_at` columns.
-   */
-  datetime: (options) => makeColumn("datetime", { withTimezone: options?.timezone }),
-  /** `TIMESTAMP` → `Date` (SQL-specific). Pass `{ timezone: true }`. */
-  timestamp: (options) => makeColumn("timestamp", { withTimezone: options?.timezone }),
-  /** `BLOB`/`BYTEA` → `Uint8Array`. */
-  blob: () => makeColumn("blob"),
-  /** `JSON` → the given parsed value type `T` (defaults to `unknown`). */
-  json: () => makeColumn("json"),
-  /** `JSONB` (PostgreSQL) → the given parsed value type `T`. */
-  jsonb: () => makeColumn("json", { jsonb: true }),
-  /** `UUID` → `string`. */
-  uuid: () => makeColumn("uuid"),
-  /** `ENUM(...values)` → a string-literal union of the given values. */
-  enum: (...values) => makeColumn("enum", { values }),
-  /**
-   * A PostgreSQL array column (`text[]`, `integer[]`) → `T[]`.
-   *
-   * PostgreSQL only: SQLite and MySQL have no native array type, and rendering
-   * one as JSON there would give the same model different semantics per dialect
-   * (`@>` and `&&` work on one and not the other), so the DDL renderer throws
-   * for those dialects instead of falling back silently.
-   *
-   * @param element The element column (its type, not its flags, is what is used).
-   * @returns A column whose inferred type is an array of the element's type.
-   *
-   * @example
-   * ```ts
-   * class ApiKey extends Model {
-   *   static tablename = "api_keys";
-   *   scopes = column.array(column.text()).notNull().default(["send"]);
-   * }
-   * ```
-   */
-  array: (element) => makeColumn("array", { element: element.type })
-};
-function unique(...columns) {
-  if (columns.length === 0) {
-    throw new Error("unique() requires at least one column.");
-  }
-  return { kind: "unique", columns };
-}
-function foreignKey(columns, refTable, refColumns, options) {
-  if (columns.length === 0 || columns.length !== refColumns.length) {
-    throw new Error(
-      "foreignKey() requires matching, non-empty local and referenced column lists."
-    );
-  }
-  return {
-    kind: "foreignKey",
-    name: options?.name,
-    columns,
-    refTable,
-    refColumns,
-    onDelete: options?.onDelete,
-    onUpdate: options?.onUpdate
-  };
-}
-function toSnakeCase(name) {
-  return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
-}
-var Model = class {
-  static tablename;
-  /**
-   * Optional table-level constraints (composite unique / foreign keys), returned
-   * by a thunk so forward references resolve lazily. Mirrors SQLAlchemy's
-   * `__table_args__`.
-   */
-  static tableArgs;
-  /**
-   * How to derive column names from property names (default `"preserve"`). Set
-   * `"snake_case"` to keep a `snake_case` schema behind a `camelCase` model
-   * without annotating every column; {@link Column.name} overrides it per column.
-   */
-  static naming;
-};
-var columnsCache = /* @__PURE__ */ new WeakMap();
-function columnsOf(model) {
-  const cached = columnsCache.get(model);
-  if (cached) return cached;
-  const instance = new model();
-  const out = {};
-  for (const [key, value] of Object.entries(instance)) {
-    if (value instanceof Column) {
-      out[key] = value;
-    }
-  }
-  columnsCache.set(model, out);
-  return out;
-}
-var nameMapCache = /* @__PURE__ */ new WeakMap();
-var propMapCache = /* @__PURE__ */ new WeakMap();
-function columnNamesOf(model) {
-  const cached = nameMapCache.get(model);
-  if (cached !== void 0) return cached;
-  const strategy = model.naming ?? "preserve";
-  const map = {};
-  const seen = /* @__PURE__ */ new Map();
-  let renamed = false;
-  for (const [prop, col2] of Object.entries(columnsOf(model))) {
-    const dbName = col2.dbName ?? (strategy === "snake_case" ? toSnakeCase(prop) : prop);
-    const collision = seen.get(dbName);
-    if (collision !== void 0) {
-      throw new Error(
-        `${model.tablename}: properties "${collision}" and "${prop}" both map to column "${dbName}".`
-      );
-    }
-    seen.set(dbName, prop);
-    map[prop] = dbName;
-    if (dbName !== prop) renamed = true;
-  }
-  const result = renamed ? map : null;
-  nameMapCache.set(model, result);
-  return result;
-}
-function columnPropsOf(model) {
-  const cached = propMapCache.get(model);
-  if (cached !== void 0) return cached;
-  const forward = columnNamesOf(model);
-  let result = null;
-  if (forward) {
-    const inverse = {};
-    for (const [prop, dbName] of Object.entries(forward)) inverse[dbName] = prop;
-    result = inverse;
-  }
-  propMapCache.set(model, result);
-  return result;
-}
-function dbColumn(names, prop) {
-  return names?.[prop] ?? prop;
-}
-
-export { ActiveRecord, Agg, AsyncEngine, AsyncResult, AsyncSession, BaseDialect, BaseRepository, Column, DeleteBuilder, Expression, InsertBuilder, InvalidDatabaseUrl, JoinBuilder, Model, MysqlDialect, NoResultError, NodeSqliteDriver, OPERATORS, Params, PostgresDialect, QueryExecutionError, RecordNotFound, SelectBuilder, SqliteDialect, SyncEngine, SyncResult, SyncSession, UpdateBuilder, ValidationError, activeRecord, and, avg, belongsTo, col, column, columnNamesOf, columnPropsOf, columnsOf, count, createEngine, createSyncEngine, dbColumn, del, detectDialect, fn, foreignKey, fromDict, getDialect, hasMany, insert, isCondition, isExpression, isSqlExpression, isSubquery, join, loadRelations, max, min, not, or, parse, parseDatabaseUrl, renderPortableToken, select, sql, stringify, sum, toAsyncDriver, toCondNode, toDict, toJSON, toSnakeCase, unique, update, val };
-//# sourceMappingURL=chunk-4AWUP7BM.js.map
-//# sourceMappingURL=chunk-4AWUP7BM.js.map