@redocly/replay 0.27.0-next.4 → 0.27.0-next.6

package/dist/replay-SqliteDBStorage-D_31Bd3Z.js

@@ -0,0 +1,2857 @@
+import { F as Qe } from "./replay-index-DXnDNeqk.js";
+import { h as Ve } from "./replay-history.schema-5ce6X0R1.js";
+import { s as We } from "./replay-step-context.schema-DBk4jufr.js";
+import { b as J, c as X, a as ee } from "./replay-ai-message-parts.schema-E9u9-nqr.js";
+import { c as f, T as m, i as h, g as V, s as n, o as Ue, n as He, f as Ye, h as Ge, j as Ze, k as Xe, l as et, m as tt, p as st, q as it, r as rt, t as nt, u as at, v as ot, w as lt, x as ct, y as ht, z as ut, e as _e, A as dt, b as he, d as ft, a as mt, C as R, S as b, V as A, B as P, D as ye, E as O, F as W, G as Y, H as le, P as Oe, I as yt, J as ue, K as pe, L as pt, W as Ae, M as gt, N as Me, O as G, Q as $e } from "./replay-indexes-CfsvVMi_.js";
+class bt {
+  static [f] = "ConsoleLogWriter";
+  write(e) {
+    console.log(e);
+  }
+}
+class wt {
+  static [f] = "DefaultLogger";
+  writer;
+  constructor(e) {
+    this.writer = e?.writer ?? new bt();
+  }
+  logQuery(e, t) {
+    const s = t.map((r) => {
+      try {
+        return JSON.stringify(r);
+      } catch {
+        return String(r);
+      }
+    }), i = s.length ? ` -- params: [${s.join(", ")}]` : "";
+    this.writer.write(`Query: ${e}${i}`);
+  }
+}
+class St {
+  static [f] = "NoopLogger";
+  logQuery() {
+  }
+}
+const Ce = /* @__PURE__ */ Symbol.for("drizzle:PgInlineForeignKeys"), Ne = /* @__PURE__ */ Symbol.for("drizzle:EnableRLS");
+class vt extends m {
+  static [f] = "PgTable";
+  /** @internal */
+  static Symbol = Object.assign({}, m.Symbol, {
+    InlineForeignKeys: Ce,
+    EnableRLS: Ne
+  });
+  /**@internal */
+  [Ce] = [];
+  /** @internal */
+  [Ne] = !1;
+  /** @internal */
+  [m.Symbol.ExtraConfigBuilder] = void 0;
+  /** @internal */
+  [m.Symbol.ExtraConfigColumns] = {};
+}
+class Qt {
+  static [f] = "PgPrimaryKeyBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  name;
+  constructor(e, t) {
+    this.columns = e, this.name = t;
+  }
+  /** @internal */
+  build(e) {
+    return new $t(e, this.columns, this.name);
+  }
+}
+class $t {
+  constructor(e, t, s) {
+    this.table = e, this.columns = t, this.name = s;
+  }
+  static [f] = "PgPrimaryKey";
+  columns;
+  name;
+  getName() {
+    return this.name ?? `${this.table[vt.Symbol.Name]}_${this.columns.map((e) => e.name).join("_")}_pk`;
+  }
+}
+class je {
+  constructor(e, t, s) {
+    this.sourceTable = e, this.referencedTable = t, this.relationName = s, this.referencedTableName = t[m.Symbol.Name];
+  }
+  static [f] = "Relation";
+  referencedTableName;
+  fieldName;
+}
+class Ee {
+  constructor(e, t) {
+    this.table = e, this.config = t;
+  }
+  static [f] = "Relations";
+}
+class k extends je {
+  constructor(e, t, s, i) {
+    super(e, t, s?.relationName), this.config = s, this.isNullable = i;
+  }
+  static [f] = "One";
+  withFieldName(e) {
+    const t = new k(
+      this.sourceTable,
+      this.referencedTable,
+      this.config,
+      this.isNullable
+    );
+    return t.fieldName = e, t;
+  }
+}
+class ne extends je {
+  constructor(e, t, s) {
+    super(e, t, s?.relationName), this.config = s;
+  }
+  static [f] = "Many";
+  withFieldName(e) {
+    const t = new ne(
+      this.sourceTable,
+      this.referencedTable,
+      this.config
+    );
+    return t.fieldName = e, t;
+  }
+}
+function Ct() {
+  return {
+    and: he,
+    between: dt,
+    eq: _e,
+    exists: ut,
+    gt: ht,
+    gte: ct,
+    ilike: lt,
+    inArray: ot,
+    isNull: at,
+    isNotNull: nt,
+    like: rt,
+    lt: it,
+    lte: st,
+    ne: tt,
+    not: et,
+    notBetween: Xe,
+    notExists: Ze,
+    notLike: Ge,
+    notIlike: Ye,
+    notInArray: He,
+    or: Ue,
+    sql: n
+  };
+}
+function Nt() {
+  return {
+    sql: n,
+    asc: mt,
+    desc: ft
+  };
+}
+function qt(l, e) {
+  Object.keys(l).length === 1 && "default" in l && !h(l.default, m) && (l = l.default);
+  const t = {}, s = {}, i = {};
+  for (const [r, a] of Object.entries(l))
+    if (h(a, m)) {
+      const o = V(a), c = s[o];
+      t[o] = r, i[r] = {
+        tsName: r,
+        dbName: a[m.Symbol.Name],
+        schema: a[m.Symbol.Schema],
+        columns: a[m.Symbol.Columns],
+        relations: c?.relations ?? {},
+        primaryKey: c?.primaryKey ?? []
+      };
+      for (const d of Object.values(
+        a[m.Symbol.Columns]
+      ))
+        d.primary && i[r].primaryKey.push(d);
+      const u = a[m.Symbol.ExtraConfigBuilder]?.(a[m.Symbol.ExtraConfigColumns]);
+      if (u)
+        for (const d of Object.values(u))
+          h(d, Qt) && i[r].primaryKey.push(...d.columns);
+    } else if (h(a, Ee)) {
+      const o = V(a.table), c = t[o], u = a.config(
+        e(a.table)
+      );
+      let d;
+      for (const [p, C] of Object.entries(u))
+        if (c) {
+          const N = i[c];
+          N.relations[p] = C;
+        } else
+          o in s || (s[o] = {
+            relations: {},
+            primaryKey: d
+          }), s[o].relations[p] = C;
+    }
+  return { tables: i, tableNamesMap: t };
+}
+function ge(l, e) {
+  return new Ee(
+    l,
+    (t) => Object.fromEntries(
+      Object.entries(e(t)).map(([s, i]) => [
+        s,
+        i.withFieldName(s)
+      ])
+    )
+  );
+}
+function Tt(l) {
+  return function(t, s) {
+    return new k(
+      l,
+      t,
+      s,
+      s?.fields.reduce((i, r) => i && r.notNull, !0) ?? !1
+    );
+  };
+}
+function Lt(l) {
+  return function(t, s) {
+    return new ne(l, t, s);
+  };
+}
+function xt(l, e, t) {
+  if (h(t, k) && t.config)
+    return {
+      fields: t.config.fields,
+      references: t.config.references
+    };
+  const s = e[V(t.referencedTable)];
+  if (!s)
+    throw new Error(
+      `Table "${t.referencedTable[m.Symbol.Name]}" not found in schema`
+    );
+  const i = l[s];
+  if (!i)
+    throw new Error(`Table "${s}" not found in schema`);
+  const r = t.sourceTable, a = e[V(r)];
+  if (!a)
+    throw new Error(
+      `Table "${r[m.Symbol.Name]}" not found in schema`
+    );
+  const o = [];
+  for (const c of Object.values(
+    i.relations
+  ))
+    (t.relationName && t !== c && c.relationName === t.relationName || !t.relationName && c.referencedTable === t.sourceTable) && o.push(c);
+  if (o.length > 1)
+    throw t.relationName ? new Error(
+      `There are multiple relations with name "${t.relationName}" in table "${s}"`
+    ) : new Error(
+      `There are multiple relations between "${s}" and "${t.sourceTable[m.Symbol.Name]}". Please specify relation name`
+    );
+  if (o[0] && h(o[0], k) && o[0].config)
+    return {
+      fields: o[0].config.references,
+      references: o[0].config.fields
+    };
+  throw new Error(
+    `There is not enough information to infer relation "${a}.${t.fieldName}"`
+  );
+}
+function Rt(l) {
+  return {
+    one: Tt(l),
+    many: Lt(l)
+  };
+}
+function de(l, e, t, s, i = (r) => r) {
+  const r = {};
+  for (const [
+    a,
+    o
+  ] of s.entries())
+    if (o.isJson) {
+      const c = e.relations[o.tsKey], u = t[a], d = typeof u == "string" ? JSON.parse(u) : u;
+      r[o.tsKey] = h(c, k) ? d && de(
+        l,
+        l[o.relationTableTsKey],
+        d,
+        o.selection,
+        i
+      ) : d.map(
+        (p) => de(
+          l,
+          l[o.relationTableTsKey],
+          p,
+          o.selection,
+          i
+        )
+      );
+    } else {
+      const c = i(t[a]), u = o.field;
+      let d;
+      h(u, R) ? d = u : h(u, b) ? d = u.decoder : d = u.sql.decoder, r[o.tsKey] = c === null ? null : d.mapFromDriverValue(c);
+    }
+  return r;
+}
+class te {
+  constructor(e) {
+    this.table = e;
+  }
+  static [f] = "ColumnAliasProxyHandler";
+  get(e, t) {
+    return t === "table" ? this.table : e[t];
+  }
+}
+class be {
+  constructor(e, t) {
+    this.alias = e, this.replaceOriginalName = t;
+  }
+  static [f] = "TableAliasProxyHandler";
+  get(e, t) {
+    if (t === m.Symbol.IsAlias)
+      return !0;
+    if (t === m.Symbol.Name)
+      return this.alias;
+    if (this.replaceOriginalName && t === m.Symbol.OriginalName)
+      return this.alias;
+    if (t === A)
+      return {
+        ...e[A],
+        name: this.alias,
+        isAlias: !0
+      };
+    if (t === m.Symbol.Columns) {
+      const i = e[m.Symbol.Columns];
+      if (!i)
+        return i;
+      const r = {};
+      return Object.keys(i).map((a) => {
+        r[a] = new Proxy(
+          i[a],
+          new te(new Proxy(e, this))
+        );
+      }), r;
+    }
+    const s = e[t];
+    return h(s, R) ? new Proxy(s, new te(new Proxy(e, this))) : s;
+  }
+}
+function ce(l, e) {
+  return new Proxy(l, new be(e, !1));
+}
+function E(l, e) {
+  return new Proxy(
+    l,
+    new te(new Proxy(l.table, new be(e, !1)))
+  );
+}
+function Pe(l, e) {
+  return new b.Aliased(se(l.sql, e), l.fieldAlias);
+}
+function se(l, e) {
+  return n.join(l.queryChunks.map((t) => h(t, R) ? E(t, e) : h(t, b) ? se(t, e) : h(t, b.Aliased) ? Pe(t, e) : t));
+}
+class T {
+  static [f] = "SelectionProxyHandler";
+  config;
+  constructor(e) {
+    this.config = { ...e };
+  }
+  get(e, t) {
+    if (t === "_")
+      return {
+        ...e._,
+        selectedFields: new Proxy(
+          e._.selectedFields,
+          this
+        )
+      };
+    if (t === A)
+      return {
+        ...e[A],
+        selectedFields: new Proxy(
+          e[A].selectedFields,
+          this
+        )
+      };
+    if (typeof t == "symbol")
+      return e[t];
+    const i = (h(e, P) ? e._.selectedFields : h(e, ye) ? e[A].selectedFields : e)[t];
+    if (h(i, b.Aliased)) {
+      if (this.config.sqlAliasedBehavior === "sql" && !i.isSelectionField)
+        return i.sql;
+      const r = i.clone();
+      return r.isSelectionField = !0, r;
+    }
+    if (h(i, b)) {
+      if (this.config.sqlBehavior === "sql")
+        return i;
+      throw new Error(
+        `You tried to reference "${t}" field from a subquery, which is a raw SQL field, but it doesn't have an alias declared. Please add an alias to the field using ".as('alias')" method.`
+      );
+    }
+    return h(i, R) ? this.config.alias ? new Proxy(
+      i,
+      new te(
+        new Proxy(
+          i.table,
+          new be(this.config.alias, this.config.replaceOriginalName ?? !1)
+        )
+      )
+    ) : i : typeof i != "object" || i === null ? i : new Proxy(i, new T(this.config));
+  }
+}
+class D {
+  static [f] = "QueryPromise";
+  [Symbol.toStringTag] = "QueryPromise";
+  catch(e) {
+    return this.then(void 0, e);
+  }
+  finally(e) {
+    return this.then(
+      (t) => (e?.(), t),
+      (t) => {
+        throw e?.(), t;
+      }
+    );
+  }
+  then(e, t) {
+    return this.execute().then(e, t);
+  }
+}
+function K(l) {
+  return h(l, O) ? [`${l[m.Symbol.BaseName]}`] : h(l, P) ? l._.usedTables ?? [] : h(l, b) ? l.usedTables ?? [] : [];
+}
+class qe extends D {
+  constructor(e, t, s, i) {
+    super(), this.table = e, this.session = t, this.dialect = s, this.config = { table: e, withList: i };
+  }
+  static [f] = "SQLiteDelete";
+  /** @internal */
+  config;
+  /**
+   * Adds a `where` clause to the query.
+   *
+   * Calling this method will delete only those rows that fulfill a specified condition.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/delete}
+   *
+   * @param where the `where` clause.
+   *
+   * @example
+   * You can use conditional operators and `sql function` to filter the rows to be deleted.
+   *
+   * ```ts
+   * // Delete all cars with green color
+   * db.delete(cars).where(eq(cars.color, 'green'));
+   * // or
+   * db.delete(cars).where(sql`${cars.color} = 'green'`)
+   * ```
+   *
+   * You can logically combine conditional operators with `and()` and `or()` operators:
+   *
+   * ```ts
+   * // Delete all BMW cars with a green color
+   * db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+   *
+   * // Delete all cars with the green or blue color
+   * db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+   * ```
+   */
+  where(e) {
+    return this.config.where = e, this;
+  }
+  orderBy(...e) {
+    if (typeof e[0] == "function") {
+      const t = e[0](
+        new Proxy(
+          this.config.table[m.Symbol.Columns],
+          new T({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
+        )
+      ), s = Array.isArray(t) ? t : [t];
+      this.config.orderBy = s;
+    } else {
+      const t = e;
+      this.config.orderBy = t;
+    }
+    return this;
+  }
+  limit(e) {
+    return this.config.limit = e, this;
+  }
+  returning(e = this.table[O.Symbol.Columns]) {
+    return this.config.returning = W(e), this;
+  }
+  /** @internal */
+  getSQL() {
+    return this.dialect.buildDeleteQuery(this.config);
+  }
+  toSQL() {
+    const { typings: e, ...t } = this.dialect.sqlToQuery(this.getSQL());
+    return t;
+  }
+  /** @internal */
+  _prepare(e = !0) {
+    return this.session[e ? "prepareOneTimeQuery" : "prepareQuery"](
+      this.dialect.sqlToQuery(this.getSQL()),
+      this.config.returning,
+      this.config.returning ? "all" : "run",
+      !0,
+      void 0,
+      {
+        type: "delete",
+        tables: K(this.config.table)
+      }
+    );
+  }
+  prepare() {
+    return this._prepare(!1);
+  }
+  run = (e) => this._prepare().run(e);
+  all = (e) => this._prepare().all(e);
+  get = (e) => this._prepare().get(e);
+  values = (e) => this._prepare().values(e);
+  async execute(e) {
+    return this._prepare().execute(e);
+  }
+  $dynamic() {
+    return this;
+  }
+}
+function Bt(l) {
+  return (l.replace(/['\u2019]/g, "").match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? []).map((t) => t.toLowerCase()).join("_");
+}
+function _t(l) {
+  return (l.replace(/['\u2019]/g, "").match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? []).reduce((t, s, i) => {
+    const r = i === 0 ? s.toLowerCase() : `${s[0].toUpperCase()}${s.slice(1)}`;
+    return t + r;
+  }, "");
+}
+function Ot(l) {
+  return l;
+}
+class At {
+  static [f] = "CasingCache";
+  /** @internal */
+  cache = {};
+  cachedTables = {};
+  convert;
+  constructor(e) {
+    this.convert = e === "snake_case" ? Bt : e === "camelCase" ? _t : Ot;
+  }
+  getColumnCasing(e) {
+    if (!e.keyAsName) return e.name;
+    const t = e.table[m.Symbol.Schema] ?? "public", s = e.table[m.Symbol.OriginalName], i = `${t}.${s}.${e.name}`;
+    return this.cache[i] || this.cacheTable(e.table), this.cache[i];
+  }
+  cacheTable(e) {
+    const t = e[m.Symbol.Schema] ?? "public", s = e[m.Symbol.OriginalName], i = `${t}.${s}`;
+    if (!this.cachedTables[i]) {
+      for (const r of Object.values(e[m.Symbol.Columns])) {
+        const a = `${i}.${r.name}`;
+        this.cache[a] = this.convert(r.name);
+      }
+      this.cachedTables[i] = !0;
+    }
+  }
+  clearCache() {
+    this.cache = {}, this.cachedTables = {};
+  }
+}
+class we extends Error {
+  static [f] = "DrizzleError";
+  constructor({ message: e, cause: t }) {
+    super(e), this.name = "DrizzleError", this.cause = t;
+  }
+}
+class F extends Error {
+  constructor(e, t, s) {
+    super(`Failed query: ${e}
+params: ${t}`), this.query = e, this.params = t, this.cause = s, Error.captureStackTrace(this, F), s && (this.cause = s);
+  }
+}
+class Mt extends we {
+  static [f] = "TransactionRollbackError";
+  constructor() {
+    super({ message: "Rollback" });
+  }
+}
+class Se extends ye {
+  static [f] = "SQLiteViewBase";
+}
+class ie {
+  static [f] = "SQLiteDialect";
+  /** @internal */
+  casing;
+  constructor(e) {
+    this.casing = new At(e?.casing);
+  }
+  escapeName(e) {
+    return `"${e.replace(/"/g, '""')}"`;
+  }
+  escapeParam(e) {
+    return "?";
+  }
+  escapeString(e) {
+    return `'${e.replace(/'/g, "''")}'`;
+  }
+  buildWithCTE(e) {
+    if (!e?.length) return;
+    const t = [n`with `];
+    for (const [s, i] of e.entries())
+      t.push(n`${n.identifier(i._.alias)} as (${i._.sql})`), s < e.length - 1 && t.push(n`, `);
+    return t.push(n` `), n.join(t);
+  }
+  buildDeleteQuery({
+    table: e,
+    where: t,
+    returning: s,
+    withList: i,
+    limit: r,
+    orderBy: a
+  }) {
+    const o = this.buildWithCTE(i), c = s ? n` returning ${this.buildSelection(s, { isSingleTable: !0 })}` : void 0, u = t ? n` where ${t}` : void 0, d = this.buildOrderBy(a), p = this.buildLimit(r);
+    return n`${o}delete from ${e}${u}${c}${d}${p}`;
+  }
+  buildUpdateSet(e, t) {
+    const s = e[m.Symbol.Columns], i = Object.keys(s).filter(
+      (a) => t[a] !== void 0 || s[a]?.onUpdateFn !== void 0
+    ), r = i.length;
+    return n.join(
+      i.flatMap((a, o) => {
+        const c = s[a], u = c.onUpdateFn?.(), d = t[a] ?? (h(u, b) ? u : n.param(u, c)), p = n`${n.identifier(this.casing.getColumnCasing(c))} = ${d}`;
+        return o < r - 1 ? [p, n.raw(", ")] : [p];
+      })
+    );
+  }
+  buildUpdateQuery({
+    table: e,
+    set: t,
+    where: s,
+    returning: i,
+    withList: r,
+    joins: a,
+    from: o,
+    limit: c,
+    orderBy: u
+  }) {
+    const d = this.buildWithCTE(r), p = this.buildUpdateSet(e, t), C = o && n.join([n.raw(" from "), this.buildFromTable(o)]), N = this.buildJoins(a), $ = i ? n` returning ${this.buildSelection(i, { isSingleTable: !0 })}` : void 0, S = s ? n` where ${s}` : void 0, v = this.buildOrderBy(u), Q = this.buildLimit(c);
+    return n`${d}update ${e} set ${p}${C}${N}${S}${$}${v}${Q}`;
+  }
+  /**
+   * Builds selection SQL with provided fields/expressions
+   *
+   * Examples:
+   *
+   * `select <selection> from`
+   *
+   * `insert ... returning <selection>`
+   *
+   * If `isSingleTable` is true, then columns won't be prefixed with table name
+   */
+  buildSelection(e, { isSingleTable: t = !1 } = {}) {
+    const s = e.length, i = e.flatMap(({ field: r }, a) => {
+      const o = [];
+      if (h(r, b.Aliased) && r.isSelectionField)
+        o.push(n.identifier(r.fieldAlias));
+      else if (h(r, b.Aliased) || h(r, b)) {
+        const c = h(r, b.Aliased) ? r.sql : r;
+        t ? o.push(
+          new b(
+            c.queryChunks.map((u) => h(u, R) ? n.identifier(this.casing.getColumnCasing(u)) : u)
+          )
+        ) : o.push(c), h(r, b.Aliased) && o.push(n` as ${n.identifier(r.fieldAlias)}`);
+      } else if (h(r, R)) {
+        const c = r.table[m.Symbol.Name];
+        r.columnType === "SQLiteNumericBigInt" ? t ? o.push(
+          n`cast(${n.identifier(this.casing.getColumnCasing(r))} as text)`
+        ) : o.push(
+          n`cast(${n.identifier(c)}.${n.identifier(this.casing.getColumnCasing(r))} as text)`
+        ) : t ? o.push(n.identifier(this.casing.getColumnCasing(r))) : o.push(
+          n`${n.identifier(c)}.${n.identifier(this.casing.getColumnCasing(r))}`
+        );
+      } else if (h(r, P)) {
+        const c = Object.entries(r._.selectedFields);
+        if (c.length === 1) {
+          const u = c[0][1], d = h(u, b) ? u.decoder : h(u, R) ? { mapFromDriverValue: (p) => u.mapFromDriverValue(p) } : u.sql.decoder;
+          d && (r._.sql.decoder = d);
+        }
+        o.push(r);
+      }
+      return a < s - 1 && o.push(n`, `), o;
+    });
+    return n.join(i);
+  }
+  buildJoins(e) {
+    if (!e || e.length === 0)
+      return;
+    const t = [];
+    if (e)
+      for (const [s, i] of e.entries()) {
+        s === 0 && t.push(n` `);
+        const r = i.table, a = i.on ? n` on ${i.on}` : void 0;
+        if (h(r, O)) {
+          const o = r[O.Symbol.Name], c = r[O.Symbol.Schema], u = r[O.Symbol.OriginalName], d = o === u ? void 0 : i.alias;
+          t.push(
+            n`${n.raw(i.joinType)} join ${c ? n`${n.identifier(c)}.` : void 0}${n.identifier(
+              u
+            )}${d && n` ${n.identifier(d)}`}${a}`
+          );
+        } else
+          t.push(
+            n`${n.raw(i.joinType)} join ${r}${a}`
+          );
+        s < e.length - 1 && t.push(n` `);
+      }
+    return n.join(t);
+  }
+  buildLimit(e) {
+    return typeof e == "object" || typeof e == "number" && e >= 0 ? n` limit ${e}` : void 0;
+  }
+  buildOrderBy(e) {
+    const t = [];
+    if (e)
+      for (const [s, i] of e.entries())
+        t.push(i), s < e.length - 1 && t.push(n`, `);
+    return t.length > 0 ? n` order by ${n.join(t)}` : void 0;
+  }
+  buildFromTable(e) {
+    return h(e, m) && e[m.Symbol.IsAlias] ? n`${n`${n.identifier(e[m.Symbol.Schema] ?? "")}.`.if(e[m.Symbol.Schema])}${n.identifier(
+      e[m.Symbol.OriginalName]
+    )} ${n.identifier(e[m.Symbol.Name])}` : e;
+  }
+  buildSelectQuery({
+    withList: e,
+    fields: t,
+    fieldsFlat: s,
+    where: i,
+    having: r,
+    table: a,
+    joins: o,
+    orderBy: c,
+    groupBy: u,
+    limit: d,
+    offset: p,
+    distinct: C,
+    setOperators: N
+  }) {
+    const $ = s ?? W(t);
+    for (const B of $)
+      if (h(B.field, R) && Y(B.field.table) !== (h(a, P) ? a._.alias : h(a, Se) ? a[A].name : h(a, b) ? void 0 : Y(a)) && !((_) => o?.some(
+        ({ alias: H }) => H === (_[m.Symbol.IsAlias] ? Y(_) : _[m.Symbol.BaseName])
+      ))(B.field.table)) {
+        const _ = Y(B.field.table);
+        throw new Error(
+          `Your "${B.path.join(
+            "->"
+          )}" field references a column "${_}"."${B.field.name}", but the table "${_}" is not part of the query! Did you forget to join it?`
+        );
+      }
+    const S = !o || o.length === 0, v = this.buildWithCTE(e), Q = C ? n` distinct` : void 0, L = this.buildSelection($, { isSingleTable: S }), q = this.buildFromTable(a), g = this.buildJoins(o), M = i ? n` where ${i}` : void 0, x = r ? n` having ${r}` : void 0, y = [];
+    if (u)
+      for (const [B, _] of u.entries())
+        y.push(_), B < u.length - 1 && y.push(n`, `);
+    const w = y.length > 0 ? n` group by ${n.join(y)}` : void 0, j = this.buildOrderBy(c), U = this.buildLimit(d), oe = p ? n` offset ${p}` : void 0, z = n`${v}select${Q} ${L} from ${q}${g}${M}${w}${x}${j}${U}${oe}`;
+    return N.length > 0 ? this.buildSetOperations(z, N) : z;
+  }
+  buildSetOperations(e, t) {
+    const [s, ...i] = t;
+    if (!s)
+      throw new Error("Cannot pass undefined values to any set operator");
+    return i.length === 0 ? this.buildSetOperationQuery({ leftSelect: e, setOperator: s }) : this.buildSetOperations(
+      this.buildSetOperationQuery({ leftSelect: e, setOperator: s }),
+      i
+    );
+  }
+  buildSetOperationQuery({
+    leftSelect: e,
+    setOperator: { type: t, isAll: s, rightSelect: i, limit: r, orderBy: a, offset: o }
+  }) {
+    const c = n`${e.getSQL()} `, u = n`${i.getSQL()}`;
+    let d;
+    if (a && a.length > 0) {
+      const $ = [];
+      for (const S of a)
+        if (h(S, le))
+          $.push(n.identifier(S.name));
+        else if (h(S, b)) {
+          for (let v = 0; v < S.queryChunks.length; v++) {
+            const Q = S.queryChunks[v];
+            h(Q, le) && (S.queryChunks[v] = n.identifier(
+              this.casing.getColumnCasing(Q)
+            ));
+          }
+          $.push(n`${S}`);
+        } else
+          $.push(n`${S}`);
+      d = n` order by ${n.join($, n`, `)}`;
+    }
+    const p = typeof r == "object" || typeof r == "number" && r >= 0 ? n` limit ${r}` : void 0, C = n.raw(`${t} ${s ? "all " : ""}`), N = o ? n` offset ${o}` : void 0;
+    return n`${c}${C}${u}${d}${p}${N}`;
+  }
+  buildInsertQuery({
+    table: e,
+    values: t,
+    onConflict: s,
+    returning: i,
+    withList: r,
+    select: a
+  }) {
+    const o = [], c = e[m.Symbol.Columns], u = Object.entries(c).filter(
+      ([S, v]) => !v.shouldDisableInsert()
+    ), d = u.map(([, S]) => n.identifier(this.casing.getColumnCasing(S)));
+    if (a) {
+      const S = t;
+      h(S, b) ? o.push(S) : o.push(S.getSQL());
+    } else {
+      const S = t;
+      o.push(n.raw("values "));
+      for (const [v, Q] of S.entries()) {
+        const L = [];
+        for (const [q, g] of u) {
+          const M = Q[q];
+          if (M === void 0 || h(M, Oe) && M.value === void 0) {
+            let x;
+            if (g.default !== null && g.default !== void 0)
+              x = h(g.default, b) ? g.default : n.param(g.default, g);
+            else if (g.defaultFn !== void 0) {
+              const y = g.defaultFn();
+              x = h(y, b) ? y : n.param(y, g);
+            } else if (!g.default && g.onUpdateFn !== void 0) {
+              const y = g.onUpdateFn();
+              x = h(y, b) ? y : n.param(y, g);
+            } else
+              x = n`null`;
+            L.push(x);
+          } else
+            L.push(M);
+        }
+        o.push(L), v < S.length - 1 && o.push(n`, `);
+      }
+    }
+    const p = this.buildWithCTE(r), C = n.join(o), N = i ? n` returning ${this.buildSelection(i, { isSingleTable: !0 })}` : void 0, $ = s?.length ? n.join(s) : void 0;
+    return n`${p}insert into ${e} ${d} ${C}${$}${N}`;
+  }
+  sqlToQuery(e, t) {
+    return e.toQuery({
+      casing: this.casing,
+      escapeName: this.escapeName,
+      escapeParam: this.escapeParam,
+      escapeString: this.escapeString,
+      invokeSource: t
+    });
+  }
+  buildRelationalQuery({
+    fullSchema: e,
+    schema: t,
+    tableNamesMap: s,
+    table: i,
+    tableConfig: r,
+    queryConfig: a,
+    tableAlias: o,
+    nestedQueryRelation: c,
+    joinOn: u
+  }) {
+    let d = [], p, C, N = [], $;
+    const S = [];
+    if (a === !0)
+      d = Object.entries(r.columns).map(([L, q]) => ({
+        dbKey: q.name,
+        tsKey: L,
+        field: E(q, o),
+        relationTableTsKey: void 0,
+        isJson: !1,
+        selection: []
+      }));
+    else {
+      const Q = Object.fromEntries(
+        Object.entries(r.columns).map(([y, w]) => [
+          y,
+          E(w, o)
+        ])
+      );
+      if (a.where) {
+        const y = typeof a.where == "function" ? a.where(Q, Ct()) : a.where;
+        $ = y && se(y, o);
+      }
+      const L = [];
+      let q = [];
+      if (a.columns) {
+        let y = !1;
+        for (const [w, j] of Object.entries(a.columns))
+          j !== void 0 && w in r.columns && (!y && j === !0 && (y = !0), q.push(w));
+        q.length > 0 && (q = y ? q.filter((w) => a.columns?.[w] === !0) : Object.keys(r.columns).filter(
+          (w) => !q.includes(w)
+        ));
+      } else
+        q = Object.keys(r.columns);
+      for (const y of q) {
+        const w = r.columns[y];
+        L.push({ tsKey: y, value: w });
+      }
+      let g = [];
+      a.with && (g = Object.entries(a.with).filter(
+        (y) => !!y[1]
+      ).map(([y, w]) => ({
+        tsKey: y,
+        queryConfig: w,
+        relation: r.relations[y]
+      })));
+      let M;
+      if (a.extras) {
+        M = typeof a.extras == "function" ? a.extras(Q, { sql: n }) : a.extras;
+        for (const [y, w] of Object.entries(M))
+          L.push({
+            tsKey: y,
+            value: Pe(w, o)
+          });
+      }
+      for (const { tsKey: y, value: w } of L)
+        d.push({
+          dbKey: h(w, b.Aliased) ? w.fieldAlias : r.columns[y].name,
+          tsKey: y,
+          field: h(w, R) ? E(w, o) : w,
+          relationTableTsKey: void 0,
+          isJson: !1,
+          selection: []
+        });
+      let x = typeof a.orderBy == "function" ? a.orderBy(Q, Nt()) : a.orderBy ?? [];
+      Array.isArray(x) || (x = [x]), N = x.map((y) => h(y, R) ? E(y, o) : se(y, o)), p = a.limit, C = a.offset;
+      for (const {
+        tsKey: y,
+        queryConfig: w,
+        relation: j
+      } of g) {
+        const U = xt(
+          t,
+          s,
+          j
+        ), oe = V(j.referencedTable), z = s[oe], B = `${o}_${y}`, _ = he(
+          ...U.fields.map(
+            (ze, Je) => _e(
+              E(
+                U.references[Je],
+                B
+              ),
+              E(ze, o)
+            )
+          )
+        ), H = this.buildRelationalQuery({
+          fullSchema: e,
+          schema: t,
+          tableNamesMap: s,
+          table: e[z],
+          tableConfig: t[z],
+          queryConfig: h(j, k) ? w === !0 ? { limit: 1 } : { ...w, limit: 1 } : w,
+          tableAlias: B,
+          joinOn: _,
+          nestedQueryRelation: j
+        }), De = n`(${H.sql})`.as(y);
+        d.push({
+          dbKey: y,
+          tsKey: y,
+          field: De,
+          relationTableTsKey: z,
+          isJson: !0,
+          selection: H.selection
+        });
+      }
+    }
+    if (d.length === 0)
+      throw new we({
+        message: `No fields selected for table "${r.tsName}" ("${o}"). You need to have at least one item in "columns", "with" or "extras". If you need to select all columns, omit the "columns" key or set it to undefined.`
+      });
+    let v;
+    if ($ = he(u, $), c) {
+      let Q = n`json_array(${n.join(
+        d.map(
+          ({ field: g }) => h(g, le) ? n.identifier(this.casing.getColumnCasing(g)) : h(g, b.Aliased) ? g.sql : g
+        ),
+        n`, `
+      )})`;
+      h(c, ne) && (Q = n`coalesce(json_group_array(${Q}), json_array())`);
+      const L = [
+        {
+          dbKey: "data",
+          tsKey: "data",
+          field: Q.as("data"),
+          isJson: !0,
+          relationTableTsKey: r.tsName,
+          selection: d
+        }
+      ];
+      p !== void 0 || C !== void 0 || N.length > 0 ? (v = this.buildSelectQuery({
+        table: ce(i, o),
+        fields: {},
+        fieldsFlat: [
+          {
+            path: [],
+            field: n.raw("*")
+          }
+        ],
+        where: $,
+        limit: p,
+        offset: C,
+        orderBy: N,
+        setOperators: []
+      }), $ = void 0, p = void 0, C = void 0, N = void 0) : v = ce(i, o), v = this.buildSelectQuery({
+        table: h(v, O) ? v : new P(v, {}, o),
+        fields: {},
+        fieldsFlat: L.map(({ field: g }) => ({
+          path: [],
+          field: h(g, R) ? E(g, o) : g
+        })),
+        joins: S,
+        where: $,
+        limit: p,
+        offset: C,
+        orderBy: N,
+        setOperators: []
+      });
+    } else
+      v = this.buildSelectQuery({
+        table: ce(i, o),
+        fields: {},
+        fieldsFlat: d.map(({ field: Q }) => ({
+          path: [],
+          field: h(Q, R) ? E(Q, o) : Q
+        })),
+        joins: S,
+        where: $,
+        limit: p,
+        offset: C,
+        orderBy: N,
+        setOperators: []
+      });
+    return {
+      tableTsKey: r.tsName,
+      sql: v,
+      selection: d
+    };
+  }
+}
+class jt extends ie {
+  static [f] = "SQLiteSyncDialect";
+  migrate(e, t, s) {
+    const i = s === void 0 || typeof s == "string" ? "__drizzle_migrations" : s.migrationsTable ?? "__drizzle_migrations", r = n`
+			CREATE TABLE IF NOT EXISTS ${n.identifier(i)} (
+				id SERIAL PRIMARY KEY,
+				hash text NOT NULL,
+				created_at numeric
+			)
+		`;
+    t.run(r);
+    const o = t.values(
+      n`SELECT id, hash, created_at FROM ${n.identifier(i)} ORDER BY created_at DESC LIMIT 1`
+    )[0] ?? void 0;
+    t.run(n`BEGIN`);
+    try {
+      for (const c of e)
+        if (!o || Number(o[2]) < c.folderMillis) {
+          for (const u of c.sql)
+            t.run(n.raw(u));
+          t.run(
+            n`INSERT INTO ${n.identifier(
+              i
+            )} ("hash", "created_at") VALUES(${c.hash}, ${c.folderMillis})`
+          );
+        }
+      t.run(n`COMMIT`);
+    } catch (c) {
+      throw t.run(n`ROLLBACK`), c;
+    }
+  }
+}
+class Et extends ie {
+  static [f] = "SQLiteAsyncDialect";
+  async migrate(e, t, s) {
+    const i = s === void 0 || typeof s == "string" ? "__drizzle_migrations" : s.migrationsTable ?? "__drizzle_migrations", r = n`
+			CREATE TABLE IF NOT EXISTS ${n.identifier(i)} (
+				id SERIAL PRIMARY KEY,
+				hash text NOT NULL,
+				created_at numeric
+			)
+		`;
+    await t.run(r);
+    const o = (await t.values(
+      n`SELECT id, hash, created_at FROM ${n.identifier(i)} ORDER BY created_at DESC LIMIT 1`
+    ))[0] ?? void 0;
+    await t.transaction(async (c) => {
+      for (const u of e)
+        if (!o || Number(o[2]) < u.folderMillis) {
+          for (const d of u.sql)
+            await c.run(n.raw(d));
+          await c.run(
+            n`INSERT INTO ${n.identifier(
+              i
+            )} ("hash", "created_at") VALUES(${u.hash}, ${u.folderMillis})`
+          );
+        }
+    });
+  }
+}
+class Pt {
+  static [f] = "TypedQueryBuilder";
+  /** @internal */
+  getSelectedFields() {
+    return this._.selectedFields;
+  }
+}
+class I {
+  static [f] = "SQLiteSelectBuilder";
+  fields;
+  session;
+  dialect;
+  withList;
+  distinct;
+  constructor(e) {
+    this.fields = e.fields, this.session = e.session, this.dialect = e.dialect, this.withList = e.withList, this.distinct = e.distinct;
+  }
+  from(e) {
+    const t = !!this.fields;
+    let s;
+    return this.fields ? s = this.fields : h(e, P) ? s = Object.fromEntries(
+      Object.keys(e._.selectedFields).map((i) => [i, e[i]])
+    ) : h(e, Se) ? s = e[A].selectedFields : h(e, b) ? s = {} : s = yt(e), new Fe({
+      table: e,
+      fields: s,
+      isPartialSelect: t,
+      session: this.session,
+      dialect: this.dialect,
+      withList: this.withList,
+      distinct: this.distinct
+    });
+  }
+}
+class Ft extends Pt {
+  static [f] = "SQLiteSelectQueryBuilder";
+  _;
+  /** @internal */
+  config;
+  joinsNotNullableMap;
+  tableName;
+  isPartialSelect;
+  session;
+  dialect;
+  cacheConfig = void 0;
+  usedTables = /* @__PURE__ */ new Set();
+  constructor({ table: e, fields: t, isPartialSelect: s, session: i, dialect: r, withList: a, distinct: o }) {
+    super(), this.config = {
+      withList: a,
+      table: e,
+      fields: { ...t },
+      distinct: o,
+      setOperators: []
+    }, this.isPartialSelect = s, this.session = i, this.dialect = r, this._ = {
+      selectedFields: t,
+      config: this.config
+    }, this.tableName = ue(e), this.joinsNotNullableMap = typeof this.tableName == "string" ? { [this.tableName]: !0 } : {};
+    for (const c of K(e)) this.usedTables.add(c);
+  }
+  /** @internal */
+  getUsedTables() {
+    return [...this.usedTables];
+  }
+  createJoin(e) {
+    return (t, s) => {
+      const i = this.tableName, r = ue(t);
+      for (const a of K(t)) this.usedTables.add(a);
+      if (typeof r == "string" && this.config.joins?.some((a) => a.alias === r))
+        throw new Error(`Alias "${r}" is already used in this query`);
+      if (!this.isPartialSelect && (Object.keys(this.joinsNotNullableMap).length === 1 && typeof i == "string" && (this.config.fields = {
+        [i]: this.config.fields
+      }), typeof r == "string" && !h(t, b))) {
+        const a = h(t, P) ? t._.selectedFields : h(t, ye) ? t[A].selectedFields : t[m.Symbol.Columns];
+        this.config.fields[r] = a;
+      }
+      if (typeof s == "function" && (s = s(
+        new Proxy(
+          this.config.fields,
+          new T({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
+        )
+      )), this.config.joins || (this.config.joins = []), this.config.joins.push({ on: s, table: t, joinType: e, alias: r }), typeof r == "string")
+        switch (e) {
+          case "left": {
+            this.joinsNotNullableMap[r] = !1;
+            break;
+          }
+          case "right": {
+            this.joinsNotNullableMap = Object.fromEntries(
+              Object.entries(this.joinsNotNullableMap).map(([a]) => [a, !1])
+            ), this.joinsNotNullableMap[r] = !0;
+            break;
+          }
+          case "cross":
+          case "inner": {
+            this.joinsNotNullableMap[r] = !0;
+            break;
+          }
+          case "full": {
+            this.joinsNotNullableMap = Object.fromEntries(
+              Object.entries(this.joinsNotNullableMap).map(([a]) => [a, !1])
+            ), this.joinsNotNullableMap[r] = !1;
+            break;
+          }
+        }
+      return this;
+    };
+  }
+  /**
+   * Executes a `left join` operation by adding another table to the current query.
+   *
+   * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/joins#left-join}
+   *
+   * @param table the table to join.
+   * @param on the `on` clause.
+   *
+   * @example
+   *
+   * ```ts
+   * // Select all users and their pets
+   * const usersWithPets: { user: User; pets: Pet | null; }[] = await db.select()
+   *   .from(users)
+   *   .leftJoin(pets, eq(users.id, pets.ownerId))
+   *
+   * // Select userId and petId
+   * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
+   *   userId: users.id,
+   *   petId: pets.id,
+   * })
+   *   .from(users)
+   *   .leftJoin(pets, eq(users.id, pets.ownerId))
+   * ```
+   */
+  leftJoin = this.createJoin("left");
+  /**
+   * Executes a `right join` operation by adding another table to the current query.
+   *
+   * Calling this method associates each row of the joined table with the corresponding row from the main table, if a match is found. If no matching row exists, it sets all columns of the main table to null.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/joins#right-join}
+   *
+   * @param table the table to join.
+   * @param on the `on` clause.
+   *
+   * @example
+   *
+   * ```ts
+   * // Select all users and their pets
+   * const usersWithPets: { user: User | null; pets: Pet; }[] = await db.select()
+   *   .from(users)
+   *   .rightJoin(pets, eq(users.id, pets.ownerId))
+   *
+   * // Select userId and petId
+   * const usersIdsAndPetIds: { userId: number | null; petId: number; }[] = await db.select({
+   *   userId: users.id,
+   *   petId: pets.id,
+   * })
+   *   .from(users)
+   *   .rightJoin(pets, eq(users.id, pets.ownerId))
+   * ```
+   */
+  rightJoin = this.createJoin("right");
+  /**
+   * Executes an `inner join` operation, creating a new table by combining rows from two tables that have matching values.
+   *
+   * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join}
+   *
+   * @param table the table to join.
+   * @param on the `on` clause.
+   *
+   * @example
+   *
+   * ```ts
+   * // Select all users and their pets
+   * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
+   *   .from(users)
+   *   .innerJoin(pets, eq(users.id, pets.ownerId))
+   *
+   * // Select userId and petId
+   * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
+   *   userId: users.id,
+   *   petId: pets.id,
+   * })
+   *   .from(users)
+   *   .innerJoin(pets, eq(users.id, pets.ownerId))
+   * ```
+   */
+  innerJoin = this.createJoin("inner");
+  /**
+   * Executes a `full join` operation by combining rows from two tables into a new table.
+   *
+   * Calling this method retrieves all rows from both main and joined tables, merging rows with matching values and filling in `null` for non-matching columns.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/joins#full-join}
+   *
+   * @param table the table to join.
+   * @param on the `on` clause.
+   *
+   * @example
+   *
+   * ```ts
+   * // Select all users and their pets
+   * const usersWithPets: { user: User | null; pets: Pet | null; }[] = await db.select()
+   *   .from(users)
+   *   .fullJoin(pets, eq(users.id, pets.ownerId))
+   *
+   * // Select userId and petId
+   * const usersIdsAndPetIds: { userId: number | null; petId: number | null; }[] = await db.select({
+   *   userId: users.id,
+   *   petId: pets.id,
+   * })
+   *   .from(users)
+   *   .fullJoin(pets, eq(users.id, pets.ownerId))
+   * ```
+   */
+  fullJoin = this.createJoin("full");
+  /**
+   * Executes a `cross join` operation by combining rows from two tables into a new table.
+   *
+   * Calling this method retrieves all rows from both main and joined tables, merging all rows from each table.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join}
+   *
+   * @param table the table to join.
+   *
+   * @example
+   *
+   * ```ts
+   * // Select all users, each user with every pet
+   * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
+   *   .from(users)
+   *   .crossJoin(pets)
+   *
+   * // Select userId and petId
+   * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
+   *   userId: users.id,
+   *   petId: pets.id,
+   * })
+   *   .from(users)
+   *   .crossJoin(pets)
+   * ```
+   */
+  crossJoin = this.createJoin("cross");
+  createSetOperator(e, t) {
+    return (s) => {
+      const i = typeof s == "function" ? s(It()) : s;
+      if (!pe(this.getSelectedFields(), i.getSelectedFields()))
+        throw new Error(
+          "Set operator error (union / intersect / except): selected fields are not the same or are in a different order"
+        );
+      return this.config.setOperators.push({ type: e, isAll: t, rightSelect: i }), this;
+    };
+  }
+  /**
+   * Adds `union` set operator to the query.
+   *
+   * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}
+   *
+   * @example
+   *
+   * ```ts
+   * // Select all unique names from customers and users tables
+   * await db.select({ name: users.name })
+   *   .from(users)
+   *   .union(
+   *     db.select({ name: customers.name }).from(customers)
+   *   );
+   * // or
+   * import { union } from 'drizzle-orm/sqlite-core'
+   *
+   * await union(
+   *   db.select({ name: users.name }).from(users),
+   *   db.select({ name: customers.name }).from(customers)
+   * );
+   * ```
+   */
+  union = this.createSetOperator("union", !1);
+  /**
+   * Adds `union all` set operator to the query.
+   *
+   * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}
+   *
+   * @example
+   *
+   * ```ts
+   * // Select all transaction ids from both online and in-store sales
+   * await db.select({ transaction: onlineSales.transactionId })
+   *   .from(onlineSales)
+   *   .unionAll(
+   *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+   *   );
+   * // or
+   * import { unionAll } from 'drizzle-orm/sqlite-core'
+   *
+   * await unionAll(
+   *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
+   *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+   * );
+   * ```
+   */
+  unionAll = this.createSetOperator("union", !0);
+  /**
+   * Adds `intersect` set operator to the query.
+   *
+   * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}
+   *
+   * @example
+   *
+   * ```ts
+   * // Select course names that are offered in both departments A and B
+   * await db.select({ courseName: depA.courseName })
+   *   .from(depA)
+   *   .intersect(
+   *     db.select({ courseName: depB.courseName }).from(depB)
+   *   );
+   * // or
+   * import { intersect } from 'drizzle-orm/sqlite-core'
+   *
+   * await intersect(
+   *   db.select({ courseName: depA.courseName }).from(depA),
+   *   db.select({ courseName: depB.courseName }).from(depB)
+   * );
+   * ```
+   */
+  intersect = this.createSetOperator("intersect", !1);
+  /**
+   * Adds `except` set operator to the query.
+   *
+   * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}
+   *
+   * @example
+   *
+   * ```ts
+   * // Select all courses offered in department A but not in department B
+   * await db.select({ courseName: depA.courseName })
+   *   .from(depA)
+   *   .except(
+   *     db.select({ courseName: depB.courseName }).from(depB)
+   *   );
+   * // or
+   * import { except } from 'drizzle-orm/sqlite-core'
+   *
+   * await except(
+   *   db.select({ courseName: depA.courseName }).from(depA),
+   *   db.select({ courseName: depB.courseName }).from(depB)
+   * );
+   * ```
+   */
+  except = this.createSetOperator("except", !1);
+  /** @internal */
+  addSetOperators(e) {
+    return this.config.setOperators.push(...e), this;
+  }
+  /**
+   * Adds a `where` clause to the query.
+   *
+   * Calling this method will select only those rows that fulfill a specified condition.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/select#filtering}
+   *
+   * @param where the `where` clause.
+   *
+   * @example
+   * You can use conditional operators and `sql function` to filter the rows to be selected.
+   *
+   * ```ts
+   * // Select all cars with green color
+   * await db.select().from(cars).where(eq(cars.color, 'green'));
+   * // or
+   * await db.select().from(cars).where(sql`${cars.color} = 'green'`)
+   * ```
+   *
+   * You can logically combine conditional operators with `and()` and `or()` operators:
+   *
+   * ```ts
+   * // Select all BMW cars with a green color
+   * await db.select().from(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+   *
+   * // Select all cars with the green or blue color
+   * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+   * ```
+   */
+  where(e) {
+    return typeof e == "function" && (e = e(
+      new Proxy(
+        this.config.fields,
+        new T({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
+      )
+    )), this.config.where = e, this;
+  }
+  /**
+   * Adds a `having` clause to the query.
+   *
+   * Calling this method will select only those rows that fulfill a specified condition. It is typically used with aggregate functions to filter the aggregated data based on a specified condition.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
+   *
+   * @param having the `having` clause.
+   *
+   * @example
+   *
+   * ```ts
+   * // Select all brands with more than one car
+   * await db.select({
+   * 	brand: cars.brand,
+   * 	count: sql<number>`cast(count(${cars.id}) as int)`,
+   * })
+   *   .from(cars)
+   *   .groupBy(cars.brand)
+   *   .having(({ count }) => gt(count, 1));
+   * ```
+   */
+  having(e) {
+    return typeof e == "function" && (e = e(
+      new Proxy(
+        this.config.fields,
+        new T({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
+      )
+    )), this.config.having = e, this;
+  }
+  groupBy(...e) {
+    if (typeof e[0] == "function") {
+      const t = e[0](
+        new Proxy(
+          this.config.fields,
+          new T({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
+        )
+      );
+      this.config.groupBy = Array.isArray(t) ? t : [t];
+    } else
+      this.config.groupBy = e;
+    return this;
+  }
+  orderBy(...e) {
+    if (typeof e[0] == "function") {
+      const t = e[0](
+        new Proxy(
+          this.config.fields,
+          new T({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
+        )
+      ), s = Array.isArray(t) ? t : [t];
+      this.config.setOperators.length > 0 ? this.config.setOperators.at(-1).orderBy = s : this.config.orderBy = s;
+    } else {
+      const t = e;
+      this.config.setOperators.length > 0 ? this.config.setOperators.at(-1).orderBy = t : this.config.orderBy = t;
+    }
+    return this;
+  }
+  /**
+   * Adds a `limit` clause to the query.
+   *
+   * Calling this method will set the maximum number of rows that will be returned by this query.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
+   *
+   * @param limit the `limit` clause.
+   *
+   * @example
+   *
+   * ```ts
+   * // Get the first 10 people from this query.
+   * await db.select().from(people).limit(10);
+   * ```
+   */
+  limit(e) {
+    return this.config.setOperators.length > 0 ? this.config.setOperators.at(-1).limit = e : this.config.limit = e, this;
+  }
+  /**
+   * Adds an `offset` clause to the query.
+   *
+   * Calling this method will skip a number of rows when returning results from this query.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
+   *
+   * @param offset the `offset` clause.
+   *
+   * @example
+   *
+   * ```ts
+   * // Get the 10th-20th people from this query.
+   * await db.select().from(people).offset(10).limit(10);
+   * ```
+   */
+  offset(e) {
+    return this.config.setOperators.length > 0 ? this.config.setOperators.at(-1).offset = e : this.config.offset = e, this;
+  }
+  /** @internal */
+  getSQL() {
+    return this.dialect.buildSelectQuery(this.config);
+  }
+  toSQL() {
+    const { typings: e, ...t } = this.dialect.sqlToQuery(this.getSQL());
+    return t;
+  }
+  as(e) {
+    const t = [];
+    if (t.push(...K(this.config.table)), this.config.joins)
+      for (const s of this.config.joins) t.push(...K(s.table));
+    return new Proxy(
+      new P(this.getSQL(), this.config.fields, e, !1, [...new Set(t)]),
+      new T({ alias: e, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
+    );
+  }
+  /** @internal */
+  getSelectedFields() {
+    return new Proxy(
+      this.config.fields,
+      new T({ alias: this.tableName, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
+    );
+  }
+  $dynamic() {
+    return this;
+  }
+}
+class Fe extends Ft {
+  static [f] = "SQLiteSelect";
+  /** @internal */
+  _prepare(e = !0) {
+    if (!this.session)
+      throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
+    const t = W(this.config.fields), s = this.session[e ? "prepareOneTimeQuery" : "prepareQuery"](
+      this.dialect.sqlToQuery(this.getSQL()),
+      t,
+      "all",
+      !0,
+      void 0,
+      {
+        type: "select",
+        tables: [...this.usedTables]
+      },
+      this.cacheConfig
+    );
+    return s.joinsNotNullableMap = this.joinsNotNullableMap, s;
+  }
+  $withCache(e) {
+    return this.cacheConfig = e === void 0 ? { config: {}, enable: !0, autoInvalidate: !0 } : e === !1 ? { enable: !1 } : { enable: !0, autoInvalidate: !0, ...e }, this;
+  }
+  prepare() {
+    return this._prepare(!1);
+  }
+  run = (e) => this._prepare().run(e);
+  all = (e) => this._prepare().all(e);
+  get = (e) => this._prepare().get(e);
+  values = (e) => this._prepare().values(e);
+  async execute() {
+    return this.all();
+  }
+}
+pt(Fe, [D]);
+function ae(l, e) {
+  return (t, s, ...i) => {
+    const r = [s, ...i].map((a) => ({
+      type: l,
+      isAll: e,
+      rightSelect: a
+    }));
+    for (const a of r)
+      if (!pe(t.getSelectedFields(), a.rightSelect.getSelectedFields()))
+        throw new Error(
+          "Set operator error (union / intersect / except): selected fields are not the same or are in a different order"
+        );
+    return t.addSetOperators(r);
+  };
+}
+const It = () => ({
+  union: Kt,
+  unionAll: kt,
+  intersect: Dt,
+  except: zt
+}), Kt = ae("union", !1), kt = ae("union", !0), Dt = ae("intersect", !1), zt = ae("except", !1);
+class Ie {
+  static [f] = "SQLiteQueryBuilder";
+  dialect;
+  dialectConfig;
+  constructor(e) {
+    this.dialect = h(e, ie) ? e : void 0, this.dialectConfig = h(e, ie) ? void 0 : e;
+  }
+  $with = (e, t) => {
+    const s = this;
+    return { as: (r) => (typeof r == "function" && (r = r(s)), new Proxy(
+      new Ae(
+        r.getSQL(),
+        t ?? ("getSelectedFields" in r ? r.getSelectedFields() ?? {} : {}),
+        e,
+        !0
+      ),
+      new T({ alias: e, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
+    )) };
+  };
+  with(...e) {
+    const t = this;
+    function s(r) {
+      return new I({
+        fields: r ?? void 0,
+        session: void 0,
+        dialect: t.getDialect(),
+        withList: e
+      });
+    }
+    function i(r) {
+      return new I({
+        fields: r ?? void 0,
+        session: void 0,
+        dialect: t.getDialect(),
+        withList: e,
+        distinct: !0
+      });
+    }
+    return { select: s, selectDistinct: i };
+  }
+  select(e) {
+    return new I({ fields: e ?? void 0, session: void 0, dialect: this.getDialect() });
+  }
+  selectDistinct(e) {
+    return new I({
+      fields: e ?? void 0,
+      session: void 0,
+      dialect: this.getDialect(),
+      distinct: !0
+    });
+  }
+  // Lazy load dialect to avoid circular dependency
+  getDialect() {
+    return this.dialect || (this.dialect = new jt(this.dialectConfig)), this.dialect;
+  }
+}
+class Te {
+  constructor(e, t, s, i) {
+    this.table = e, this.session = t, this.dialect = s, this.withList = i;
+  }
+  static [f] = "SQLiteInsertBuilder";
+  values(e) {
+    if (e = Array.isArray(e) ? e : [e], e.length === 0)
+      throw new Error("values() must be called with at least one value");
+    const t = e.map((s) => {
+      const i = {}, r = this.table[m.Symbol.Columns];
+      for (const a of Object.keys(s)) {
+        const o = s[a];
+        i[a] = h(o, b) ? o : new Oe(o, r[a]);
+      }
+      return i;
+    });
+    return new Le(this.table, t, this.session, this.dialect, this.withList);
+  }
+  select(e) {
+    const t = typeof e == "function" ? e(new Ie()) : e;
+    if (!h(t, b) && !pe(this.table[gt], t._.selectedFields))
+      throw new Error(
+        "Insert select error: selected fields are not the same or are in a different order compared to the table definition"
+      );
+    return new Le(this.table, t, this.session, this.dialect, this.withList, !0);
+  }
+}
+class Le extends D {
+  constructor(e, t, s, i, r, a) {
+    super(), this.session = s, this.dialect = i, this.config = { table: e, values: t, withList: r, select: a };
+  }
+  static [f] = "SQLiteInsert";
+  /** @internal */
+  config;
+  returning(e = this.config.table[O.Symbol.Columns]) {
+    return this.config.returning = W(e), this;
+  }
+  /**
+   * Adds an `on conflict do nothing` clause to the query.
+   *
+   * Calling this method simply avoids inserting a row as its alternative action.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
+   *
+   * @param config The `target` and `where` clauses.
+   *
+   * @example
+   * ```ts
+   * // Insert one row and cancel the insert if there's a conflict
+   * await db.insert(cars)
+   *   .values({ id: 1, brand: 'BMW' })
+   *   .onConflictDoNothing();
+   *
+   * // Explicitly specify conflict target
+   * await db.insert(cars)
+   *   .values({ id: 1, brand: 'BMW' })
+   *   .onConflictDoNothing({ target: cars.id });
+   * ```
+   */
+  onConflictDoNothing(e = {}) {
+    if (this.config.onConflict || (this.config.onConflict = []), e.target === void 0)
+      this.config.onConflict.push(n` on conflict do nothing`);
+    else {
+      const t = Array.isArray(e.target) ? n`${e.target}` : n`${[e.target]}`, s = e.where ? n` where ${e.where}` : n``;
+      this.config.onConflict.push(n` on conflict ${t} do nothing${s}`);
+    }
+    return this;
+  }
+  /**
+   * Adds an `on conflict do update` clause to the query.
+   *
+   * Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
+   *
+   * @param config The `target`, `set` and `where` clauses.
+   *
+   * @example
+   * ```ts
+   * // Update the row if there's a conflict
+   * await db.insert(cars)
+   *   .values({ id: 1, brand: 'BMW' })
+   *   .onConflictDoUpdate({
+   *     target: cars.id,
+   *     set: { brand: 'Porsche' }
+   *   });
+   *
+   * // Upsert with 'where' clause
+   * await db.insert(cars)
+   *   .values({ id: 1, brand: 'BMW' })
+   *   .onConflictDoUpdate({
+   *     target: cars.id,
+   *     set: { brand: 'newBMW' },
+   *     where: sql`${cars.createdAt} > '2023-01-01'::date`,
+   *   });
+   * ```
+   */
+  onConflictDoUpdate(e) {
+    if (e.where && (e.targetWhere || e.setWhere))
+      throw new Error(
+        'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
+      );
+    this.config.onConflict || (this.config.onConflict = []);
+    const t = e.where ? n` where ${e.where}` : void 0, s = e.targetWhere ? n` where ${e.targetWhere}` : void 0, i = e.setWhere ? n` where ${e.setWhere}` : void 0, r = Array.isArray(e.target) ? n`${e.target}` : n`${[e.target]}`, a = this.dialect.buildUpdateSet(this.config.table, Me(this.config.table, e.set));
+    return this.config.onConflict.push(
+      n` on conflict ${r}${s} do update set ${a}${t}${i}`
+    ), this;
+  }
+  /** @internal */
+  getSQL() {
+    return this.dialect.buildInsertQuery(this.config);
+  }
+  toSQL() {
+    const { typings: e, ...t } = this.dialect.sqlToQuery(this.getSQL());
+    return t;
+  }
+  /** @internal */
+  _prepare(e = !0) {
+    return this.session[e ? "prepareOneTimeQuery" : "prepareQuery"](
+      this.dialect.sqlToQuery(this.getSQL()),
+      this.config.returning,
+      this.config.returning ? "all" : "run",
+      !0,
+      void 0,
+      {
+        type: "insert",
+        tables: K(this.config.table)
+      }
+    );
+  }
+  prepare() {
+    return this._prepare(!1);
+  }
+  run = (e) => this._prepare().run(e);
+  all = (e) => this._prepare().all(e);
+  get = (e) => this._prepare().get(e);
+  values = (e) => this._prepare().values(e);
+  async execute() {
+    return this.config.returning ? this.all() : this.run();
+  }
+  $dynamic() {
+    return this;
+  }
+}
+class xe {
+  constructor(e, t, s, i) {
+    this.table = e, this.session = t, this.dialect = s, this.withList = i;
+  }
+  static [f] = "SQLiteUpdateBuilder";
+  set(e) {
+    return new Jt(
+      this.table,
+      Me(this.table, e),
+      this.session,
+      this.dialect,
+      this.withList
+    );
+  }
+}
+class Jt extends D {
+  constructor(e, t, s, i, r) {
+    super(), this.session = s, this.dialect = i, this.config = { set: t, table: e, withList: r, joins: [] };
+  }
+  static [f] = "SQLiteUpdate";
+  /** @internal */
+  config;
+  from(e) {
+    return this.config.from = e, this;
+  }
+  createJoin(e) {
+    return (t, s) => {
+      const i = ue(t);
+      if (typeof i == "string" && this.config.joins.some((r) => r.alias === i))
+        throw new Error(`Alias "${i}" is already used in this query`);
+      if (typeof s == "function") {
+        const r = this.config.from ? h(t, O) ? t[m.Symbol.Columns] : h(t, P) ? t._.selectedFields : h(t, Se) ? t[A].selectedFields : void 0 : void 0;
+        s = s(
+          new Proxy(
+            this.config.table[m.Symbol.Columns],
+            new T({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
+          ),
+          r && new Proxy(
+            r,
+            new T({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
+          )
+        );
+      }
+      return this.config.joins.push({ on: s, table: t, joinType: e, alias: i }), this;
+    };
+  }
+  leftJoin = this.createJoin("left");
+  rightJoin = this.createJoin("right");
+  innerJoin = this.createJoin("inner");
+  fullJoin = this.createJoin("full");
+  /**
+   * Adds a 'where' clause to the query.
+   *
+   * Calling this method will update only those rows that fulfill a specified condition.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/update}
+   *
+   * @param where the 'where' clause.
+   *
+   * @example
+   * You can use conditional operators and `sql function` to filter the rows to be updated.
+   *
+   * ```ts
+   * // Update all cars with green color
+   * db.update(cars).set({ color: 'red' })
+   *   .where(eq(cars.color, 'green'));
+   * // or
+   * db.update(cars).set({ color: 'red' })
+   *   .where(sql`${cars.color} = 'green'`)
+   * ```
+   *
+   * You can logically combine conditional operators with `and()` and `or()` operators:
+   *
+   * ```ts
+   * // Update all BMW cars with a green color
+   * db.update(cars).set({ color: 'red' })
+   *   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+   *
+   * // Update all cars with the green or blue color
+   * db.update(cars).set({ color: 'red' })
+   *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+   * ```
+   */
+  where(e) {
+    return this.config.where = e, this;
+  }
+  orderBy(...e) {
+    if (typeof e[0] == "function") {
+      const t = e[0](
+        new Proxy(
+          this.config.table[m.Symbol.Columns],
+          new T({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
+        )
+      ), s = Array.isArray(t) ? t : [t];
+      this.config.orderBy = s;
+    } else {
+      const t = e;
+      this.config.orderBy = t;
+    }
+    return this;
+  }
+  limit(e) {
+    return this.config.limit = e, this;
+  }
+  returning(e = this.config.table[O.Symbol.Columns]) {
+    return this.config.returning = W(e), this;
+  }
+  /** @internal */
+  getSQL() {
+    return this.dialect.buildUpdateQuery(this.config);
+  }
+  toSQL() {
+    const { typings: e, ...t } = this.dialect.sqlToQuery(this.getSQL());
+    return t;
+  }
+  /** @internal */
+  _prepare(e = !0) {
+    return this.session[e ? "prepareOneTimeQuery" : "prepareQuery"](
+      this.dialect.sqlToQuery(this.getSQL()),
+      this.config.returning,
+      this.config.returning ? "all" : "run",
+      !0,
+      void 0,
+      {
+        type: "insert",
+        tables: K(this.config.table)
+      }
+    );
+  }
+  prepare() {
+    return this._prepare(!1);
+  }
+  run = (e) => this._prepare().run(e);
+  all = (e) => this._prepare().all(e);
+  get = (e) => this._prepare().get(e);
+  values = (e) => this._prepare().values(e);
+  async execute() {
+    return this.config.returning ? this.all() : this.run();
+  }
+  $dynamic() {
+    return this;
+  }
+}
+class re extends b {
+  constructor(e) {
+    super(re.buildEmbeddedCount(e.source, e.filters).queryChunks), this.params = e, this.session = e.session, this.sql = re.buildCount(
+      e.source,
+      e.filters
+    );
+  }
+  sql;
+  static [f] = "SQLiteCountBuilderAsync";
+  [Symbol.toStringTag] = "SQLiteCountBuilderAsync";
+  session;
+  static buildEmbeddedCount(e, t) {
+    return n`(select count(*) from ${e}${n.raw(" where ").if(t)}${t})`;
+  }
+  static buildCount(e, t) {
+    return n`select count(*) from ${e}${n.raw(" where ").if(t)}${t}`;
+  }
+  then(e, t) {
+    return Promise.resolve(this.session.count(this.sql)).then(
+      e,
+      t
+    );
+  }
+  catch(e) {
+    return this.then(void 0, e);
+  }
+  finally(e) {
+    return this.then(
+      (t) => (e?.(), t),
+      (t) => {
+        throw e?.(), t;
+      }
+    );
+  }
+}
+class Vt {
+  constructor(e, t, s, i, r, a, o, c) {
+    this.mode = e, this.fullSchema = t, this.schema = s, this.tableNamesMap = i, this.table = r, this.tableConfig = a, this.dialect = o, this.session = c;
+  }
+  static [f] = "SQLiteAsyncRelationalQueryBuilder";
+  findMany(e) {
+    return this.mode === "sync" ? new Re(
+      this.fullSchema,
+      this.schema,
+      this.tableNamesMap,
+      this.table,
+      this.tableConfig,
+      this.dialect,
+      this.session,
+      e || {},
+      "many"
+    ) : new fe(
+      this.fullSchema,
+      this.schema,
+      this.tableNamesMap,
+      this.table,
+      this.tableConfig,
+      this.dialect,
+      this.session,
+      e || {},
+      "many"
+    );
+  }
+  findFirst(e) {
+    return this.mode === "sync" ? new Re(
+      this.fullSchema,
+      this.schema,
+      this.tableNamesMap,
+      this.table,
+      this.tableConfig,
+      this.dialect,
+      this.session,
+      e ? { ...e, limit: 1 } : { limit: 1 },
+      "first"
+    ) : new fe(
+      this.fullSchema,
+      this.schema,
+      this.tableNamesMap,
+      this.table,
+      this.tableConfig,
+      this.dialect,
+      this.session,
+      e ? { ...e, limit: 1 } : { limit: 1 },
+      "first"
+    );
+  }
+}
+class fe extends D {
+  constructor(e, t, s, i, r, a, o, c, u) {
+    super(), this.fullSchema = e, this.schema = t, this.tableNamesMap = s, this.table = i, this.tableConfig = r, this.dialect = a, this.session = o, this.config = c, this.mode = u;
+  }
+  static [f] = "SQLiteAsyncRelationalQuery";
+  /** @internal */
+  mode;
+  /** @internal */
+  getSQL() {
+    return this.dialect.buildRelationalQuery({
+      fullSchema: this.fullSchema,
+      schema: this.schema,
+      tableNamesMap: this.tableNamesMap,
+      table: this.table,
+      tableConfig: this.tableConfig,
+      queryConfig: this.config,
+      tableAlias: this.tableConfig.tsName
+    }).sql;
+  }
+  /** @internal */
+  _prepare(e = !1) {
+    const { query: t, builtQuery: s } = this._toSQL();
+    return this.session[e ? "prepareOneTimeQuery" : "prepareQuery"](
+      s,
+      void 0,
+      this.mode === "first" ? "get" : "all",
+      !0,
+      (i, r) => {
+        const a = i.map(
+          (o) => de(this.schema, this.tableConfig, o, t.selection, r)
+        );
+        return this.mode === "first" ? a[0] : a;
+      }
+    );
+  }
+  prepare() {
+    return this._prepare(!1);
+  }
+  _toSQL() {
+    const e = this.dialect.buildRelationalQuery({
+      fullSchema: this.fullSchema,
+      schema: this.schema,
+      tableNamesMap: this.tableNamesMap,
+      table: this.table,
+      tableConfig: this.tableConfig,
+      queryConfig: this.config,
+      tableAlias: this.tableConfig.tsName
+    }), t = this.dialect.sqlToQuery(e.sql);
+    return { query: e, builtQuery: t };
+  }
+  toSQL() {
+    return this._toSQL().builtQuery;
+  }
+  /** @internal */
+  executeRaw() {
+    return this.mode === "first" ? this._prepare(!1).get() : this._prepare(!1).all();
+  }
+  async execute() {
+    return this.executeRaw();
+  }
+}
+class Re extends fe {
+  static [f] = "SQLiteSyncRelationalQuery";
+  sync() {
+    return this.executeRaw();
+  }
+}
+class Z extends D {
+  constructor(e, t, s, i, r) {
+    super(), this.execute = e, this.getSQL = t, this.dialect = i, this.mapBatchResult = r, this.config = { action: s };
+  }
+  static [f] = "SQLiteRaw";
+  /** @internal */
+  config;
+  getQuery() {
+    return { ...this.dialect.sqlToQuery(this.getSQL()), method: this.config.action };
+  }
+  mapResult(e, t) {
+    return t ? this.mapBatchResult(e) : e;
+  }
+  _prepare() {
+    return this;
+  }
+  /** @internal */
+  isResponseInArrayMode() {
+    return !1;
+  }
+}
+class Ke {
+  constructor(e, t, s, i) {
+    this.resultKind = e, this.dialect = t, this.session = s, this._ = i ? {
+      schema: i.schema,
+      fullSchema: i.fullSchema,
+      tableNamesMap: i.tableNamesMap
+    } : {
+      schema: void 0,
+      fullSchema: {},
+      tableNamesMap: {}
+    }, this.query = {};
+    const r = this.query;
+    if (this._.schema)
+      for (const [a, o] of Object.entries(this._.schema))
+        r[a] = new Vt(
+          e,
+          i.fullSchema,
+          this._.schema,
+          this._.tableNamesMap,
+          i.fullSchema[a],
+          o,
+          t,
+          s
+        );
+    this.$cache = { invalidate: async (a) => {
+    } };
+  }
+  static [f] = "BaseSQLiteDatabase";
+  query;
+  /**
+   * Creates a subquery that defines a temporary named result set as a CTE.
+   *
+   * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+   *
+   * @param alias The alias for the subquery.
+   *
+   * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
+   *
+   * @example
+   *
+   * ```ts
+   * // Create a subquery with alias 'sq' and use it in the select query
+   * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+   *
+   * const result = await db.with(sq).select().from(sq);
+   * ```
+   *
+   * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
+   *
+   * ```ts
+   * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
+   * const sq = db.$with('sq').as(db.select({
+   *   name: sql<string>`upper(${users.name})`.as('name'),
+   * })
+   * .from(users));
+   *
+   * const result = await db.with(sq).select({ name: sq.name }).from(sq);
+   * ```
+   */
+  $with = (e, t) => {
+    const s = this;
+    return { as: (r) => (typeof r == "function" && (r = r(new Ie(s.dialect))), new Proxy(
+      new Ae(
+        r.getSQL(),
+        t ?? ("getSelectedFields" in r ? r.getSelectedFields() ?? {} : {}),
+        e,
+        !0
+      ),
+      new T({ alias: e, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
+    )) };
+  };
+  $count(e, t) {
+    return new re({ source: e, filters: t, session: this.session });
+  }
+  /**
+   * Incorporates a previously defined CTE (using `$with`) into the main query.
+   *
+   * This method allows the main query to reference a temporary named result set.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+   *
+   * @param queries The CTEs to incorporate into the main query.
+   *
+   * @example
+   *
+   * ```ts
+   * // Define a subquery 'sq' as a CTE using $with
+   * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+   *
+   * // Incorporate the CTE 'sq' into the main query and select from it
+   * const result = await db.with(sq).select().from(sq);
+   * ```
+   */
+  with(...e) {
+    const t = this;
+    function s(c) {
+      return new I({
+        fields: c ?? void 0,
+        session: t.session,
+        dialect: t.dialect,
+        withList: e
+      });
+    }
+    function i(c) {
+      return new I({
+        fields: c ?? void 0,
+        session: t.session,
+        dialect: t.dialect,
+        withList: e,
+        distinct: !0
+      });
+    }
+    function r(c) {
+      return new xe(c, t.session, t.dialect, e);
+    }
+    function a(c) {
+      return new Te(c, t.session, t.dialect, e);
+    }
+    function o(c) {
+      return new qe(c, t.session, t.dialect, e);
+    }
+    return { select: s, selectDistinct: i, update: r, insert: a, delete: o };
+  }
+  select(e) {
+    return new I({ fields: e ?? void 0, session: this.session, dialect: this.dialect });
+  }
+  selectDistinct(e) {
+    return new I({
+      fields: e ?? void 0,
+      session: this.session,
+      dialect: this.dialect,
+      distinct: !0
+    });
+  }
+  /**
+   * Creates an update query.
+   *
+   * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+   *
+   * Use `.set()` method to specify which values to update.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/update}
+   *
+   * @param table The table to update.
+   *
+   * @example
+   *
+   * ```ts
+   * // Update all rows in the 'cars' table
+   * await db.update(cars).set({ color: 'red' });
+   *
+   * // Update rows with filters and conditions
+   * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+   *
+   * // Update with returning clause
+   * const updatedCar: Car[] = await db.update(cars)
+   *   .set({ color: 'red' })
+   *   .where(eq(cars.id, 1))
+   *   .returning();
+   * ```
+   */
+  update(e) {
+    return new xe(e, this.session, this.dialect);
+  }
+  $cache;
+  /**
+   * Creates an insert query.
+   *
+   * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/insert}
+   *
+   * @param table The table to insert into.
+   *
+   * @example
+   *
+   * ```ts
+   * // Insert one row
+   * await db.insert(cars).values({ brand: 'BMW' });
+   *
+   * // Insert multiple rows
+   * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+   *
+   * // Insert with returning clause
+   * const insertedCar: Car[] = await db.insert(cars)
+   *   .values({ brand: 'BMW' })
+   *   .returning();
+   * ```
+   */
+  insert(e) {
+    return new Te(e, this.session, this.dialect);
+  }
+  /**
+   * Creates a delete query.
+   *
+   * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+   *
+   * See docs: {@link https://orm.drizzle.team/docs/delete}
+   *
+   * @param table The table to delete from.
+   *
+   * @example
+   *
+   * ```ts
+   * // Delete all rows in the 'cars' table
+   * await db.delete(cars);
+   *
+   * // Delete rows with filters and conditions
+   * await db.delete(cars).where(eq(cars.color, 'green'));
+   *
+   * // Delete with returning clause
+   * const deletedCar: Car[] = await db.delete(cars)
+   *   .where(eq(cars.id, 1))
+   *   .returning();
+   * ```
+   */
+  delete(e) {
+    return new qe(e, this.session, this.dialect);
+  }
+  run(e) {
+    const t = typeof e == "string" ? n.raw(e) : e.getSQL();
+    return this.resultKind === "async" ? new Z(
+      async () => this.session.run(t),
+      () => t,
+      "run",
+      this.dialect,
+      this.session.extractRawRunValueFromBatchResult.bind(this.session)
+    ) : this.session.run(t);
+  }
+  all(e) {
+    const t = typeof e == "string" ? n.raw(e) : e.getSQL();
+    return this.resultKind === "async" ? new Z(
+      async () => this.session.all(t),
+      () => t,
+      "all",
+      this.dialect,
+      this.session.extractRawAllValueFromBatchResult.bind(this.session)
+    ) : this.session.all(t);
+  }
+  get(e) {
+    const t = typeof e == "string" ? n.raw(e) : e.getSQL();
+    return this.resultKind === "async" ? new Z(
+      async () => this.session.get(t),
+      () => t,
+      "get",
+      this.dialect,
+      this.session.extractRawGetValueFromBatchResult.bind(this.session)
+    ) : this.session.get(t);
+  }
+  values(e) {
+    const t = typeof e == "string" ? n.raw(e) : e.getSQL();
+    return this.resultKind === "async" ? new Z(
+      async () => this.session.values(t),
+      () => t,
+      "values",
+      this.dialect,
+      this.session.extractRawValuesValueFromBatchResult.bind(this.session)
+    ) : this.session.values(t);
+  }
+  transaction(e, t) {
+    return this.session.transaction(e, t);
+  }
+}
+class Wt {
+  static [f] = "Cache";
+}
+class ke extends Wt {
+  strategy() {
+    return "all";
+  }
+  static [f] = "NoopCache";
+  async get(e) {
+  }
+  async put(e, t, s, i) {
+  }
+  async onMutate(e) {
+  }
+}
+async function Be(l, e) {
+  const t = `${l}-${JSON.stringify(e)}`, i = new TextEncoder().encode(t), r = await crypto.subtle.digest("SHA-256", i);
+  return [...new Uint8Array(r)].map((c) => c.toString(16).padStart(2, "0")).join("");
+}
+class Ut extends D {
+  constructor(e) {
+    super(), this.resultCb = e;
+  }
+  static [f] = "ExecuteResultSync";
+  async execute() {
+    return this.resultCb();
+  }
+  sync() {
+    return this.resultCb();
+  }
+}
+class Ht {
+  constructor(e, t, s, i, r, a) {
+    this.mode = e, this.executeMethod = t, this.query = s, this.cache = i, this.queryMetadata = r, this.cacheConfig = a, i && i.strategy() === "all" && a === void 0 && (this.cacheConfig = { enable: !0, autoInvalidate: !0 }), this.cacheConfig?.enable || (this.cacheConfig = void 0);
+  }
+  static [f] = "PreparedQuery";
+  /** @internal */
+  joinsNotNullableMap;
+  /** @internal */
+  async queryWithCache(e, t, s) {
+    if (this.cache === void 0 || h(this.cache, ke) || this.queryMetadata === void 0)
+      try {
+        return await s();
+      } catch (i) {
+        throw new F(e, t, i);
+      }
+    if (this.cacheConfig && !this.cacheConfig.enable)
+      try {
+        return await s();
+      } catch (i) {
+        throw new F(e, t, i);
+      }
+    if ((this.queryMetadata.type === "insert" || this.queryMetadata.type === "update" || this.queryMetadata.type === "delete") && this.queryMetadata.tables.length > 0)
+      try {
+        const [i] = await Promise.all([
+          s(),
+          this.cache.onMutate({ tables: this.queryMetadata.tables })
+        ]);
+        return i;
+      } catch (i) {
+        throw new F(e, t, i);
+      }
+    if (!this.cacheConfig)
+      try {
+        return await s();
+      } catch (i) {
+        throw new F(e, t, i);
+      }
+    if (this.queryMetadata.type === "select") {
+      const i = await this.cache.get(
+        this.cacheConfig.tag ?? await Be(e, t),
+        this.queryMetadata.tables,
+        this.cacheConfig.tag !== void 0,
+        this.cacheConfig.autoInvalidate
+      );
+      if (i === void 0) {
+        let r;
+        try {
+          r = await s();
+        } catch (a) {
+          throw new F(e, t, a);
+        }
+        return await this.cache.put(
+          this.cacheConfig.tag ?? await Be(e, t),
+          r,
+          // make sure we send tables that were used in a query only if user wants to invalidate it on each write
+          this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [],
+          this.cacheConfig.tag !== void 0,
+          this.cacheConfig.config
+        ), r;
+      }
+      return i;
+    }
+    try {
+      return await s();
+    } catch (i) {
+      throw new F(e, t, i);
+    }
+  }
+  getQuery() {
+    return this.query;
+  }
+  mapRunResult(e, t) {
+    return e;
+  }
+  mapAllResult(e, t) {
+    throw new Error("Not implemented");
+  }
+  mapGetResult(e, t) {
+    throw new Error("Not implemented");
+  }
+  execute(e) {
+    return this.mode === "async" ? this[this.executeMethod](e) : new Ut(() => this[this.executeMethod](e));
+  }
+  mapResult(e, t) {
+    switch (this.executeMethod) {
+      case "run":
+        return this.mapRunResult(e, t);
+      case "all":
+        return this.mapAllResult(e, t);
+      case "get":
+        return this.mapGetResult(e, t);
+    }
+  }
+}
+class Yt {
+  constructor(e) {
+    this.dialect = e;
+  }
+  static [f] = "SQLiteSession";
+  prepareOneTimeQuery(e, t, s, i, r, a, o) {
+    return this.prepareQuery(
+      e,
+      t,
+      s,
+      i,
+      r,
+      a,
+      o
+    );
+  }
+  run(e) {
+    const t = this.dialect.sqlToQuery(e);
+    try {
+      return this.prepareOneTimeQuery(t, void 0, "run", !1).run();
+    } catch (s) {
+      throw new we({ cause: s, message: `Failed to run the query '${t.sql}'` });
+    }
+  }
+  /** @internal */
+  extractRawRunValueFromBatchResult(e) {
+    return e;
+  }
+  all(e) {
+    return this.prepareOneTimeQuery(this.dialect.sqlToQuery(e), void 0, "run", !1).all();
+  }
+  /** @internal */
+  extractRawAllValueFromBatchResult(e) {
+    throw new Error("Not implemented");
+  }
+  get(e) {
+    return this.prepareOneTimeQuery(this.dialect.sqlToQuery(e), void 0, "run", !1).get();
+  }
+  /** @internal */
+  extractRawGetValueFromBatchResult(e) {
+    throw new Error("Not implemented");
+  }
+  values(e) {
+    return this.prepareOneTimeQuery(this.dialect.sqlToQuery(e), void 0, "run", !1).values();
+  }
+  async count(e) {
+    return (await this.values(e))[0][0];
+  }
+  /** @internal */
+  extractRawValuesValueFromBatchResult(e) {
+    throw new Error("Not implemented");
+  }
+}
+class Gt extends Ke {
+  constructor(e, t, s, i, r = 0) {
+    super(e, t, s, i), this.schema = i, this.nestedIndex = r;
+  }
+  static [f] = "SQLiteTransaction";
+  rollback() {
+    throw new Mt();
+  }
+}
+class Zt extends Yt {
+  constructor(e, t, s, i, r = {}) {
+    super(t), this.client = e, this.schema = s, this.batchCLient = i, this.logger = r.logger ?? new St(), this.cache = r.cache ?? new ke();
+  }
+  static [f] = "SQLiteRemoteSession";
+  logger;
+  cache;
+  prepareQuery(e, t, s, i, r, a, o) {
+    return new Xt(
+      this.client,
+      e,
+      this.logger,
+      this.cache,
+      a,
+      o,
+      t,
+      s,
+      i,
+      r
+    );
+  }
+  async batch(e) {
+    const t = [], s = [];
+    for (const r of e) {
+      const a = r._prepare(), o = a.getQuery();
+      t.push(a), s.push({ sql: o.sql, params: o.params, method: o.method });
+    }
+    return (await this.batchCLient(s)).map((r, a) => t[a].mapResult(r, !0));
+  }
+  async transaction(e, t) {
+    const s = new ve("async", this.dialect, this, this.schema);
+    await this.run(n.raw(`begin${t?.behavior ? " " + t.behavior : ""}`));
+    try {
+      const i = await e(s);
+      return await this.run(n`commit`), i;
+    } catch (i) {
+      throw await this.run(n`rollback`), i;
+    }
+  }
+  extractRawAllValueFromBatchResult(e) {
+    return e.rows;
+  }
+  extractRawGetValueFromBatchResult(e) {
+    return e.rows[0];
+  }
+  extractRawValuesValueFromBatchResult(e) {
+    return e.rows;
+  }
+}
+class ve extends Gt {
+  static [f] = "SQLiteProxyTransaction";
+  async transaction(e) {
+    const t = `sp${this.nestedIndex}`, s = new ve("async", this.dialect, this.session, this.schema, this.nestedIndex + 1);
+    await this.session.run(n.raw(`savepoint ${t}`));
+    try {
+      const i = await e(s);
+      return await this.session.run(n.raw(`release savepoint ${t}`)), i;
+    } catch (i) {
+      throw await this.session.run(n.raw(`rollback to savepoint ${t}`)), i;
+    }
+  }
+}
+class Xt extends Ht {
+  constructor(e, t, s, i, r, a, o, c, u, d) {
+    super("async", c, t, i, r, a), this.client = e, this.logger = s, this.fields = o, this._isResponseInArrayMode = u, this.customResultMapper = d, this.customResultMapper = d, this.method = c;
+  }
+  static [f] = "SQLiteProxyPreparedQuery";
+  method;
+  getQuery() {
+    return { ...this.query, method: this.method };
+  }
+  async run(e) {
+    const t = G(this.query.params, e ?? {});
+    return this.logger.logQuery(this.query.sql, t), await this.queryWithCache(this.query.sql, t, async () => await this.client(this.query.sql, t, "run"));
+  }
+  mapAllResult(e, t) {
+    return t && (e = e.rows), !this.fields && !this.customResultMapper ? e : this.customResultMapper ? this.customResultMapper(e) : e.map((s) => $e(
+      this.fields,
+      s,
+      this.joinsNotNullableMap
+    ));
+  }
+  async all(e) {
+    const { query: t, logger: s, client: i } = this, r = G(t.params, e ?? {});
+    s.logQuery(t.sql, r);
+    const { rows: a } = await this.queryWithCache(t.sql, r, async () => await i(t.sql, r, "all"));
+    return this.mapAllResult(a);
+  }
+  async get(e) {
+    const { query: t, logger: s, client: i } = this, r = G(t.params, e ?? {});
+    s.logQuery(t.sql, r);
+    const a = await this.queryWithCache(t.sql, r, async () => await i(t.sql, r, "get"));
+    return this.mapGetResult(a.rows);
+  }
+  mapGetResult(e, t) {
+    t && (e = e.rows);
+    const s = e;
+    if (!this.fields && !this.customResultMapper)
+      return s;
+    if (s)
+      return this.customResultMapper ? this.customResultMapper([e]) : $e(
+        this.fields,
+        s,
+        this.joinsNotNullableMap
+      );
+  }
+  async values(e) {
+    const t = G(this.query.params, e ?? {});
+    return this.logger.logQuery(this.query.sql, t), (await this.queryWithCache(this.query.sql, t, async () => await this.client(this.query.sql, t, "values"))).rows;
+  }
+  /** @internal */
+  isResponseInArrayMode() {
+    return this._isResponseInArrayMode;
+  }
+}
+class es extends Ke {
+  static [f] = "SqliteRemoteDatabase";
+  async batch(e) {
+    return this.session.batch(e);
+  }
+}
+function ts(l, e, t) {
+  const s = new Et({ casing: t?.casing });
+  let i, r, a, o = {};
+  e && (typeof e == "function" ? (a = e, o = {}) : (a = void 0, o = e), o.logger === !0 ? i = new wt() : o.logger !== !1 && (i = o.logger, r = o.cache));
+  let c;
+  if (o.schema) {
+    const p = qt(
+      o.schema,
+      Rt
+    );
+    c = {
+      fullSchema: o.schema,
+      schema: p.tables,
+      tableNamesMap: p.tableNamesMap
+    };
+  }
+  const u = new Zt(l, s, c, a, { logger: i, cache: r }), d = new es("async", s, u, c);
+  return d.$cache = r, d.$cache && (d.$cache.invalidate = r?.onMutate), d;
+}
+const ss = ge(X, ({ many: l }) => ({
+  messages: l(J)
+})), is = ge(J, ({ one: l, many: e }) => ({
+  chat: l(X, {
+    fields: [J.aiChatId],
+    references: [X.id]
+  }),
+  parts: e(ee)
+})), rs = ge(ee, ({ one: l }) => ({
+  message: l(J, {
+    fields: [ee.aiMessageId],
+    references: [J.id]
+  })
+})), ns = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  aiChats: X,
+  aiChatsRelations: ss,
+  aiMessageParts: ee,
+  aiMessagePartsRelations: rs,
+  aiMessages: J,
+  aiMessagesRelations: is,
+  history: Ve,
+  stepContext: We
+}, Symbol.toStringTag, { value: "Module" }));
+function as(l) {
+  return l.map((e) => e === "" ? null : e);
+}
+class me {
+  constructor(e) {
+    this.dbPath = e, this.db = ts(
+      async (t, s, i) => {
+        try {
+          const a = (await Qe("db_query", {
+            params: { sql: t, params: s || [] }
+          })).rows || [];
+          if (a.length === 0 && i === "get")
+            return {};
+          const o = a.map(as);
+          return { rows: i === "get" ? o[0] : o };
+        } catch (r) {
+          throw console.error("SQLite proxy error:", r), r;
+        }
+      },
+      { schema: ns }
+    );
+  }
+  dbPath;
+  static instances = /* @__PURE__ */ new Map();
+  initPromise = null;
+  db;
+  /**
+   * Get or create singleton instance for a database path
+   * All entities with the same dbPath share this instance
+   */
+  static getInstance(e) {
+    let t = this.instances.get(e);
+    return t || (t = new me(e), this.instances.set(e, t)), t;
+  }
+  /**
+   * Initialize database connection
+   * Handles concurrent initialization - only runs once even if called multiple times
+   */
+  async initialize() {
+    if (this.initPromise)
+      return this.initPromise;
+    this.initPromise = Qe("db_init", { dbPath: this.dbPath });
+    try {
+      await this.initPromise;
+    } catch (e) {
+      throw this.initPromise = null, e;
+    }
+  }
+  async close() {
+    me.instances.delete(this.dbPath);
+  }
+}
+export {
+  me as SqliteDBStorage
+};