@uiid/bertrand 0.10.0 → 0.10.1

package/dist/bertrand.js

@@ -101,4292 +101,6 @@ var init_router = __esm(() => {
   aliases = new Map;
 });
 
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/entity.js
-function is(value, type) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  if (value instanceof type) {
-    return true;
-  }
-  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
-    throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
-  }
-  let cls = Object.getPrototypeOf(value).constructor;
-  if (cls) {
-    while (cls) {
-      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
-        return true;
-      }
-      cls = Object.getPrototypeOf(cls);
-    }
-  }
-  return false;
-}
-var entityKind, hasOwnEntityKind;
-var init_entity = __esm(() => {
-  entityKind = Symbol.for("drizzle:entityKind");
-  hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/column.js
-var Column;
-var init_column = __esm(() => {
-  init_entity();
-  Column = class Column {
-    constructor(table, config) {
-      this.table = table;
-      this.config = config;
-      this.name = config.name;
-      this.keyAsName = config.keyAsName;
-      this.notNull = config.notNull;
-      this.default = config.default;
-      this.defaultFn = config.defaultFn;
-      this.onUpdateFn = config.onUpdateFn;
-      this.hasDefault = config.hasDefault;
-      this.primary = config.primaryKey;
-      this.isUnique = config.isUnique;
-      this.uniqueName = config.uniqueName;
-      this.uniqueType = config.uniqueType;
-      this.dataType = config.dataType;
-      this.columnType = config.columnType;
-      this.generated = config.generated;
-      this.generatedIdentity = config.generatedIdentity;
-    }
-    static [entityKind] = "Column";
-    name;
-    keyAsName;
-    primary;
-    notNull;
-    default;
-    defaultFn;
-    onUpdateFn;
-    hasDefault;
-    isUnique;
-    uniqueName;
-    uniqueType;
-    dataType;
-    columnType;
-    enumValues = undefined;
-    generated = undefined;
-    generatedIdentity = undefined;
-    config;
-    mapFromDriverValue(value) {
-      return value;
-    }
-    mapToDriverValue(value) {
-      return value;
-    }
-    shouldDisableInsert() {
-      return this.config.generated !== undefined && this.config.generated.type !== "byDefault";
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/column-builder.js
-var ColumnBuilder;
-var init_column_builder = __esm(() => {
-  init_entity();
-  ColumnBuilder = class ColumnBuilder {
-    static [entityKind] = "ColumnBuilder";
-    config;
-    constructor(name, dataType, columnType) {
-      this.config = {
-        name,
-        keyAsName: name === "",
-        notNull: false,
-        default: undefined,
-        hasDefault: false,
-        primaryKey: false,
-        isUnique: false,
-        uniqueName: undefined,
-        uniqueType: undefined,
-        dataType,
-        columnType,
-        generated: undefined
-      };
-    }
-    $type() {
-      return this;
-    }
-    notNull() {
-      this.config.notNull = true;
-      return this;
-    }
-    default(value) {
-      this.config.default = value;
-      this.config.hasDefault = true;
-      return this;
-    }
-    $defaultFn(fn) {
-      this.config.defaultFn = fn;
-      this.config.hasDefault = true;
-      return this;
-    }
-    $default = this.$defaultFn;
-    $onUpdateFn(fn) {
-      this.config.onUpdateFn = fn;
-      this.config.hasDefault = true;
-      return this;
-    }
-    $onUpdate = this.$onUpdateFn;
-    primaryKey() {
-      this.config.primaryKey = true;
-      this.config.notNull = true;
-      return this;
-    }
-    setName(name) {
-      if (this.config.name !== "")
-        return;
-      this.config.name = name;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/table.utils.js
-var TableName;
-var init_table_utils = __esm(() => {
-  TableName = Symbol.for("drizzle:Name");
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/tracing-utils.js
-function iife(fn, ...args) {
-  return fn(...args);
-}
-var init_tracing_utils = () => {};
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/pg-core/unique-constraint.js
-function uniqueKeyName(table, columns) {
-  return `${table[TableName]}_${columns.join("_")}_unique`;
-}
-var init_unique_constraint = __esm(() => {
-  init_table_utils();
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/pg-core/columns/common.js
-var PgColumn, ExtraConfigColumn;
-var init_common = __esm(() => {
-  init_column();
-  init_entity();
-  init_unique_constraint();
-  PgColumn = class PgColumn extends Column {
-    constructor(table, config) {
-      if (!config.uniqueName) {
-        config.uniqueName = uniqueKeyName(table, [config.name]);
-      }
-      super(table, config);
-      this.table = table;
-    }
-    static [entityKind] = "PgColumn";
-  };
-  ExtraConfigColumn = class ExtraConfigColumn extends PgColumn {
-    static [entityKind] = "ExtraConfigColumn";
-    getSQLType() {
-      return this.getSQLType();
-    }
-    indexConfig = {
-      order: this.config.order ?? "asc",
-      nulls: this.config.nulls ?? "last",
-      opClass: this.config.opClass
-    };
-    defaultConfig = {
-      order: "asc",
-      nulls: "last",
-      opClass: undefined
-    };
-    asc() {
-      this.indexConfig.order = "asc";
-      return this;
-    }
-    desc() {
-      this.indexConfig.order = "desc";
-      return this;
-    }
-    nullsFirst() {
-      this.indexConfig.nulls = "first";
-      return this;
-    }
-    nullsLast() {
-      this.indexConfig.nulls = "last";
-      return this;
-    }
-    op(opClass) {
-      this.indexConfig.opClass = opClass;
-      return this;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/pg-core/columns/enum.js
-function isPgEnum(obj) {
-  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
-}
-var PgEnumObjectColumn, isPgEnumSym, PgEnumColumn;
-var init_enum = __esm(() => {
-  init_entity();
-  init_common();
-  PgEnumObjectColumn = class PgEnumObjectColumn extends PgColumn {
-    static [entityKind] = "PgEnumObjectColumn";
-    enum;
-    enumValues = this.config.enum.enumValues;
-    constructor(table, config) {
-      super(table, config);
-      this.enum = config.enum;
-    }
-    getSQLType() {
-      return this.enum.enumName;
-    }
-  };
-  isPgEnumSym = Symbol.for("drizzle:isPgEnum");
-  PgEnumColumn = class PgEnumColumn extends PgColumn {
-    static [entityKind] = "PgEnumColumn";
-    enum = this.config.enum;
-    enumValues = this.config.enum.enumValues;
-    constructor(table, config) {
-      super(table, config);
-      this.enum = config.enum;
-    }
-    getSQLType() {
-      return this.enum.enumName;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/subquery.js
-var Subquery, WithSubquery;
-var init_subquery = __esm(() => {
-  init_entity();
-  Subquery = class Subquery {
-    static [entityKind] = "Subquery";
-    constructor(sql, fields, alias2, isWith = false, usedTables = []) {
-      this._ = {
-        brand: "Subquery",
-        sql,
-        selectedFields: fields,
-        alias: alias2,
-        isWith,
-        usedTables
-      };
-    }
-  };
-  WithSubquery = class WithSubquery extends Subquery {
-    static [entityKind] = "WithSubquery";
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/version.js
-var version = "0.44.7";
-var init_version = () => {};
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/tracing.js
-var otel, rawTracer, tracer;
-var init_tracing = __esm(() => {
-  init_tracing_utils();
-  init_version();
-  tracer = {
-    startActiveSpan(name, fn) {
-      if (!otel) {
-        return fn();
-      }
-      if (!rawTracer) {
-        rawTracer = otel.trace.getTracer("drizzle-orm", version);
-      }
-      return iife((otel2, rawTracer2) => rawTracer2.startActiveSpan(name, (span) => {
-        try {
-          return fn(span);
-        } catch (e) {
-          span.setStatus({
-            code: otel2.SpanStatusCode.ERROR,
-            message: e instanceof Error ? e.message : "Unknown error"
-          });
-          throw e;
-        } finally {
-          span.end();
-        }
-      }), otel, rawTracer);
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/view-common.js
-var ViewBaseConfig;
-var init_view_common = __esm(() => {
-  ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/table.js
-function getTableName(table) {
-  return table[TableName];
-}
-function getTableUniqueName(table) {
-  return `${table[Schema] ?? "public"}.${table[TableName]}`;
-}
-var Schema, Columns, ExtraConfigColumns, OriginalName, BaseName, IsAlias, ExtraConfigBuilder, IsDrizzleTable, Table;
-var init_table = __esm(() => {
-  init_entity();
-  init_table_utils();
-  Schema = Symbol.for("drizzle:Schema");
-  Columns = Symbol.for("drizzle:Columns");
-  ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
-  OriginalName = Symbol.for("drizzle:OriginalName");
-  BaseName = Symbol.for("drizzle:BaseName");
-  IsAlias = Symbol.for("drizzle:IsAlias");
-  ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
-  IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
-  Table = class Table {
-    static [entityKind] = "Table";
-    static Symbol = {
-      Name: TableName,
-      Schema,
-      OriginalName,
-      Columns,
-      ExtraConfigColumns,
-      BaseName,
-      IsAlias,
-      ExtraConfigBuilder
-    };
-    [TableName];
-    [OriginalName];
-    [Schema];
-    [Columns];
-    [ExtraConfigColumns];
-    [BaseName];
-    [IsAlias] = false;
-    [IsDrizzleTable] = true;
-    [ExtraConfigBuilder] = undefined;
-    constructor(name, schema, baseName) {
-      this[TableName] = this[OriginalName] = name;
-      this[Schema] = schema;
-      this[BaseName] = baseName;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sql/sql.js
-function isSQLWrapper(value) {
-  return value !== null && value !== undefined && typeof value.getSQL === "function";
-}
-function mergeQueries(queries) {
-  const result = { sql: "", params: [] };
-  for (const query of queries) {
-    result.sql += query.sql;
-    result.params.push(...query.params);
-    if (query.typings?.length) {
-      if (!result.typings) {
-        result.typings = [];
-      }
-      result.typings.push(...query.typings);
-    }
-  }
-  return result;
-}
-function isDriverValueEncoder(value) {
-  return typeof value === "object" && value !== null && "mapToDriverValue" in value && typeof value.mapToDriverValue === "function";
-}
-function sql(strings, ...params) {
-  const queryChunks = [];
-  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
-    queryChunks.push(new StringChunk(strings[0]));
-  }
-  for (const [paramIndex, param2] of params.entries()) {
-    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
-  }
-  return new SQL(queryChunks);
-}
-function fillPlaceholders(params, values) {
-  return params.map((p) => {
-    if (is(p, Placeholder)) {
-      if (!(p.name in values)) {
-        throw new Error(`No value for placeholder "${p.name}" was provided`);
-      }
-      return values[p.name];
-    }
-    if (is(p, Param) && is(p.value, Placeholder)) {
-      if (!(p.value.name in values)) {
-        throw new Error(`No value for placeholder "${p.value.name}" was provided`);
-      }
-      return p.encoder.mapToDriverValue(values[p.value.name]);
-    }
-    return p;
-  });
-}
-var StringChunk, SQL, Name, noopDecoder, noopEncoder, noopMapper, Param, Placeholder, IsDrizzleView, View;
-var init_sql = __esm(() => {
-  init_entity();
-  init_enum();
-  init_subquery();
-  init_tracing();
-  init_view_common();
-  init_column();
-  init_table();
-  StringChunk = class StringChunk {
-    static [entityKind] = "StringChunk";
-    value;
-    constructor(value) {
-      this.value = Array.isArray(value) ? value : [value];
-    }
-    getSQL() {
-      return new SQL([this]);
-    }
-  };
-  SQL = class SQL {
-    constructor(queryChunks) {
-      this.queryChunks = queryChunks;
-      for (const chunk of queryChunks) {
-        if (is(chunk, Table)) {
-          const schemaName = chunk[Table.Symbol.Schema];
-          this.usedTables.push(schemaName === undefined ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
-        }
-      }
-    }
-    static [entityKind] = "SQL";
-    decoder = noopDecoder;
-    shouldInlineParams = false;
-    usedTables = [];
-    append(query) {
-      this.queryChunks.push(...query.queryChunks);
-      return this;
-    }
-    toQuery(config) {
-      return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
-        const query = this.buildQueryFromSourceParams(this.queryChunks, config);
-        span?.setAttributes({
-          "drizzle.query.text": query.sql,
-          "drizzle.query.params": JSON.stringify(query.params)
-        });
-        return query;
-      });
-    }
-    buildQueryFromSourceParams(chunks, _config) {
-      const config = Object.assign({}, _config, {
-        inlineParams: _config.inlineParams || this.shouldInlineParams,
-        paramStartIndex: _config.paramStartIndex || { value: 0 }
-      });
-      const {
-        casing,
-        escapeName,
-        escapeParam,
-        prepareTyping,
-        inlineParams,
-        paramStartIndex
-      } = config;
-      return mergeQueries(chunks.map((chunk) => {
-        if (is(chunk, StringChunk)) {
-          return { sql: chunk.value.join(""), params: [] };
-        }
-        if (is(chunk, Name)) {
-          return { sql: escapeName(chunk.value), params: [] };
-        }
-        if (chunk === undefined) {
-          return { sql: "", params: [] };
-        }
-        if (Array.isArray(chunk)) {
-          const result = [new StringChunk("(")];
-          for (const [i, p] of chunk.entries()) {
-            result.push(p);
-            if (i < chunk.length - 1) {
-              result.push(new StringChunk(", "));
-            }
-          }
-          result.push(new StringChunk(")"));
-          return this.buildQueryFromSourceParams(result, config);
-        }
-        if (is(chunk, SQL)) {
-          return this.buildQueryFromSourceParams(chunk.queryChunks, {
-            ...config,
-            inlineParams: inlineParams || chunk.shouldInlineParams
-          });
-        }
-        if (is(chunk, Table)) {
-          const schemaName = chunk[Table.Symbol.Schema];
-          const tableName = chunk[Table.Symbol.Name];
-          return {
-            sql: schemaName === undefined || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
-            params: []
-          };
-        }
-        if (is(chunk, Column)) {
-          const columnName = casing.getColumnCasing(chunk);
-          if (_config.invokeSource === "indexes") {
-            return { sql: escapeName(columnName), params: [] };
-          }
-          const schemaName = chunk.table[Table.Symbol.Schema];
-          return {
-            sql: chunk.table[IsAlias] || schemaName === undefined ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
-            params: []
-          };
-        }
-        if (is(chunk, View)) {
-          const schemaName = chunk[ViewBaseConfig].schema;
-          const viewName = chunk[ViewBaseConfig].name;
-          return {
-            sql: schemaName === undefined || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
-            params: []
-          };
-        }
-        if (is(chunk, Param)) {
-          if (is(chunk.value, Placeholder)) {
-            return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
-          }
-          const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
-          if (is(mappedValue, SQL)) {
-            return this.buildQueryFromSourceParams([mappedValue], config);
-          }
-          if (inlineParams) {
-            return { sql: this.mapInlineParam(mappedValue, config), params: [] };
-          }
-          let typings = ["none"];
-          if (prepareTyping) {
-            typings = [prepareTyping(chunk.encoder)];
-          }
-          return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
-        }
-        if (is(chunk, Placeholder)) {
-          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
-        }
-        if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
-          return { sql: escapeName(chunk.fieldAlias), params: [] };
-        }
-        if (is(chunk, Subquery)) {
-          if (chunk._.isWith) {
-            return { sql: escapeName(chunk._.alias), params: [] };
-          }
-          return this.buildQueryFromSourceParams([
-            new StringChunk("("),
-            chunk._.sql,
-            new StringChunk(") "),
-            new Name(chunk._.alias)
-          ], config);
-        }
-        if (isPgEnum(chunk)) {
-          if (chunk.schema) {
-            return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
-          }
-          return { sql: escapeName(chunk.enumName), params: [] };
-        }
-        if (isSQLWrapper(chunk)) {
-          if (chunk.shouldOmitSQLParens?.()) {
-            return this.buildQueryFromSourceParams([chunk.getSQL()], config);
-          }
-          return this.buildQueryFromSourceParams([
-            new StringChunk("("),
-            chunk.getSQL(),
-            new StringChunk(")")
-          ], config);
-        }
-        if (inlineParams) {
-          return { sql: this.mapInlineParam(chunk, config), params: [] };
-        }
-        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
-      }));
-    }
-    mapInlineParam(chunk, { escapeString }) {
-      if (chunk === null) {
-        return "null";
-      }
-      if (typeof chunk === "number" || typeof chunk === "boolean") {
-        return chunk.toString();
-      }
-      if (typeof chunk === "string") {
-        return escapeString(chunk);
-      }
-      if (typeof chunk === "object") {
-        const mappedValueAsString = chunk.toString();
-        if (mappedValueAsString === "[object Object]") {
-          return escapeString(JSON.stringify(chunk));
-        }
-        return escapeString(mappedValueAsString);
-      }
-      throw new Error("Unexpected param value: " + chunk);
-    }
-    getSQL() {
-      return this;
-    }
-    as(alias2) {
-      if (alias2 === undefined) {
-        return this;
-      }
-      return new SQL.Aliased(this, alias2);
-    }
-    mapWith(decoder) {
-      this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
-      return this;
-    }
-    inlineParams() {
-      this.shouldInlineParams = true;
-      return this;
-    }
-    if(condition) {
-      return condition ? this : undefined;
-    }
-  };
-  Name = class Name {
-    constructor(value) {
-      this.value = value;
-    }
-    static [entityKind] = "Name";
-    brand;
-    getSQL() {
-      return new SQL([this]);
-    }
-  };
-  noopDecoder = {
-    mapFromDriverValue: (value) => value
-  };
-  noopEncoder = {
-    mapToDriverValue: (value) => value
-  };
-  noopMapper = {
-    ...noopDecoder,
-    ...noopEncoder
-  };
-  Param = class Param {
-    constructor(value, encoder = noopEncoder) {
-      this.value = value;
-      this.encoder = encoder;
-    }
-    static [entityKind] = "Param";
-    brand;
-    getSQL() {
-      return new SQL([this]);
-    }
-  };
-  ((sql2) => {
-    function empty() {
-      return new SQL([]);
-    }
-    sql2.empty = empty;
-    function fromList(list) {
-      return new SQL(list);
-    }
-    sql2.fromList = fromList;
-    function raw(str) {
-      return new SQL([new StringChunk(str)]);
-    }
-    sql2.raw = raw;
-    function join2(chunks, separator) {
-      const result = [];
-      for (const [i, chunk] of chunks.entries()) {
-        if (i > 0 && separator !== undefined) {
-          result.push(separator);
-        }
-        result.push(chunk);
-      }
-      return new SQL(result);
-    }
-    sql2.join = join2;
-    function identifier(value) {
-      return new Name(value);
-    }
-    sql2.identifier = identifier;
-    function placeholder2(name2) {
-      return new Placeholder(name2);
-    }
-    sql2.placeholder = placeholder2;
-    function param2(value, encoder) {
-      return new Param(value, encoder);
-    }
-    sql2.param = param2;
-  })(sql || (sql = {}));
-  ((SQL2) => {
-
-    class Aliased {
-      constructor(sql2, fieldAlias) {
-        this.sql = sql2;
-        this.fieldAlias = fieldAlias;
-      }
-      static [entityKind] = "SQL.Aliased";
-      isSelectionField = false;
-      getSQL() {
-        return this.sql;
-      }
-      clone() {
-        return new Aliased(this.sql, this.fieldAlias);
-      }
-    }
-    SQL2.Aliased = Aliased;
-  })(SQL || (SQL = {}));
-  Placeholder = class Placeholder {
-    constructor(name2) {
-      this.name = name2;
-    }
-    static [entityKind] = "Placeholder";
-    getSQL() {
-      return new SQL([this]);
-    }
-  };
-  IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
-  View = class View {
-    static [entityKind] = "View";
-    [ViewBaseConfig];
-    [IsDrizzleView] = true;
-    constructor({ name: name2, schema, selectedFields, query }) {
-      this[ViewBaseConfig] = {
-        name: name2,
-        originalName: name2,
-        schema,
-        selectedFields,
-        query,
-        isExisting: !query,
-        isAlias: false
-      };
-    }
-    getSQL() {
-      return new SQL([this]);
-    }
-  };
-  Column.prototype.getSQL = function() {
-    return new SQL([this]);
-  };
-  Table.prototype.getSQL = function() {
-    return new SQL([this]);
-  };
-  Subquery.prototype.getSQL = function() {
-    return new SQL([this]);
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/alias.js
-function aliasedTable(table, tableAlias) {
-  return new Proxy(table, new TableAliasProxyHandler(tableAlias, false));
-}
-function aliasedTableColumn(column, tableAlias) {
-  return new Proxy(column, new ColumnAliasProxyHandler(new Proxy(column.table, new TableAliasProxyHandler(tableAlias, false))));
-}
-function mapColumnsInAliasedSQLToAlias(query, alias2) {
-  return new SQL.Aliased(mapColumnsInSQLToAlias(query.sql, alias2), query.fieldAlias);
-}
-function mapColumnsInSQLToAlias(query, alias2) {
-  return sql.join(query.queryChunks.map((c) => {
-    if (is(c, Column)) {
-      return aliasedTableColumn(c, alias2);
-    }
-    if (is(c, SQL)) {
-      return mapColumnsInSQLToAlias(c, alias2);
-    }
-    if (is(c, SQL.Aliased)) {
-      return mapColumnsInAliasedSQLToAlias(c, alias2);
-    }
-    return c;
-  }));
-}
-var ColumnAliasProxyHandler, TableAliasProxyHandler;
-var init_alias = __esm(() => {
-  init_column();
-  init_entity();
-  init_sql();
-  init_table();
-  init_view_common();
-  ColumnAliasProxyHandler = class ColumnAliasProxyHandler {
-    constructor(table) {
-      this.table = table;
-    }
-    static [entityKind] = "ColumnAliasProxyHandler";
-    get(columnObj, prop) {
-      if (prop === "table") {
-        return this.table;
-      }
-      return columnObj[prop];
-    }
-  };
-  TableAliasProxyHandler = class TableAliasProxyHandler {
-    constructor(alias2, replaceOriginalName) {
-      this.alias = alias2;
-      this.replaceOriginalName = replaceOriginalName;
-    }
-    static [entityKind] = "TableAliasProxyHandler";
-    get(target, prop) {
-      if (prop === Table.Symbol.IsAlias) {
-        return true;
-      }
-      if (prop === Table.Symbol.Name) {
-        return this.alias;
-      }
-      if (this.replaceOriginalName && prop === Table.Symbol.OriginalName) {
-        return this.alias;
-      }
-      if (prop === ViewBaseConfig) {
-        return {
-          ...target[ViewBaseConfig],
-          name: this.alias,
-          isAlias: true
-        };
-      }
-      if (prop === Table.Symbol.Columns) {
-        const columns = target[Table.Symbol.Columns];
-        if (!columns) {
-          return columns;
-        }
-        const proxiedColumns = {};
-        Object.keys(columns).map((key) => {
-          proxiedColumns[key] = new Proxy(columns[key], new ColumnAliasProxyHandler(new Proxy(target, this)));
-        });
-        return proxiedColumns;
-      }
-      const value = target[prop];
-      if (is(value, Column)) {
-        return new Proxy(value, new ColumnAliasProxyHandler(new Proxy(target, this)));
-      }
-      return value;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/errors.js
-var DrizzleError, DrizzleQueryError, TransactionRollbackError;
-var init_errors = __esm(() => {
-  init_entity();
-  DrizzleError = class DrizzleError extends Error {
-    static [entityKind] = "DrizzleError";
-    constructor({ message, cause }) {
-      super(message);
-      this.name = "DrizzleError";
-      this.cause = cause;
-    }
-  };
-  DrizzleQueryError = class DrizzleQueryError extends Error {
-    constructor(query, params, cause) {
-      super(`Failed query: ${query}
-params: ${params}`);
-      this.query = query;
-      this.params = params;
-      this.cause = cause;
-      Error.captureStackTrace(this, DrizzleQueryError);
-      if (cause)
-        this.cause = cause;
-    }
-  };
-  TransactionRollbackError = class TransactionRollbackError extends DrizzleError {
-    static [entityKind] = "TransactionRollbackError";
-    constructor() {
-      super({ message: "Rollback" });
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/logger.js
-var ConsoleLogWriter, DefaultLogger, NoopLogger;
-var init_logger = __esm(() => {
-  init_entity();
-  ConsoleLogWriter = class ConsoleLogWriter {
-    static [entityKind] = "ConsoleLogWriter";
-    write(message) {
-      console.log(message);
-    }
-  };
-  DefaultLogger = class DefaultLogger {
-    static [entityKind] = "DefaultLogger";
-    writer;
-    constructor(config) {
-      this.writer = config?.writer ?? new ConsoleLogWriter;
-    }
-    logQuery(query, params) {
-      const stringifiedParams = params.map((p) => {
-        try {
-          return JSON.stringify(p);
-        } catch {
-          return String(p);
-        }
-      });
-      const paramsStr = stringifiedParams.length ? ` -- params: [${stringifiedParams.join(", ")}]` : "";
-      this.writer.write(`Query: ${query}${paramsStr}`);
-    }
-  };
-  NoopLogger = class NoopLogger {
-    static [entityKind] = "NoopLogger";
-    logQuery() {}
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/query-promise.js
-var QueryPromise;
-var init_query_promise = __esm(() => {
-  init_entity();
-  QueryPromise = class QueryPromise {
-    static [entityKind] = "QueryPromise";
-    [Symbol.toStringTag] = "QueryPromise";
-    catch(onRejected) {
-      return this.then(undefined, onRejected);
-    }
-    finally(onFinally) {
-      return this.then((value) => {
-        onFinally?.();
-        return value;
-      }, (reason) => {
-        onFinally?.();
-        throw reason;
-      });
-    }
-    then(onFulfilled, onRejected) {
-      return this.execute().then(onFulfilled, onRejected);
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/utils.js
-function mapResultRow(columns, row, joinsNotNullableMap) {
-  const nullifyMap = {};
-  const result = columns.reduce((result2, { path, field }, columnIndex) => {
-    let decoder;
-    if (is(field, Column)) {
-      decoder = field;
-    } else if (is(field, SQL)) {
-      decoder = field.decoder;
-    } else {
-      decoder = field.sql.decoder;
-    }
-    let node = result2;
-    for (const [pathChunkIndex, pathChunk] of path.entries()) {
-      if (pathChunkIndex < path.length - 1) {
-        if (!(pathChunk in node)) {
-          node[pathChunk] = {};
-        }
-        node = node[pathChunk];
-      } else {
-        const rawValue = row[columnIndex];
-        const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-        if (joinsNotNullableMap && is(field, Column) && path.length === 2) {
-          const objectName = path[0];
-          if (!(objectName in nullifyMap)) {
-            nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
-          } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
-            nullifyMap[objectName] = false;
-          }
-        }
-      }
-    }
-    return result2;
-  }, {});
-  if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
-    for (const [objectName, tableName] of Object.entries(nullifyMap)) {
-      if (typeof tableName === "string" && !joinsNotNullableMap[tableName]) {
-        result[objectName] = null;
-      }
-    }
-  }
-  return result;
-}
-function orderSelectedFields(fields, pathPrefix) {
-  return Object.entries(fields).reduce((result, [name, field]) => {
-    if (typeof name !== "string") {
-      return result;
-    }
-    const newPath = pathPrefix ? [...pathPrefix, name] : [name];
-    if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased)) {
-      result.push({ path: newPath, field });
-    } else if (is(field, Table)) {
-      result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath));
-    } else {
-      result.push(...orderSelectedFields(field, newPath));
-    }
-    return result;
-  }, []);
-}
-function haveSameKeys(left, right) {
-  const leftKeys = Object.keys(left);
-  const rightKeys = Object.keys(right);
-  if (leftKeys.length !== rightKeys.length) {
-    return false;
-  }
-  for (const [index, key] of leftKeys.entries()) {
-    if (key !== rightKeys[index]) {
-      return false;
-    }
-  }
-  return true;
-}
-function mapUpdateSet(table, values) {
-  const entries = Object.entries(values).filter(([, value]) => value !== undefined).map(([key, value]) => {
-    if (is(value, SQL) || is(value, Column)) {
-      return [key, value];
-    } else {
-      return [key, new Param(value, table[Table.Symbol.Columns][key])];
-    }
-  });
-  if (entries.length === 0) {
-    throw new Error("No values to set");
-  }
-  return Object.fromEntries(entries);
-}
-function applyMixins(baseClass, extendedClasses) {
-  for (const extendedClass of extendedClasses) {
-    for (const name of Object.getOwnPropertyNames(extendedClass.prototype)) {
-      if (name === "constructor")
-        continue;
-      Object.defineProperty(baseClass.prototype, name, Object.getOwnPropertyDescriptor(extendedClass.prototype, name) || /* @__PURE__ */ Object.create(null));
-    }
-  }
-}
-function getTableColumns(table) {
-  return table[Table.Symbol.Columns];
-}
-function getTableLikeName(table) {
-  return is(table, Subquery) ? table._.alias : is(table, View) ? table[ViewBaseConfig].name : is(table, SQL) ? undefined : table[Table.Symbol.IsAlias] ? table[Table.Symbol.Name] : table[Table.Symbol.BaseName];
-}
-function getColumnNameAndConfig(a, b) {
-  return {
-    name: typeof a === "string" && a.length > 0 ? a : "",
-    config: typeof a === "object" ? a : b
-  };
-}
-function isConfig(data) {
-  if (typeof data !== "object" || data === null)
-    return false;
-  if (data.constructor.name !== "Object")
-    return false;
-  if ("logger" in data) {
-    const type = typeof data["logger"];
-    if (type !== "boolean" && (type !== "object" || typeof data["logger"]["logQuery"] !== "function") && type !== "undefined")
-      return false;
-    return true;
-  }
-  if ("schema" in data) {
-    const type = typeof data["schema"];
-    if (type !== "object" && type !== "undefined")
-      return false;
-    return true;
-  }
-  if ("casing" in data) {
-    const type = typeof data["casing"];
-    if (type !== "string" && type !== "undefined")
-      return false;
-    return true;
-  }
-  if ("mode" in data) {
-    if (data["mode"] !== "default" || data["mode"] !== "planetscale" || data["mode"] !== undefined)
-      return false;
-    return true;
-  }
-  if ("connection" in data) {
-    const type = typeof data["connection"];
-    if (type !== "string" && type !== "object" && type !== "undefined")
-      return false;
-    return true;
-  }
-  if ("client" in data) {
-    const type = typeof data["client"];
-    if (type !== "object" && type !== "function" && type !== "undefined")
-      return false;
-    return true;
-  }
-  if (Object.keys(data).length === 0)
-    return true;
-  return false;
-}
-var textDecoder;
-var init_utils = __esm(() => {
-  init_column();
-  init_entity();
-  init_sql();
-  init_subquery();
-  init_table();
-  init_view_common();
-  textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/pg-core/table.js
-var InlineForeignKeys, EnableRLS, PgTable;
-var init_table2 = __esm(() => {
-  init_entity();
-  init_table();
-  InlineForeignKeys = Symbol.for("drizzle:PgInlineForeignKeys");
-  EnableRLS = Symbol.for("drizzle:EnableRLS");
-  PgTable = class PgTable extends Table {
-    static [entityKind] = "PgTable";
-    static Symbol = Object.assign({}, Table.Symbol, {
-      InlineForeignKeys,
-      EnableRLS
-    });
-    [InlineForeignKeys] = [];
-    [EnableRLS] = false;
-    [Table.Symbol.ExtraConfigBuilder] = undefined;
-    [Table.Symbol.ExtraConfigColumns] = {};
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/pg-core/primary-keys.js
-var PrimaryKeyBuilder, PrimaryKey;
-var init_primary_keys = __esm(() => {
-  init_entity();
-  init_table2();
-  PrimaryKeyBuilder = class PrimaryKeyBuilder {
-    static [entityKind] = "PgPrimaryKeyBuilder";
-    columns;
-    name;
-    constructor(columns, name) {
-      this.columns = columns;
-      this.name = name;
-    }
-    build(table) {
-      return new PrimaryKey(table, this.columns, this.name);
-    }
-  };
-  PrimaryKey = class PrimaryKey {
-    constructor(table, columns, name) {
-      this.table = table;
-      this.columns = columns;
-      this.name = name;
-    }
-    static [entityKind] = "PgPrimaryKey";
-    columns;
-    name;
-    getName() {
-      return this.name ?? `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sql/expressions/conditions.js
-function bindIfParam(value, column) {
-  if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) {
-    return new Param(value, column);
-  }
-  return value;
-}
-function and(...unfilteredConditions) {
-  const conditions = unfilteredConditions.filter((c) => c !== undefined);
-  if (conditions.length === 0) {
-    return;
-  }
-  if (conditions.length === 1) {
-    return new SQL(conditions);
-  }
-  return new SQL([
-    new StringChunk("("),
-    sql.join(conditions, new StringChunk(" and ")),
-    new StringChunk(")")
-  ]);
-}
-function or(...unfilteredConditions) {
-  const conditions = unfilteredConditions.filter((c) => c !== undefined);
-  if (conditions.length === 0) {
-    return;
-  }
-  if (conditions.length === 1) {
-    return new SQL(conditions);
-  }
-  return new SQL([
-    new StringChunk("("),
-    sql.join(conditions, new StringChunk(" or ")),
-    new StringChunk(")")
-  ]);
-}
-function not(condition) {
-  return sql`not ${condition}`;
-}
-function inArray(column, values) {
-  if (Array.isArray(values)) {
-    if (values.length === 0) {
-      return sql`false`;
-    }
-    return sql`${column} in ${values.map((v) => bindIfParam(v, column))}`;
-  }
-  return sql`${column} in ${bindIfParam(values, column)}`;
-}
-function notInArray(column, values) {
-  if (Array.isArray(values)) {
-    if (values.length === 0) {
-      return sql`true`;
-    }
-    return sql`${column} not in ${values.map((v) => bindIfParam(v, column))}`;
-  }
-  return sql`${column} not in ${bindIfParam(values, column)}`;
-}
-function isNull(value) {
-  return sql`${value} is null`;
-}
-function isNotNull(value) {
-  return sql`${value} is not null`;
-}
-function exists(subquery) {
-  return sql`exists ${subquery}`;
-}
-function notExists(subquery) {
-  return sql`not exists ${subquery}`;
-}
-function between(column, min, max) {
-  return sql`${column} between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
-}
-function notBetween(column, min, max) {
-  return sql`${column} not between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
-}
-function like(column, value) {
-  return sql`${column} like ${value}`;
-}
-function notLike(column, value) {
-  return sql`${column} not like ${value}`;
-}
-function ilike(column, value) {
-  return sql`${column} ilike ${value}`;
-}
-function notIlike(column, value) {
-  return sql`${column} not ilike ${value}`;
-}
-var eq = (left, right) => {
-  return sql`${left} = ${bindIfParam(right, left)}`;
-}, ne = (left, right) => {
-  return sql`${left} <> ${bindIfParam(right, left)}`;
-}, gt = (left, right) => {
-  return sql`${left} > ${bindIfParam(right, left)}`;
-}, gte = (left, right) => {
-  return sql`${left} >= ${bindIfParam(right, left)}`;
-}, lt = (left, right) => {
-  return sql`${left} < ${bindIfParam(right, left)}`;
-}, lte = (left, right) => {
-  return sql`${left} <= ${bindIfParam(right, left)}`;
-};
-var init_conditions = __esm(() => {
-  init_column();
-  init_entity();
-  init_table();
-  init_sql();
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sql/expressions/select.js
-function asc(column) {
-  return sql`${column} asc`;
-}
-function desc(column) {
-  return sql`${column} desc`;
-}
-var init_select = __esm(() => {
-  init_sql();
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sql/expressions/index.js
-var init_expressions = __esm(() => {
-  init_conditions();
-  init_select();
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/relations.js
-function getOperators() {
-  return {
-    and,
-    between,
-    eq,
-    exists,
-    gt,
-    gte,
-    ilike,
-    inArray,
-    isNull,
-    isNotNull,
-    like,
-    lt,
-    lte,
-    ne,
-    not,
-    notBetween,
-    notExists,
-    notLike,
-    notIlike,
-    notInArray,
-    or,
-    sql
-  };
-}
-function getOrderByOperators() {
-  return {
-    sql,
-    asc,
-    desc
-  };
-}
-function extractTablesRelationalConfig(schema, configHelpers) {
-  if (Object.keys(schema).length === 1 && "default" in schema && !is(schema["default"], Table)) {
-    schema = schema["default"];
-  }
-  const tableNamesMap = {};
-  const relationsBuffer = {};
-  const tablesConfig = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (is(value, Table)) {
-      const dbName = getTableUniqueName(value);
-      const bufferedRelations = relationsBuffer[dbName];
-      tableNamesMap[dbName] = key;
-      tablesConfig[key] = {
-        tsName: key,
-        dbName: value[Table.Symbol.Name],
-        schema: value[Table.Symbol.Schema],
-        columns: value[Table.Symbol.Columns],
-        relations: bufferedRelations?.relations ?? {},
-        primaryKey: bufferedRelations?.primaryKey ?? []
-      };
-      for (const column of Object.values(value[Table.Symbol.Columns])) {
-        if (column.primary) {
-          tablesConfig[key].primaryKey.push(column);
-        }
-      }
-      const extraConfig = value[Table.Symbol.ExtraConfigBuilder]?.(value[Table.Symbol.ExtraConfigColumns]);
-      if (extraConfig) {
-        for (const configEntry of Object.values(extraConfig)) {
-          if (is(configEntry, PrimaryKeyBuilder)) {
-            tablesConfig[key].primaryKey.push(...configEntry.columns);
-          }
-        }
-      }
-    } else if (is(value, Relations)) {
-      const dbName = getTableUniqueName(value.table);
-      const tableName = tableNamesMap[dbName];
-      const relations2 = value.config(configHelpers(value.table));
-      let primaryKey;
-      for (const [relationName, relation] of Object.entries(relations2)) {
-        if (tableName) {
-          const tableConfig = tablesConfig[tableName];
-          tableConfig.relations[relationName] = relation;
-          if (primaryKey) {
-            tableConfig.primaryKey.push(...primaryKey);
-          }
-        } else {
-          if (!(dbName in relationsBuffer)) {
-            relationsBuffer[dbName] = {
-              relations: {},
-              primaryKey
-            };
-          }
-          relationsBuffer[dbName].relations[relationName] = relation;
-        }
-      }
-    }
-  }
-  return { tables: tablesConfig, tableNamesMap };
-}
-function createOne(sourceTable) {
-  return function one(table, config) {
-    return new One(sourceTable, table, config, config?.fields.reduce((res, f) => res && f.notNull, true) ?? false);
-  };
-}
-function createMany(sourceTable) {
-  return function many(referencedTable, config) {
-    return new Many(sourceTable, referencedTable, config);
-  };
-}
-function normalizeRelation(schema, tableNamesMap, relation) {
-  if (is(relation, One) && relation.config) {
-    return {
-      fields: relation.config.fields,
-      references: relation.config.references
-    };
-  }
-  const referencedTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];
-  if (!referencedTableTsName) {
-    throw new Error(`Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`);
-  }
-  const referencedTableConfig = schema[referencedTableTsName];
-  if (!referencedTableConfig) {
-    throw new Error(`Table "${referencedTableTsName}" not found in schema`);
-  }
-  const sourceTable = relation.sourceTable;
-  const sourceTableTsName = tableNamesMap[getTableUniqueName(sourceTable)];
-  if (!sourceTableTsName) {
-    throw new Error(`Table "${sourceTable[Table.Symbol.Name]}" not found in schema`);
-  }
-  const reverseRelations = [];
-  for (const referencedTableRelation of Object.values(referencedTableConfig.relations)) {
-    if (relation.relationName && relation !== referencedTableRelation && referencedTableRelation.relationName === relation.relationName || !relation.relationName && referencedTableRelation.referencedTable === relation.sourceTable) {
-      reverseRelations.push(referencedTableRelation);
-    }
-  }
-  if (reverseRelations.length > 1) {
-    throw relation.relationName ? new Error(`There are multiple relations with name "${relation.relationName}" in table "${referencedTableTsName}"`) : new Error(`There are multiple relations between "${referencedTableTsName}" and "${relation.sourceTable[Table.Symbol.Name]}". Please specify relation name`);
-  }
-  if (reverseRelations[0] && is(reverseRelations[0], One) && reverseRelations[0].config) {
-    return {
-      fields: reverseRelations[0].config.references,
-      references: reverseRelations[0].config.fields
-    };
-  }
-  throw new Error(`There is not enough information to infer relation "${sourceTableTsName}.${relation.fieldName}"`);
-}
-function createTableRelationsHelpers(sourceTable) {
-  return {
-    one: createOne(sourceTable),
-    many: createMany(sourceTable)
-  };
-}
-function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelection, mapColumnValue = (value) => value) {
-  const result = {};
-  for (const [
-    selectionItemIndex,
-    selectionItem
-  ] of buildQueryResultSelection.entries()) {
-    if (selectionItem.isJson) {
-      const relation = tableConfig.relations[selectionItem.tsKey];
-      const rawSubRows = row[selectionItemIndex];
-      const subRows = typeof rawSubRows === "string" ? JSON.parse(rawSubRows) : rawSubRows;
-      result[selectionItem.tsKey] = is(relation, One) ? subRows && mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRows, selectionItem.selection, mapColumnValue) : subRows.map((subRow) => mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRow, selectionItem.selection, mapColumnValue));
-    } else {
-      const value = mapColumnValue(row[selectionItemIndex]);
-      const field = selectionItem.field;
-      let decoder;
-      if (is(field, Column)) {
-        decoder = field;
-      } else if (is(field, SQL)) {
-        decoder = field.decoder;
-      } else {
-        decoder = field.sql.decoder;
-      }
-      result[selectionItem.tsKey] = value === null ? null : decoder.mapFromDriverValue(value);
-    }
-  }
-  return result;
-}
-var Relation, Relations, One, Many;
-var init_relations = __esm(() => {
-  init_table();
-  init_column();
-  init_entity();
-  init_primary_keys();
-  init_expressions();
-  init_sql();
-  Relation = class Relation {
-    constructor(sourceTable, referencedTable, relationName) {
-      this.sourceTable = sourceTable;
-      this.referencedTable = referencedTable;
-      this.relationName = relationName;
-      this.referencedTableName = referencedTable[Table.Symbol.Name];
-    }
-    static [entityKind] = "Relation";
-    referencedTableName;
-    fieldName;
-  };
-  Relations = class Relations {
-    constructor(table, config) {
-      this.table = table;
-      this.config = config;
-    }
-    static [entityKind] = "Relations";
-  };
-  One = class One extends Relation {
-    constructor(sourceTable, referencedTable, config, isNullable) {
-      super(sourceTable, referencedTable, config?.relationName);
-      this.config = config;
-      this.isNullable = isNullable;
-    }
-    static [entityKind] = "One";
-    withFieldName(fieldName) {
-      const relation = new One(this.sourceTable, this.referencedTable, this.config, this.isNullable);
-      relation.fieldName = fieldName;
-      return relation;
-    }
-  };
-  Many = class Many extends Relation {
-    constructor(sourceTable, referencedTable, config) {
-      super(sourceTable, referencedTable, config?.relationName);
-      this.config = config;
-    }
-    static [entityKind] = "Many";
-    withFieldName(fieldName) {
-      const relation = new Many(this.sourceTable, this.referencedTable, this.config);
-      relation.fieldName = fieldName;
-      return relation;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sql/functions/aggregate.js
-var init_aggregate = () => {};
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sql/functions/vector.js
-var init_vector = () => {};
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sql/functions/index.js
-var init_functions = __esm(() => {
-  init_aggregate();
-  init_vector();
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sql/index.js
-var init_sql2 = __esm(() => {
-  init_expressions();
-  init_functions();
-  init_sql();
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/index.js
-var init_drizzle_orm = __esm(() => {
-  init_alias();
-  init_column_builder();
-  init_column();
-  init_entity();
-  init_errors();
-  init_logger();
-  init_query_promise();
-  init_relations();
-  init_sql2();
-  init_subquery();
-  init_table();
-  init_utils();
-  init_view_common();
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/selection-proxy.js
-var SelectionProxyHandler;
-var init_selection_proxy = __esm(() => {
-  init_alias();
-  init_column();
-  init_entity();
-  init_sql();
-  init_subquery();
-  init_view_common();
-  SelectionProxyHandler = class SelectionProxyHandler {
-    static [entityKind] = "SelectionProxyHandler";
-    config;
-    constructor(config) {
-      this.config = { ...config };
-    }
-    get(subquery2, prop) {
-      if (prop === "_") {
-        return {
-          ...subquery2["_"],
-          selectedFields: new Proxy(subquery2._.selectedFields, this)
-        };
-      }
-      if (prop === ViewBaseConfig) {
-        return {
-          ...subquery2[ViewBaseConfig],
-          selectedFields: new Proxy(subquery2[ViewBaseConfig].selectedFields, this)
-        };
-      }
-      if (typeof prop === "symbol") {
-        return subquery2[prop];
-      }
-      const columns = is(subquery2, Subquery) ? subquery2._.selectedFields : is(subquery2, View) ? subquery2[ViewBaseConfig].selectedFields : subquery2;
-      const value = columns[prop];
-      if (is(value, SQL.Aliased)) {
-        if (this.config.sqlAliasedBehavior === "sql" && !value.isSelectionField) {
-          return value.sql;
-        }
-        const newValue = value.clone();
-        newValue.isSelectionField = true;
-        return newValue;
-      }
-      if (is(value, SQL)) {
-        if (this.config.sqlBehavior === "sql") {
-          return value;
-        }
-        throw new Error(`You tried to reference "${prop}" 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.`);
-      }
-      if (is(value, Column)) {
-        if (this.config.alias) {
-          return new Proxy(value, new ColumnAliasProxyHandler(new Proxy(value.table, new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false))));
-        }
-        return value;
-      }
-      if (typeof value !== "object" || value === null) {
-        return value;
-      }
-      return new Proxy(value, new SelectionProxyHandler(this.config));
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
-var ForeignKeyBuilder, ForeignKey;
-var init_foreign_keys = __esm(() => {
-  init_entity();
-  init_table_utils();
-  ForeignKeyBuilder = class ForeignKeyBuilder {
-    static [entityKind] = "SQLiteForeignKeyBuilder";
-    reference;
-    _onUpdate;
-    _onDelete;
-    constructor(config, actions) {
-      this.reference = () => {
-        const { name, columns, foreignColumns } = config();
-        return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
-      };
-      if (actions) {
-        this._onUpdate = actions.onUpdate;
-        this._onDelete = actions.onDelete;
-      }
-    }
-    onUpdate(action) {
-      this._onUpdate = action;
-      return this;
-    }
-    onDelete(action) {
-      this._onDelete = action;
-      return this;
-    }
-    build(table2) {
-      return new ForeignKey(table2, this);
-    }
-  };
-  ForeignKey = class ForeignKey {
-    constructor(table2, builder) {
-      this.table = table2;
-      this.reference = builder.reference;
-      this.onUpdate = builder._onUpdate;
-      this.onDelete = builder._onDelete;
-    }
-    static [entityKind] = "SQLiteForeignKey";
-    reference;
-    onUpdate;
-    onDelete;
-    getName() {
-      const { name, columns, foreignColumns } = this.reference();
-      const columnNames = columns.map((column2) => column2.name);
-      const foreignColumnNames = foreignColumns.map((column2) => column2.name);
-      const chunks = [
-        this.table[TableName],
-        ...columnNames,
-        foreignColumns[0].table[TableName],
-        ...foreignColumnNames
-      ];
-      return name ?? `${chunks.join("_")}_fk`;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
-function uniqueKeyName2(table2, columns) {
-  return `${table2[TableName]}_${columns.join("_")}_unique`;
-}
-var init_unique_constraint2 = __esm(() => {
-  init_table_utils();
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/columns/common.js
-var SQLiteColumnBuilder, SQLiteColumn;
-var init_common2 = __esm(() => {
-  init_column_builder();
-  init_column();
-  init_entity();
-  init_foreign_keys();
-  init_unique_constraint2();
-  SQLiteColumnBuilder = class SQLiteColumnBuilder extends ColumnBuilder {
-    static [entityKind] = "SQLiteColumnBuilder";
-    foreignKeyConfigs = [];
-    references(ref, actions = {}) {
-      this.foreignKeyConfigs.push({ ref, actions });
-      return this;
-    }
-    unique(name) {
-      this.config.isUnique = true;
-      this.config.uniqueName = name;
-      return this;
-    }
-    generatedAlwaysAs(as, config) {
-      this.config.generated = {
-        as,
-        type: "always",
-        mode: config?.mode ?? "virtual"
-      };
-      return this;
-    }
-    buildForeignKeys(column2, table2) {
-      return this.foreignKeyConfigs.map(({ ref, actions }) => {
-        return ((ref2, actions2) => {
-          const builder = new ForeignKeyBuilder(() => {
-            const foreignColumn = ref2();
-            return { columns: [column2], foreignColumns: [foreignColumn] };
-          });
-          if (actions2.onUpdate) {
-            builder.onUpdate(actions2.onUpdate);
-          }
-          if (actions2.onDelete) {
-            builder.onDelete(actions2.onDelete);
-          }
-          return builder.build(table2);
-        })(ref, actions);
-      });
-    }
-  };
-  SQLiteColumn = class SQLiteColumn extends Column {
-    constructor(table2, config) {
-      if (!config.uniqueName) {
-        config.uniqueName = uniqueKeyName2(table2, [config.name]);
-      }
-      super(table2, config);
-      this.table = table2;
-    }
-    static [entityKind] = "SQLiteColumn";
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/columns/blob.js
-function blob(a, b) {
-  const { name, config } = getColumnNameAndConfig(a, b);
-  if (config?.mode === "json") {
-    return new SQLiteBlobJsonBuilder(name);
-  }
-  if (config?.mode === "bigint") {
-    return new SQLiteBigIntBuilder(name);
-  }
-  return new SQLiteBlobBufferBuilder(name);
-}
-var SQLiteBigIntBuilder, SQLiteBigInt, SQLiteBlobJsonBuilder, SQLiteBlobJson, SQLiteBlobBufferBuilder, SQLiteBlobBuffer;
-var init_blob = __esm(() => {
-  init_entity();
-  init_utils();
-  init_common2();
-  SQLiteBigIntBuilder = class SQLiteBigIntBuilder extends SQLiteColumnBuilder {
-    static [entityKind] = "SQLiteBigIntBuilder";
-    constructor(name) {
-      super(name, "bigint", "SQLiteBigInt");
-    }
-    build(table2) {
-      return new SQLiteBigInt(table2, this.config);
-    }
-  };
-  SQLiteBigInt = class SQLiteBigInt extends SQLiteColumn {
-    static [entityKind] = "SQLiteBigInt";
-    getSQLType() {
-      return "blob";
-    }
-    mapFromDriverValue(value) {
-      if (typeof Buffer !== "undefined" && Buffer.from) {
-        const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
-        return BigInt(buf.toString("utf8"));
-      }
-      return BigInt(textDecoder.decode(value));
-    }
-    mapToDriverValue(value) {
-      return Buffer.from(value.toString());
-    }
-  };
-  SQLiteBlobJsonBuilder = class SQLiteBlobJsonBuilder extends SQLiteColumnBuilder {
-    static [entityKind] = "SQLiteBlobJsonBuilder";
-    constructor(name) {
-      super(name, "json", "SQLiteBlobJson");
-    }
-    build(table2) {
-      return new SQLiteBlobJson(table2, this.config);
-    }
-  };
-  SQLiteBlobJson = class SQLiteBlobJson extends SQLiteColumn {
-    static [entityKind] = "SQLiteBlobJson";
-    getSQLType() {
-      return "blob";
-    }
-    mapFromDriverValue(value) {
-      if (typeof Buffer !== "undefined" && Buffer.from) {
-        const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
-        return JSON.parse(buf.toString("utf8"));
-      }
-      return JSON.parse(textDecoder.decode(value));
-    }
-    mapToDriverValue(value) {
-      return Buffer.from(JSON.stringify(value));
-    }
-  };
-  SQLiteBlobBufferBuilder = class SQLiteBlobBufferBuilder extends SQLiteColumnBuilder {
-    static [entityKind] = "SQLiteBlobBufferBuilder";
-    constructor(name) {
-      super(name, "buffer", "SQLiteBlobBuffer");
-    }
-    build(table2) {
-      return new SQLiteBlobBuffer(table2, this.config);
-    }
-  };
-  SQLiteBlobBuffer = class SQLiteBlobBuffer extends SQLiteColumn {
-    static [entityKind] = "SQLiteBlobBuffer";
-    mapFromDriverValue(value) {
-      if (Buffer.isBuffer(value)) {
-        return value;
-      }
-      return Buffer.from(value);
-    }
-    getSQLType() {
-      return "blob";
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/columns/custom.js
-function customType(customTypeParams) {
-  return (a, b) => {
-    const { name, config } = getColumnNameAndConfig(a, b);
-    return new SQLiteCustomColumnBuilder(name, config, customTypeParams);
-  };
-}
-var SQLiteCustomColumnBuilder, SQLiteCustomColumn;
-var init_custom = __esm(() => {
-  init_entity();
-  init_utils();
-  init_common2();
-  SQLiteCustomColumnBuilder = class SQLiteCustomColumnBuilder extends SQLiteColumnBuilder {
-    static [entityKind] = "SQLiteCustomColumnBuilder";
-    constructor(name, fieldConfig, customTypeParams) {
-      super(name, "custom", "SQLiteCustomColumn");
-      this.config.fieldConfig = fieldConfig;
-      this.config.customTypeParams = customTypeParams;
-    }
-    build(table2) {
-      return new SQLiteCustomColumn(table2, this.config);
-    }
-  };
-  SQLiteCustomColumn = class SQLiteCustomColumn extends SQLiteColumn {
-    static [entityKind] = "SQLiteCustomColumn";
-    sqlName;
-    mapTo;
-    mapFrom;
-    constructor(table2, config) {
-      super(table2, config);
-      this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
-      this.mapTo = config.customTypeParams.toDriver;
-      this.mapFrom = config.customTypeParams.fromDriver;
-    }
-    getSQLType() {
-      return this.sqlName;
-    }
-    mapFromDriverValue(value) {
-      return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
-    }
-    mapToDriverValue(value) {
-      return typeof this.mapTo === "function" ? this.mapTo(value) : value;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/columns/integer.js
-function integer(a, b) {
-  const { name, config } = getColumnNameAndConfig(a, b);
-  if (config?.mode === "timestamp" || config?.mode === "timestamp_ms") {
-    return new SQLiteTimestampBuilder(name, config.mode);
-  }
-  if (config?.mode === "boolean") {
-    return new SQLiteBooleanBuilder(name, config.mode);
-  }
-  return new SQLiteIntegerBuilder(name);
-}
-var SQLiteBaseIntegerBuilder, SQLiteBaseInteger, SQLiteIntegerBuilder, SQLiteInteger, SQLiteTimestampBuilder, SQLiteTimestamp, SQLiteBooleanBuilder, SQLiteBoolean;
-var init_integer = __esm(() => {
-  init_entity();
-  init_sql();
-  init_utils();
-  init_common2();
-  SQLiteBaseIntegerBuilder = class SQLiteBaseIntegerBuilder extends SQLiteColumnBuilder {
-    static [entityKind] = "SQLiteBaseIntegerBuilder";
-    constructor(name, dataType, columnType) {
-      super(name, dataType, columnType);
-      this.config.autoIncrement = false;
-    }
-    primaryKey(config) {
-      if (config?.autoIncrement) {
-        this.config.autoIncrement = true;
-      }
-      this.config.hasDefault = true;
-      return super.primaryKey();
-    }
-  };
-  SQLiteBaseInteger = class SQLiteBaseInteger extends SQLiteColumn {
-    static [entityKind] = "SQLiteBaseInteger";
-    autoIncrement = this.config.autoIncrement;
-    getSQLType() {
-      return "integer";
-    }
-  };
-  SQLiteIntegerBuilder = class SQLiteIntegerBuilder extends SQLiteBaseIntegerBuilder {
-    static [entityKind] = "SQLiteIntegerBuilder";
-    constructor(name) {
-      super(name, "number", "SQLiteInteger");
-    }
-    build(table2) {
-      return new SQLiteInteger(table2, this.config);
-    }
-  };
-  SQLiteInteger = class SQLiteInteger extends SQLiteBaseInteger {
-    static [entityKind] = "SQLiteInteger";
-  };
-  SQLiteTimestampBuilder = class SQLiteTimestampBuilder extends SQLiteBaseIntegerBuilder {
-    static [entityKind] = "SQLiteTimestampBuilder";
-    constructor(name, mode) {
-      super(name, "date", "SQLiteTimestamp");
-      this.config.mode = mode;
-    }
-    defaultNow() {
-      return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
-    }
-    build(table2) {
-      return new SQLiteTimestamp(table2, this.config);
-    }
-  };
-  SQLiteTimestamp = class SQLiteTimestamp extends SQLiteBaseInteger {
-    static [entityKind] = "SQLiteTimestamp";
-    mode = this.config.mode;
-    mapFromDriverValue(value) {
-      if (this.config.mode === "timestamp") {
-        return new Date(value * 1000);
-      }
-      return new Date(value);
-    }
-    mapToDriverValue(value) {
-      const unix = value.getTime();
-      if (this.config.mode === "timestamp") {
-        return Math.floor(unix / 1000);
-      }
-      return unix;
-    }
-  };
-  SQLiteBooleanBuilder = class SQLiteBooleanBuilder extends SQLiteBaseIntegerBuilder {
-    static [entityKind] = "SQLiteBooleanBuilder";
-    constructor(name, mode) {
-      super(name, "boolean", "SQLiteBoolean");
-      this.config.mode = mode;
-    }
-    build(table2) {
-      return new SQLiteBoolean(table2, this.config);
-    }
-  };
-  SQLiteBoolean = class SQLiteBoolean extends SQLiteBaseInteger {
-    static [entityKind] = "SQLiteBoolean";
-    mode = this.config.mode;
-    mapFromDriverValue(value) {
-      return Number(value) === 1;
-    }
-    mapToDriverValue(value) {
-      return value ? 1 : 0;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
-function numeric(a, b) {
-  const { name, config } = getColumnNameAndConfig(a, b);
-  const mode = config?.mode;
-  return mode === "number" ? new SQLiteNumericNumberBuilder(name) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);
-}
-var SQLiteNumericBuilder, SQLiteNumeric, SQLiteNumericNumberBuilder, SQLiteNumericNumber, SQLiteNumericBigIntBuilder, SQLiteNumericBigInt;
-var init_numeric = __esm(() => {
-  init_entity();
-  init_utils();
-  init_common2();
-  SQLiteNumericBuilder = class SQLiteNumericBuilder extends SQLiteColumnBuilder {
-    static [entityKind] = "SQLiteNumericBuilder";
-    constructor(name) {
-      super(name, "string", "SQLiteNumeric");
-    }
-    build(table2) {
-      return new SQLiteNumeric(table2, this.config);
-    }
-  };
-  SQLiteNumeric = class SQLiteNumeric extends SQLiteColumn {
-    static [entityKind] = "SQLiteNumeric";
-    mapFromDriverValue(value) {
-      if (typeof value === "string")
-        return value;
-      return String(value);
-    }
-    getSQLType() {
-      return "numeric";
-    }
-  };
-  SQLiteNumericNumberBuilder = class SQLiteNumericNumberBuilder extends SQLiteColumnBuilder {
-    static [entityKind] = "SQLiteNumericNumberBuilder";
-    constructor(name) {
-      super(name, "number", "SQLiteNumericNumber");
-    }
-    build(table2) {
-      return new SQLiteNumericNumber(table2, this.config);
-    }
-  };
-  SQLiteNumericNumber = class SQLiteNumericNumber extends SQLiteColumn {
-    static [entityKind] = "SQLiteNumericNumber";
-    mapFromDriverValue(value) {
-      if (typeof value === "number")
-        return value;
-      return Number(value);
-    }
-    mapToDriverValue = String;
-    getSQLType() {
-      return "numeric";
-    }
-  };
-  SQLiteNumericBigIntBuilder = class SQLiteNumericBigIntBuilder extends SQLiteColumnBuilder {
-    static [entityKind] = "SQLiteNumericBigIntBuilder";
-    constructor(name) {
-      super(name, "bigint", "SQLiteNumericBigInt");
-    }
-    build(table2) {
-      return new SQLiteNumericBigInt(table2, this.config);
-    }
-  };
-  SQLiteNumericBigInt = class SQLiteNumericBigInt extends SQLiteColumn {
-    static [entityKind] = "SQLiteNumericBigInt";
-    mapFromDriverValue = BigInt;
-    mapToDriverValue = String;
-    getSQLType() {
-      return "numeric";
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/columns/real.js
-function real(name) {
-  return new SQLiteRealBuilder(name ?? "");
-}
-var SQLiteRealBuilder, SQLiteReal;
-var init_real = __esm(() => {
-  init_entity();
-  init_common2();
-  SQLiteRealBuilder = class SQLiteRealBuilder extends SQLiteColumnBuilder {
-    static [entityKind] = "SQLiteRealBuilder";
-    constructor(name) {
-      super(name, "number", "SQLiteReal");
-    }
-    build(table2) {
-      return new SQLiteReal(table2, this.config);
-    }
-  };
-  SQLiteReal = class SQLiteReal extends SQLiteColumn {
-    static [entityKind] = "SQLiteReal";
-    getSQLType() {
-      return "real";
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/columns/text.js
-function text(a, b = {}) {
-  const { name, config } = getColumnNameAndConfig(a, b);
-  if (config.mode === "json") {
-    return new SQLiteTextJsonBuilder(name);
-  }
-  return new SQLiteTextBuilder(name, config);
-}
-var SQLiteTextBuilder, SQLiteText, SQLiteTextJsonBuilder, SQLiteTextJson;
-var init_text = __esm(() => {
-  init_entity();
-  init_utils();
-  init_common2();
-  SQLiteTextBuilder = class SQLiteTextBuilder extends SQLiteColumnBuilder {
-    static [entityKind] = "SQLiteTextBuilder";
-    constructor(name, config) {
-      super(name, "string", "SQLiteText");
-      this.config.enumValues = config.enum;
-      this.config.length = config.length;
-    }
-    build(table2) {
-      return new SQLiteText(table2, this.config);
-    }
-  };
-  SQLiteText = class SQLiteText extends SQLiteColumn {
-    static [entityKind] = "SQLiteText";
-    enumValues = this.config.enumValues;
-    length = this.config.length;
-    constructor(table2, config) {
-      super(table2, config);
-    }
-    getSQLType() {
-      return `text${this.config.length ? `(${this.config.length})` : ""}`;
-    }
-  };
-  SQLiteTextJsonBuilder = class SQLiteTextJsonBuilder extends SQLiteColumnBuilder {
-    static [entityKind] = "SQLiteTextJsonBuilder";
-    constructor(name) {
-      super(name, "json", "SQLiteTextJson");
-    }
-    build(table2) {
-      return new SQLiteTextJson(table2, this.config);
-    }
-  };
-  SQLiteTextJson = class SQLiteTextJson extends SQLiteColumn {
-    static [entityKind] = "SQLiteTextJson";
-    getSQLType() {
-      return "text";
-    }
-    mapFromDriverValue(value) {
-      return JSON.parse(value);
-    }
-    mapToDriverValue(value) {
-      return JSON.stringify(value);
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/columns/all.js
-function getSQLiteColumnBuilders() {
-  return {
-    blob,
-    customType,
-    integer,
-    numeric,
-    real,
-    text
-  };
-}
-var init_all = __esm(() => {
-  init_blob();
-  init_custom();
-  init_integer();
-  init_numeric();
-  init_real();
-  init_text();
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/table.js
-function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
-  const rawTable = new SQLiteTable(name, schema, baseName);
-  const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
-  const builtColumns = Object.fromEntries(Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
-    const colBuilder = colBuilderBase;
-    colBuilder.setName(name2);
-    const column2 = colBuilder.build(rawTable);
-    rawTable[InlineForeignKeys2].push(...colBuilder.buildForeignKeys(column2, rawTable));
-    return [name2, column2];
-  }));
-  const table2 = Object.assign(rawTable, builtColumns);
-  table2[Table.Symbol.Columns] = builtColumns;
-  table2[Table.Symbol.ExtraConfigColumns] = builtColumns;
-  if (extraConfig) {
-    table2[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
-  }
-  return table2;
-}
-var InlineForeignKeys2, SQLiteTable, sqliteTable = (name, columns, extraConfig) => {
-  return sqliteTableBase(name, columns, extraConfig);
-};
-var init_table3 = __esm(() => {
-  init_entity();
-  init_table();
-  init_all();
-  InlineForeignKeys2 = Symbol.for("drizzle:SQLiteInlineForeignKeys");
-  SQLiteTable = class SQLiteTable extends Table {
-    static [entityKind] = "SQLiteTable";
-    static Symbol = Object.assign({}, Table.Symbol, {
-      InlineForeignKeys: InlineForeignKeys2
-    });
-    [Table.Symbol.Columns];
-    [InlineForeignKeys2] = [];
-    [Table.Symbol.ExtraConfigBuilder] = undefined;
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/checks.js
-var init_checks = () => {};
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/indexes.js
-function index(name) {
-  return new IndexBuilderOn(name, false);
-}
-function uniqueIndex(name) {
-  return new IndexBuilderOn(name, true);
-}
-var IndexBuilderOn, IndexBuilder, Index;
-var init_indexes = __esm(() => {
-  init_entity();
-  IndexBuilderOn = class IndexBuilderOn {
-    constructor(name, unique) {
-      this.name = name;
-      this.unique = unique;
-    }
-    static [entityKind] = "SQLiteIndexBuilderOn";
-    on(...columns) {
-      return new IndexBuilder(this.name, columns, this.unique);
-    }
-  };
-  IndexBuilder = class IndexBuilder {
-    static [entityKind] = "SQLiteIndexBuilder";
-    config;
-    constructor(name, columns, unique) {
-      this.config = {
-        name,
-        columns,
-        unique,
-        where: undefined
-      };
-    }
-    where(condition) {
-      this.config.where = condition;
-      return this;
-    }
-    build(table2) {
-      return new Index(this.config, table2);
-    }
-  };
-  Index = class Index {
-    static [entityKind] = "SQLiteIndex";
-    config;
-    constructor(config, table2) {
-      this.config = { ...config, table: table2 };
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/primary-keys.js
-var init_primary_keys2 = () => {};
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/utils.js
-function extractUsedTable(table2) {
-  if (is(table2, SQLiteTable)) {
-    return [`${table2[Table.Symbol.BaseName]}`];
-  }
-  if (is(table2, Subquery)) {
-    return table2._.usedTables ?? [];
-  }
-  if (is(table2, SQL)) {
-    return table2.usedTables ?? [];
-  }
-  return [];
-}
-var init_utils2 = __esm(() => {
-  init_entity();
-  init_sql();
-  init_subquery();
-  init_table();
-  init_table3();
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/query-builders/delete.js
-var SQLiteDeleteBase;
-var init_delete = __esm(() => {
-  init_entity();
-  init_query_promise();
-  init_selection_proxy();
-  init_table3();
-  init_table();
-  init_utils();
-  init_utils2();
-  SQLiteDeleteBase = class SQLiteDeleteBase extends QueryPromise {
-    constructor(table2, session, dialect, withList) {
-      super();
-      this.table = table2;
-      this.session = session;
-      this.dialect = dialect;
-      this.config = { table: table2, withList };
-    }
-    static [entityKind] = "SQLiteDelete";
-    config;
-    where(where) {
-      this.config.where = where;
-      return this;
-    }
-    orderBy(...columns) {
-      if (typeof columns[0] === "function") {
-        const orderBy = columns[0](new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
-        const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
-        this.config.orderBy = orderByArray;
-      } else {
-        const orderByArray = columns;
-        this.config.orderBy = orderByArray;
-      }
-      return this;
-    }
-    limit(limit) {
-      this.config.limit = limit;
-      return this;
-    }
-    returning(fields = this.table[SQLiteTable.Symbol.Columns]) {
-      this.config.returning = orderSelectedFields(fields);
-      return this;
-    }
-    getSQL() {
-      return this.dialect.buildDeleteQuery(this.config);
-    }
-    toSQL() {
-      const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-      return rest;
-    }
-    _prepare(isOneTimeQuery = true) {
-      return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", true, undefined, {
-        type: "delete",
-        tables: extractUsedTable(this.config.table)
-      });
-    }
-    prepare() {
-      return this._prepare(false);
-    }
-    run = (placeholderValues) => {
-      return this._prepare().run(placeholderValues);
-    };
-    all = (placeholderValues) => {
-      return this._prepare().all(placeholderValues);
-    };
-    get = (placeholderValues) => {
-      return this._prepare().get(placeholderValues);
-    };
-    values = (placeholderValues) => {
-      return this._prepare().values(placeholderValues);
-    };
-    async execute(placeholderValues) {
-      return this._prepare().execute(placeholderValues);
-    }
-    $dynamic() {
-      return this;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/casing.js
-function toSnakeCase(input) {
-  const words = input.replace(/['\u2019]/g, "").match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? [];
-  return words.map((word) => word.toLowerCase()).join("_");
-}
-function toCamelCase(input) {
-  const words = input.replace(/['\u2019]/g, "").match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? [];
-  return words.reduce((acc, word, i) => {
-    const formattedWord = i === 0 ? word.toLowerCase() : `${word[0].toUpperCase()}${word.slice(1)}`;
-    return acc + formattedWord;
-  }, "");
-}
-function noopCase(input) {
-  return input;
-}
-var CasingCache;
-var init_casing = __esm(() => {
-  init_entity();
-  init_table();
-  CasingCache = class CasingCache {
-    static [entityKind] = "CasingCache";
-    cache = {};
-    cachedTables = {};
-    convert;
-    constructor(casing) {
-      this.convert = casing === "snake_case" ? toSnakeCase : casing === "camelCase" ? toCamelCase : noopCase;
-    }
-    getColumnCasing(column2) {
-      if (!column2.keyAsName)
-        return column2.name;
-      const schema = column2.table[Table.Symbol.Schema] ?? "public";
-      const tableName = column2.table[Table.Symbol.OriginalName];
-      const key = `${schema}.${tableName}.${column2.name}`;
-      if (!this.cache[key]) {
-        this.cacheTable(column2.table);
-      }
-      return this.cache[key];
-    }
-    cacheTable(table2) {
-      const schema = table2[Table.Symbol.Schema] ?? "public";
-      const tableName = table2[Table.Symbol.OriginalName];
-      const tableKey = `${schema}.${tableName}`;
-      if (!this.cachedTables[tableKey]) {
-        for (const column2 of Object.values(table2[Table.Symbol.Columns])) {
-          const columnKey = `${tableKey}.${column2.name}`;
-          this.cache[columnKey] = this.convert(column2.name);
-        }
-        this.cachedTables[tableKey] = true;
-      }
-    }
-    clearCache() {
-      this.cache = {};
-      this.cachedTables = {};
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/columns/index.js
-var init_columns = __esm(() => {
-  init_blob();
-  init_common2();
-  init_custom();
-  init_integer();
-  init_numeric();
-  init_real();
-  init_text();
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/view-base.js
-var SQLiteViewBase;
-var init_view_base = __esm(() => {
-  init_entity();
-  init_sql();
-  SQLiteViewBase = class SQLiteViewBase extends View {
-    static [entityKind] = "SQLiteViewBase";
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/dialect.js
-var SQLiteDialect, SQLiteSyncDialect;
-var init_dialect = __esm(() => {
-  init_alias();
-  init_casing();
-  init_column();
-  init_entity();
-  init_errors();
-  init_relations();
-  init_sql2();
-  init_sql();
-  init_columns();
-  init_table3();
-  init_subquery();
-  init_table();
-  init_utils();
-  init_view_common();
-  init_view_base();
-  SQLiteDialect = class SQLiteDialect {
-    static [entityKind] = "SQLiteDialect";
-    casing;
-    constructor(config) {
-      this.casing = new CasingCache(config?.casing);
-    }
-    escapeName(name) {
-      return `"${name}"`;
-    }
-    escapeParam(_num) {
-      return "?";
-    }
-    escapeString(str) {
-      return `'${str.replace(/'/g, "''")}'`;
-    }
-    buildWithCTE(queries) {
-      if (!queries?.length)
-        return;
-      const withSqlChunks = [sql`with `];
-      for (const [i, w] of queries.entries()) {
-        withSqlChunks.push(sql`${sql.identifier(w._.alias)} as (${w._.sql})`);
-        if (i < queries.length - 1) {
-          withSqlChunks.push(sql`, `);
-        }
-      }
-      withSqlChunks.push(sql` `);
-      return sql.join(withSqlChunks);
-    }
-    buildDeleteQuery({ table: table2, where, returning, withList, limit, orderBy }) {
-      const withSql = this.buildWithCTE(withList);
-      const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : undefined;
-      const whereSql = where ? sql` where ${where}` : undefined;
-      const orderBySql = this.buildOrderBy(orderBy);
-      const limitSql = this.buildLimit(limit);
-      return sql`${withSql}delete from ${table2}${whereSql}${returningSql}${orderBySql}${limitSql}`;
-    }
-    buildUpdateSet(table2, set) {
-      const tableColumns = table2[Table.Symbol.Columns];
-      const columnNames = Object.keys(tableColumns).filter((colName) => set[colName] !== undefined || tableColumns[colName]?.onUpdateFn !== undefined);
-      const setSize = columnNames.length;
-      return sql.join(columnNames.flatMap((colName, i) => {
-        const col = tableColumns[colName];
-        const value = set[colName] ?? sql.param(col.onUpdateFn(), col);
-        const res = sql`${sql.identifier(this.casing.getColumnCasing(col))} = ${value}`;
-        if (i < setSize - 1) {
-          return [res, sql.raw(", ")];
-        }
-        return [res];
-      }));
-    }
-    buildUpdateQuery({ table: table2, set, where, returning, withList, joins, from, limit, orderBy }) {
-      const withSql = this.buildWithCTE(withList);
-      const setSql = this.buildUpdateSet(table2, set);
-      const fromSql = from && sql.join([sql.raw(" from "), this.buildFromTable(from)]);
-      const joinsSql = this.buildJoins(joins);
-      const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : undefined;
-      const whereSql = where ? sql` where ${where}` : undefined;
-      const orderBySql = this.buildOrderBy(orderBy);
-      const limitSql = this.buildLimit(limit);
-      return sql`${withSql}update ${table2} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}${orderBySql}${limitSql}`;
-    }
-    buildSelection(fields, { isSingleTable = false } = {}) {
-      const columnsLen = fields.length;
-      const chunks = fields.flatMap(({ field }, i) => {
-        const chunk = [];
-        if (is(field, SQL.Aliased) && field.isSelectionField) {
-          chunk.push(sql.identifier(field.fieldAlias));
-        } else if (is(field, SQL.Aliased) || is(field, SQL)) {
-          const query = is(field, SQL.Aliased) ? field.sql : field;
-          if (isSingleTable) {
-            chunk.push(new SQL(query.queryChunks.map((c) => {
-              if (is(c, Column)) {
-                return sql.identifier(this.casing.getColumnCasing(c));
-              }
-              return c;
-            })));
-          } else {
-            chunk.push(query);
-          }
-          if (is(field, SQL.Aliased)) {
-            chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
-          }
-        } else if (is(field, Column)) {
-          const tableName = field.table[Table.Symbol.Name];
-          if (field.columnType === "SQLiteNumericBigInt") {
-            if (isSingleTable) {
-              chunk.push(sql`cast(${sql.identifier(this.casing.getColumnCasing(field))} as text)`);
-            } else {
-              chunk.push(sql`cast(${sql.identifier(tableName)}.${sql.identifier(this.casing.getColumnCasing(field))} as text)`);
-            }
-          } else {
-            if (isSingleTable) {
-              chunk.push(sql.identifier(this.casing.getColumnCasing(field)));
-            } else {
-              chunk.push(sql`${sql.identifier(tableName)}.${sql.identifier(this.casing.getColumnCasing(field))}`);
-            }
-          }
-        }
-        if (i < columnsLen - 1) {
-          chunk.push(sql`, `);
-        }
-        return chunk;
-      });
-      return sql.join(chunks);
-    }
-    buildJoins(joins) {
-      if (!joins || joins.length === 0) {
-        return;
-      }
-      const joinsArray = [];
-      if (joins) {
-        for (const [index2, joinMeta] of joins.entries()) {
-          if (index2 === 0) {
-            joinsArray.push(sql` `);
-          }
-          const table2 = joinMeta.table;
-          const onSql = joinMeta.on ? sql` on ${joinMeta.on}` : undefined;
-          if (is(table2, SQLiteTable)) {
-            const tableName = table2[SQLiteTable.Symbol.Name];
-            const tableSchema = table2[SQLiteTable.Symbol.Schema];
-            const origTableName = table2[SQLiteTable.Symbol.OriginalName];
-            const alias3 = tableName === origTableName ? undefined : joinMeta.alias;
-            joinsArray.push(sql`${sql.raw(joinMeta.joinType)} join ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : undefined}${sql.identifier(origTableName)}${alias3 && sql` ${sql.identifier(alias3)}`}${onSql}`);
-          } else {
-            joinsArray.push(sql`${sql.raw(joinMeta.joinType)} join ${table2}${onSql}`);
-          }
-          if (index2 < joins.length - 1) {
-            joinsArray.push(sql` `);
-          }
-        }
-      }
-      return sql.join(joinsArray);
-    }
-    buildLimit(limit) {
-      return typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : undefined;
-    }
-    buildOrderBy(orderBy) {
-      const orderByList = [];
-      if (orderBy) {
-        for (const [index2, orderByValue] of orderBy.entries()) {
-          orderByList.push(orderByValue);
-          if (index2 < orderBy.length - 1) {
-            orderByList.push(sql`, `);
-          }
-        }
-      }
-      return orderByList.length > 0 ? sql` order by ${sql.join(orderByList)}` : undefined;
-    }
-    buildFromTable(table2) {
-      if (is(table2, Table) && table2[Table.Symbol.IsAlias]) {
-        return sql`${sql`${sql.identifier(table2[Table.Symbol.Schema] ?? "")}.`.if(table2[Table.Symbol.Schema])}${sql.identifier(table2[Table.Symbol.OriginalName])} ${sql.identifier(table2[Table.Symbol.Name])}`;
-      }
-      return table2;
-    }
-    buildSelectQuery({
-      withList,
-      fields,
-      fieldsFlat,
-      where,
-      having,
-      table: table2,
-      joins,
-      orderBy,
-      groupBy,
-      limit,
-      offset,
-      distinct,
-      setOperators
-    }) {
-      const fieldsList = fieldsFlat ?? orderSelectedFields(fields);
-      for (const f of fieldsList) {
-        if (is(f.field, Column) && getTableName(f.field.table) !== (is(table2, Subquery) ? table2._.alias : is(table2, SQLiteViewBase) ? table2[ViewBaseConfig].name : is(table2, SQL) ? undefined : getTableName(table2)) && !((table22) => joins?.some(({ alias: alias3 }) => alias3 === (table22[Table.Symbol.IsAlias] ? getTableName(table22) : table22[Table.Symbol.BaseName])))(f.field.table)) {
-          const tableName = getTableName(f.field.table);
-          throw new Error(`Your "${f.path.join("->")}" field references a column "${tableName}"."${f.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`);
-        }
-      }
-      const isSingleTable = !joins || joins.length === 0;
-      const withSql = this.buildWithCTE(withList);
-      const distinctSql = distinct ? sql` distinct` : undefined;
-      const selection = this.buildSelection(fieldsList, { isSingleTable });
-      const tableSql = this.buildFromTable(table2);
-      const joinsSql = this.buildJoins(joins);
-      const whereSql = where ? sql` where ${where}` : undefined;
-      const havingSql = having ? sql` having ${having}` : undefined;
-      const groupByList = [];
-      if (groupBy) {
-        for (const [index2, groupByValue] of groupBy.entries()) {
-          groupByList.push(groupByValue);
-          if (index2 < groupBy.length - 1) {
-            groupByList.push(sql`, `);
-          }
-        }
-      }
-      const groupBySql = groupByList.length > 0 ? sql` group by ${sql.join(groupByList)}` : undefined;
-      const orderBySql = this.buildOrderBy(orderBy);
-      const limitSql = this.buildLimit(limit);
-      const offsetSql = offset ? sql` offset ${offset}` : undefined;
-      const finalQuery = sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}`;
-      if (setOperators.length > 0) {
-        return this.buildSetOperations(finalQuery, setOperators);
-      }
-      return finalQuery;
-    }
-    buildSetOperations(leftSelect, setOperators) {
-      const [setOperator, ...rest] = setOperators;
-      if (!setOperator) {
-        throw new Error("Cannot pass undefined values to any set operator");
-      }
-      if (rest.length === 0) {
-        return this.buildSetOperationQuery({ leftSelect, setOperator });
-      }
-      return this.buildSetOperations(this.buildSetOperationQuery({ leftSelect, setOperator }), rest);
-    }
-    buildSetOperationQuery({
-      leftSelect,
-      setOperator: { type, isAll, rightSelect, limit, orderBy, offset }
-    }) {
-      const leftChunk = sql`${leftSelect.getSQL()} `;
-      const rightChunk = sql`${rightSelect.getSQL()}`;
-      let orderBySql;
-      if (orderBy && orderBy.length > 0) {
-        const orderByValues = [];
-        for (const singleOrderBy of orderBy) {
-          if (is(singleOrderBy, SQLiteColumn)) {
-            orderByValues.push(sql.identifier(singleOrderBy.name));
-          } else if (is(singleOrderBy, SQL)) {
-            for (let i = 0;i < singleOrderBy.queryChunks.length; i++) {
-              const chunk = singleOrderBy.queryChunks[i];
-              if (is(chunk, SQLiteColumn)) {
-                singleOrderBy.queryChunks[i] = sql.identifier(this.casing.getColumnCasing(chunk));
-              }
-            }
-            orderByValues.push(sql`${singleOrderBy}`);
-          } else {
-            orderByValues.push(sql`${singleOrderBy}`);
-          }
-        }
-        orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)}`;
-      }
-      const limitSql = typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : undefined;
-      const operatorChunk = sql.raw(`${type} ${isAll ? "all " : ""}`);
-      const offsetSql = offset ? sql` offset ${offset}` : undefined;
-      return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
-    }
-    buildInsertQuery({ table: table2, values: valuesOrSelect, onConflict, returning, withList, select: select2 }) {
-      const valuesSqlList = [];
-      const columns = table2[Table.Symbol.Columns];
-      const colEntries = Object.entries(columns).filter(([_, col]) => !col.shouldDisableInsert());
-      const insertOrder = colEntries.map(([, column2]) => sql.identifier(this.casing.getColumnCasing(column2)));
-      if (select2) {
-        const select22 = valuesOrSelect;
-        if (is(select22, SQL)) {
-          valuesSqlList.push(select22);
-        } else {
-          valuesSqlList.push(select22.getSQL());
-        }
-      } else {
-        const values = valuesOrSelect;
-        valuesSqlList.push(sql.raw("values "));
-        for (const [valueIndex, value] of values.entries()) {
-          const valueList = [];
-          for (const [fieldName, col] of colEntries) {
-            const colValue = value[fieldName];
-            if (colValue === undefined || is(colValue, Param) && colValue.value === undefined) {
-              let defaultValue;
-              if (col.default !== null && col.default !== undefined) {
-                defaultValue = is(col.default, SQL) ? col.default : sql.param(col.default, col);
-              } else if (col.defaultFn !== undefined) {
-                const defaultFnResult = col.defaultFn();
-                defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
-              } else if (!col.default && col.onUpdateFn !== undefined) {
-                const onUpdateFnResult = col.onUpdateFn();
-                defaultValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
-              } else {
-                defaultValue = sql`null`;
-              }
-              valueList.push(defaultValue);
-            } else {
-              valueList.push(colValue);
-            }
-          }
-          valuesSqlList.push(valueList);
-          if (valueIndex < values.length - 1) {
-            valuesSqlList.push(sql`, `);
-          }
-        }
-      }
-      const withSql = this.buildWithCTE(withList);
-      const valuesSql = sql.join(valuesSqlList);
-      const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : undefined;
-      const onConflictSql = onConflict?.length ? sql.join(onConflict) : undefined;
-      return sql`${withSql}insert into ${table2} ${insertOrder} ${valuesSql}${onConflictSql}${returningSql}`;
-    }
-    sqlToQuery(sql22, invokeSource) {
-      return sql22.toQuery({
-        casing: this.casing,
-        escapeName: this.escapeName,
-        escapeParam: this.escapeParam,
-        escapeString: this.escapeString,
-        invokeSource
-      });
-    }
-    buildRelationalQuery({
-      fullSchema,
-      schema,
-      tableNamesMap,
-      table: table2,
-      tableConfig,
-      queryConfig: config,
-      tableAlias,
-      nestedQueryRelation,
-      joinOn
-    }) {
-      let selection = [];
-      let limit, offset, orderBy = [], where;
-      const joins = [];
-      if (config === true) {
-        const selectionEntries = Object.entries(tableConfig.columns);
-        selection = selectionEntries.map(([key, value]) => ({
-          dbKey: value.name,
-          tsKey: key,
-          field: aliasedTableColumn(value, tableAlias),
-          relationTableTsKey: undefined,
-          isJson: false,
-          selection: []
-        }));
-      } else {
-        const aliasedColumns = Object.fromEntries(Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]));
-        if (config.where) {
-          const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, getOperators()) : config.where;
-          where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
-        }
-        const fieldsSelection = [];
-        let selectedColumns = [];
-        if (config.columns) {
-          let isIncludeMode = false;
-          for (const [field, value] of Object.entries(config.columns)) {
-            if (value === undefined) {
-              continue;
-            }
-            if (field in tableConfig.columns) {
-              if (!isIncludeMode && value === true) {
-                isIncludeMode = true;
-              }
-              selectedColumns.push(field);
-            }
-          }
-          if (selectedColumns.length > 0) {
-            selectedColumns = isIncludeMode ? selectedColumns.filter((c) => config.columns?.[c] === true) : Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
-          }
-        } else {
-          selectedColumns = Object.keys(tableConfig.columns);
-        }
-        for (const field of selectedColumns) {
-          const column2 = tableConfig.columns[field];
-          fieldsSelection.push({ tsKey: field, value: column2 });
-        }
-        let selectedRelations = [];
-        if (config.with) {
-          selectedRelations = Object.entries(config.with).filter((entry) => !!entry[1]).map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey] }));
-        }
-        let extras;
-        if (config.extras) {
-          extras = typeof config.extras === "function" ? config.extras(aliasedColumns, { sql }) : config.extras;
-          for (const [tsKey, value] of Object.entries(extras)) {
-            fieldsSelection.push({
-              tsKey,
-              value: mapColumnsInAliasedSQLToAlias(value, tableAlias)
-            });
-          }
-        }
-        for (const { tsKey, value } of fieldsSelection) {
-          selection.push({
-            dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey].name,
-            tsKey,
-            field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
-            relationTableTsKey: undefined,
-            isJson: false,
-            selection: []
-          });
-        }
-        let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, getOrderByOperators()) : config.orderBy ?? [];
-        if (!Array.isArray(orderByOrig)) {
-          orderByOrig = [orderByOrig];
-        }
-        orderBy = orderByOrig.map((orderByValue) => {
-          if (is(orderByValue, Column)) {
-            return aliasedTableColumn(orderByValue, tableAlias);
-          }
-          return mapColumnsInSQLToAlias(orderByValue, tableAlias);
-        });
-        limit = config.limit;
-        offset = config.offset;
-        for (const {
-          tsKey: selectedRelationTsKey,
-          queryConfig: selectedRelationConfigValue,
-          relation
-        } of selectedRelations) {
-          const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
-          const relationTableName = getTableUniqueName(relation.referencedTable);
-          const relationTableTsName = tableNamesMap[relationTableName];
-          const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
-          const joinOn2 = and(...normalizedRelation.fields.map((field2, i) => eq(aliasedTableColumn(normalizedRelation.references[i], relationTableAlias), aliasedTableColumn(field2, tableAlias))));
-          const builtRelation = this.buildRelationalQuery({
-            fullSchema,
-            schema,
-            tableNamesMap,
-            table: fullSchema[relationTableTsName],
-            tableConfig: schema[relationTableTsName],
-            queryConfig: is(relation, One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,
-            tableAlias: relationTableAlias,
-            joinOn: joinOn2,
-            nestedQueryRelation: relation
-          });
-          const field = sql`(${builtRelation.sql})`.as(selectedRelationTsKey);
-          selection.push({
-            dbKey: selectedRelationTsKey,
-            tsKey: selectedRelationTsKey,
-            field,
-            relationTableTsKey: relationTableTsName,
-            isJson: true,
-            selection: builtRelation.selection
-          });
-        }
-      }
-      if (selection.length === 0) {
-        throw new DrizzleError({
-          message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}"). 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 result;
-      where = and(joinOn, where);
-      if (nestedQueryRelation) {
-        let field = sql`json_array(${sql.join(selection.map(({ field: field2 }) => is(field2, SQLiteColumn) ? sql.identifier(this.casing.getColumnCasing(field2)) : is(field2, SQL.Aliased) ? field2.sql : field2), sql`, `)})`;
-        if (is(nestedQueryRelation, Many)) {
-          field = sql`coalesce(json_group_array(${field}), json_array())`;
-        }
-        const nestedSelection = [{
-          dbKey: "data",
-          tsKey: "data",
-          field: field.as("data"),
-          isJson: true,
-          relationTableTsKey: tableConfig.tsName,
-          selection
-        }];
-        const needsSubquery = limit !== undefined || offset !== undefined || orderBy.length > 0;
-        if (needsSubquery) {
-          result = this.buildSelectQuery({
-            table: aliasedTable(table2, tableAlias),
-            fields: {},
-            fieldsFlat: [
-              {
-                path: [],
-                field: sql.raw("*")
-              }
-            ],
-            where,
-            limit,
-            offset,
-            orderBy,
-            setOperators: []
-          });
-          where = undefined;
-          limit = undefined;
-          offset = undefined;
-          orderBy = undefined;
-        } else {
-          result = aliasedTable(table2, tableAlias);
-        }
-        result = this.buildSelectQuery({
-          table: is(result, SQLiteTable) ? result : new Subquery(result, {}, tableAlias),
-          fields: {},
-          fieldsFlat: nestedSelection.map(({ field: field2 }) => ({
-            path: [],
-            field: is(field2, Column) ? aliasedTableColumn(field2, tableAlias) : field2
-          })),
-          joins,
-          where,
-          limit,
-          offset,
-          orderBy,
-          setOperators: []
-        });
-      } else {
-        result = this.buildSelectQuery({
-          table: aliasedTable(table2, tableAlias),
-          fields: {},
-          fieldsFlat: selection.map(({ field }) => ({
-            path: [],
-            field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field
-          })),
-          joins,
-          where,
-          limit,
-          offset,
-          orderBy,
-          setOperators: []
-        });
-      }
-      return {
-        tableTsKey: tableConfig.tsName,
-        sql: result,
-        selection
-      };
-    }
-  };
-  SQLiteSyncDialect = class SQLiteSyncDialect extends SQLiteDialect {
-    static [entityKind] = "SQLiteSyncDialect";
-    migrate(migrations, session, config) {
-      const migrationsTable = config === undefined ? "__drizzle_migrations" : typeof config === "string" ? "__drizzle_migrations" : config.migrationsTable ?? "__drizzle_migrations";
-      const migrationTableCreate = sql`
-			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
-				id SERIAL PRIMARY KEY,
-				hash text NOT NULL,
-				created_at numeric
-			)
-		`;
-      session.run(migrationTableCreate);
-      const dbMigrations = session.values(sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`);
-      const lastDbMigration = dbMigrations[0] ?? undefined;
-      session.run(sql`BEGIN`);
-      try {
-        for (const migration of migrations) {
-          if (!lastDbMigration || Number(lastDbMigration[2]) < migration.folderMillis) {
-            for (const stmt of migration.sql) {
-              session.run(sql.raw(stmt));
-            }
-            session.run(sql`INSERT INTO ${sql.identifier(migrationsTable)} ("hash", "created_at") VALUES(${migration.hash}, ${migration.folderMillis})`);
-          }
-        }
-        session.run(sql`COMMIT`);
-      } catch (e) {
-        session.run(sql`ROLLBACK`);
-        throw e;
-      }
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/query-builders/query-builder.js
-var TypedQueryBuilder;
-var init_query_builder = __esm(() => {
-  init_entity();
-  TypedQueryBuilder = class TypedQueryBuilder {
-    static [entityKind] = "TypedQueryBuilder";
-    getSelectedFields() {
-      return this._.selectedFields;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/query-builders/select.js
-function createSetOperator(type, isAll) {
-  return (leftSelect, rightSelect, ...restSelects) => {
-    const setOperators = [rightSelect, ...restSelects].map((select2) => ({
-      type,
-      isAll,
-      rightSelect: select2
-    }));
-    for (const setOperator of setOperators) {
-      if (!haveSameKeys(leftSelect.getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {
-        throw new Error("Set operator error (union / intersect / except): selected fields are not the same or are in a different order");
-      }
-    }
-    return leftSelect.addSetOperators(setOperators);
-  };
-}
-var SQLiteSelectBuilder, SQLiteSelectQueryBuilderBase, SQLiteSelectBase, getSQLiteSetOperators = () => ({
-  union,
-  unionAll,
-  intersect,
-  except
-}), union, unionAll, intersect, except;
-var init_select2 = __esm(() => {
-  init_entity();
-  init_query_builder();
-  init_query_promise();
-  init_selection_proxy();
-  init_sql();
-  init_subquery();
-  init_table();
-  init_utils();
-  init_view_common();
-  init_utils2();
-  init_view_base();
-  SQLiteSelectBuilder = class SQLiteSelectBuilder {
-    static [entityKind] = "SQLiteSelectBuilder";
-    fields;
-    session;
-    dialect;
-    withList;
-    distinct;
-    constructor(config) {
-      this.fields = config.fields;
-      this.session = config.session;
-      this.dialect = config.dialect;
-      this.withList = config.withList;
-      this.distinct = config.distinct;
-    }
-    from(source) {
-      const isPartialSelect = !!this.fields;
-      let fields;
-      if (this.fields) {
-        fields = this.fields;
-      } else if (is(source, Subquery)) {
-        fields = Object.fromEntries(Object.keys(source._.selectedFields).map((key) => [key, source[key]]));
-      } else if (is(source, SQLiteViewBase)) {
-        fields = source[ViewBaseConfig].selectedFields;
-      } else if (is(source, SQL)) {
-        fields = {};
-      } else {
-        fields = getTableColumns(source);
-      }
-      return new SQLiteSelectBase({
-        table: source,
-        fields,
-        isPartialSelect,
-        session: this.session,
-        dialect: this.dialect,
-        withList: this.withList,
-        distinct: this.distinct
-      });
-    }
-  };
-  SQLiteSelectQueryBuilderBase = class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
-    static [entityKind] = "SQLiteSelectQueryBuilder";
-    _;
-    config;
-    joinsNotNullableMap;
-    tableName;
-    isPartialSelect;
-    session;
-    dialect;
-    cacheConfig = undefined;
-    usedTables = /* @__PURE__ */ new Set;
-    constructor({ table: table2, fields, isPartialSelect, session, dialect, withList, distinct }) {
-      super();
-      this.config = {
-        withList,
-        table: table2,
-        fields: { ...fields },
-        distinct,
-        setOperators: []
-      };
-      this.isPartialSelect = isPartialSelect;
-      this.session = session;
-      this.dialect = dialect;
-      this._ = {
-        selectedFields: fields,
-        config: this.config
-      };
-      this.tableName = getTableLikeName(table2);
-      this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
-      for (const item of extractUsedTable(table2))
-        this.usedTables.add(item);
-    }
-    getUsedTables() {
-      return [...this.usedTables];
-    }
-    createJoin(joinType) {
-      return (table2, on) => {
-        const baseTableName = this.tableName;
-        const tableName = getTableLikeName(table2);
-        for (const item of extractUsedTable(table2))
-          this.usedTables.add(item);
-        if (typeof tableName === "string" && this.config.joins?.some((join2) => join2.alias === tableName)) {
-          throw new Error(`Alias "${tableName}" is already used in this query`);
-        }
-        if (!this.isPartialSelect) {
-          if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") {
-            this.config.fields = {
-              [baseTableName]: this.config.fields
-            };
-          }
-          if (typeof tableName === "string" && !is(table2, SQL)) {
-            const selection = is(table2, Subquery) ? table2._.selectedFields : is(table2, View) ? table2[ViewBaseConfig].selectedFields : table2[Table.Symbol.Columns];
-            this.config.fields[tableName] = selection;
-          }
-        }
-        if (typeof on === "function") {
-          on = on(new Proxy(this.config.fields, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
-        }
-        if (!this.config.joins) {
-          this.config.joins = [];
-        }
-        this.config.joins.push({ on, table: table2, joinType, alias: tableName });
-        if (typeof tableName === "string") {
-          switch (joinType) {
-            case "left": {
-              this.joinsNotNullableMap[tableName] = false;
-              break;
-            }
-            case "right": {
-              this.joinsNotNullableMap = Object.fromEntries(Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]));
-              this.joinsNotNullableMap[tableName] = true;
-              break;
-            }
-            case "cross":
-            case "inner": {
-              this.joinsNotNullableMap[tableName] = true;
-              break;
-            }
-            case "full": {
-              this.joinsNotNullableMap = Object.fromEntries(Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]));
-              this.joinsNotNullableMap[tableName] = false;
-              break;
-            }
-          }
-        }
-        return this;
-      };
-    }
-    leftJoin = this.createJoin("left");
-    rightJoin = this.createJoin("right");
-    innerJoin = this.createJoin("inner");
-    fullJoin = this.createJoin("full");
-    crossJoin = this.createJoin("cross");
-    createSetOperator(type, isAll) {
-      return (rightSelection) => {
-        const rightSelect = typeof rightSelection === "function" ? rightSelection(getSQLiteSetOperators()) : rightSelection;
-        if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {
-          throw new Error("Set operator error (union / intersect / except): selected fields are not the same or are in a different order");
-        }
-        this.config.setOperators.push({ type, isAll, rightSelect });
-        return this;
-      };
-    }
-    union = this.createSetOperator("union", false);
-    unionAll = this.createSetOperator("union", true);
-    intersect = this.createSetOperator("intersect", false);
-    except = this.createSetOperator("except", false);
-    addSetOperators(setOperators) {
-      this.config.setOperators.push(...setOperators);
-      return this;
-    }
-    where(where) {
-      if (typeof where === "function") {
-        where = where(new Proxy(this.config.fields, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
-      }
-      this.config.where = where;
-      return this;
-    }
-    having(having) {
-      if (typeof having === "function") {
-        having = having(new Proxy(this.config.fields, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
-      }
-      this.config.having = having;
-      return this;
-    }
-    groupBy(...columns) {
-      if (typeof columns[0] === "function") {
-        const groupBy = columns[0](new Proxy(this.config.fields, new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
-        this.config.groupBy = Array.isArray(groupBy) ? groupBy : [groupBy];
-      } else {
-        this.config.groupBy = columns;
-      }
-      return this;
-    }
-    orderBy(...columns) {
-      if (typeof columns[0] === "function") {
-        const orderBy = columns[0](new Proxy(this.config.fields, new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
-        const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
-        if (this.config.setOperators.length > 0) {
-          this.config.setOperators.at(-1).orderBy = orderByArray;
-        } else {
-          this.config.orderBy = orderByArray;
-        }
-      } else {
-        const orderByArray = columns;
-        if (this.config.setOperators.length > 0) {
-          this.config.setOperators.at(-1).orderBy = orderByArray;
-        } else {
-          this.config.orderBy = orderByArray;
-        }
-      }
-      return this;
-    }
-    limit(limit) {
-      if (this.config.setOperators.length > 0) {
-        this.config.setOperators.at(-1).limit = limit;
-      } else {
-        this.config.limit = limit;
-      }
-      return this;
-    }
-    offset(offset) {
-      if (this.config.setOperators.length > 0) {
-        this.config.setOperators.at(-1).offset = offset;
-      } else {
-        this.config.offset = offset;
-      }
-      return this;
-    }
-    getSQL() {
-      return this.dialect.buildSelectQuery(this.config);
-    }
-    toSQL() {
-      const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-      return rest;
-    }
-    as(alias3) {
-      const usedTables = [];
-      usedTables.push(...extractUsedTable(this.config.table));
-      if (this.config.joins) {
-        for (const it of this.config.joins)
-          usedTables.push(...extractUsedTable(it.table));
-      }
-      return new Proxy(new Subquery(this.getSQL(), this.config.fields, alias3, false, [...new Set(usedTables)]), new SelectionProxyHandler({ alias: alias3, sqlAliasedBehavior: "alias", sqlBehavior: "error" }));
-    }
-    getSelectedFields() {
-      return new Proxy(this.config.fields, new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: "alias", sqlBehavior: "error" }));
-    }
-    $dynamic() {
-      return this;
-    }
-  };
-  SQLiteSelectBase = class SQLiteSelectBase extends SQLiteSelectQueryBuilderBase {
-    static [entityKind] = "SQLiteSelect";
-    _prepare(isOneTimeQuery = true) {
-      if (!this.session) {
-        throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
-      }
-      const fieldsList = orderSelectedFields(this.config.fields);
-      const query = this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), fieldsList, "all", true, undefined, {
-        type: "select",
-        tables: [...this.usedTables]
-      }, this.cacheConfig);
-      query.joinsNotNullableMap = this.joinsNotNullableMap;
-      return query;
-    }
-    $withCache(config) {
-      this.cacheConfig = config === undefined ? { config: {}, enable: true, autoInvalidate: true } : config === false ? { enable: false } : { enable: true, autoInvalidate: true, ...config };
-      return this;
-    }
-    prepare() {
-      return this._prepare(false);
-    }
-    run = (placeholderValues) => {
-      return this._prepare().run(placeholderValues);
-    };
-    all = (placeholderValues) => {
-      return this._prepare().all(placeholderValues);
-    };
-    get = (placeholderValues) => {
-      return this._prepare().get(placeholderValues);
-    };
-    values = (placeholderValues) => {
-      return this._prepare().values(placeholderValues);
-    };
-    async execute() {
-      return this.all();
-    }
-  };
-  applyMixins(SQLiteSelectBase, [QueryPromise]);
-  union = createSetOperator("union", false);
-  unionAll = createSetOperator("union", true);
-  intersect = createSetOperator("intersect", false);
-  except = createSetOperator("except", false);
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/query-builders/query-builder.js
-var QueryBuilder;
-var init_query_builder2 = __esm(() => {
-  init_entity();
-  init_selection_proxy();
-  init_dialect();
-  init_subquery();
-  init_select2();
-  QueryBuilder = class QueryBuilder {
-    static [entityKind] = "SQLiteQueryBuilder";
-    dialect;
-    dialectConfig;
-    constructor(dialect) {
-      this.dialect = is(dialect, SQLiteDialect) ? dialect : undefined;
-      this.dialectConfig = is(dialect, SQLiteDialect) ? undefined : dialect;
-    }
-    $with = (alias3, selection) => {
-      const queryBuilder = this;
-      const as = (qb) => {
-        if (typeof qb === "function") {
-          qb = qb(queryBuilder);
-        }
-        return new Proxy(new WithSubquery(qb.getSQL(), selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}), alias3, true), new SelectionProxyHandler({ alias: alias3, sqlAliasedBehavior: "alias", sqlBehavior: "error" }));
-      };
-      return { as };
-    };
-    with(...queries) {
-      const self = this;
-      function select2(fields) {
-        return new SQLiteSelectBuilder({
-          fields: fields ?? undefined,
-          session: undefined,
-          dialect: self.getDialect(),
-          withList: queries
-        });
-      }
-      function selectDistinct(fields) {
-        return new SQLiteSelectBuilder({
-          fields: fields ?? undefined,
-          session: undefined,
-          dialect: self.getDialect(),
-          withList: queries,
-          distinct: true
-        });
-      }
-      return { select: select2, selectDistinct };
-    }
-    select(fields) {
-      return new SQLiteSelectBuilder({ fields: fields ?? undefined, session: undefined, dialect: this.getDialect() });
-    }
-    selectDistinct(fields) {
-      return new SQLiteSelectBuilder({
-        fields: fields ?? undefined,
-        session: undefined,
-        dialect: this.getDialect(),
-        distinct: true
-      });
-    }
-    getDialect() {
-      if (!this.dialect) {
-        this.dialect = new SQLiteSyncDialect(this.dialectConfig);
-      }
-      return this.dialect;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/query-builders/insert.js
-var SQLiteInsertBuilder, SQLiteInsertBase;
-var init_insert = __esm(() => {
-  init_entity();
-  init_query_promise();
-  init_sql();
-  init_table3();
-  init_table();
-  init_utils();
-  init_utils2();
-  init_query_builder2();
-  SQLiteInsertBuilder = class SQLiteInsertBuilder {
-    constructor(table2, session, dialect, withList) {
-      this.table = table2;
-      this.session = session;
-      this.dialect = dialect;
-      this.withList = withList;
-    }
-    static [entityKind] = "SQLiteInsertBuilder";
-    values(values) {
-      values = Array.isArray(values) ? values : [values];
-      if (values.length === 0) {
-        throw new Error("values() must be called with at least one value");
-      }
-      const mappedValues = values.map((entry) => {
-        const result = {};
-        const cols = this.table[Table.Symbol.Columns];
-        for (const colKey of Object.keys(entry)) {
-          const colValue = entry[colKey];
-          result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
-        }
-        return result;
-      });
-      return new SQLiteInsertBase(this.table, mappedValues, this.session, this.dialect, this.withList);
-    }
-    select(selectQuery) {
-      const select2 = typeof selectQuery === "function" ? selectQuery(new QueryBuilder) : selectQuery;
-      if (!is(select2, SQL) && !haveSameKeys(this.table[Columns], select2._.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 SQLiteInsertBase(this.table, select2, this.session, this.dialect, this.withList, true);
-    }
-  };
-  SQLiteInsertBase = class SQLiteInsertBase extends QueryPromise {
-    constructor(table2, values, session, dialect, withList, select2) {
-      super();
-      this.session = session;
-      this.dialect = dialect;
-      this.config = { table: table2, values, withList, select: select2 };
-    }
-    static [entityKind] = "SQLiteInsert";
-    config;
-    returning(fields = this.config.table[SQLiteTable.Symbol.Columns]) {
-      this.config.returning = orderSelectedFields(fields);
-      return this;
-    }
-    onConflictDoNothing(config = {}) {
-      if (!this.config.onConflict)
-        this.config.onConflict = [];
-      if (config.target === undefined) {
-        this.config.onConflict.push(sql` on conflict do nothing`);
-      } else {
-        const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
-        const whereSql = config.where ? sql` where ${config.where}` : sql``;
-        this.config.onConflict.push(sql` on conflict ${targetSql} do nothing${whereSql}`);
-      }
-      return this;
-    }
-    onConflictDoUpdate(config) {
-      if (config.where && (config.targetWhere || config.setWhere)) {
-        throw new Error('You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.');
-      }
-      if (!this.config.onConflict)
-        this.config.onConflict = [];
-      const whereSql = config.where ? sql` where ${config.where}` : undefined;
-      const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : undefined;
-      const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : undefined;
-      const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
-      const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
-      this.config.onConflict.push(sql` on conflict ${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`);
-      return this;
-    }
-    getSQL() {
-      return this.dialect.buildInsertQuery(this.config);
-    }
-    toSQL() {
-      const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-      return rest;
-    }
-    _prepare(isOneTimeQuery = true) {
-      return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", true, undefined, {
-        type: "insert",
-        tables: extractUsedTable(this.config.table)
-      });
-    }
-    prepare() {
-      return this._prepare(false);
-    }
-    run = (placeholderValues) => {
-      return this._prepare().run(placeholderValues);
-    };
-    all = (placeholderValues) => {
-      return this._prepare().all(placeholderValues);
-    };
-    get = (placeholderValues) => {
-      return this._prepare().get(placeholderValues);
-    };
-    values = (placeholderValues) => {
-      return this._prepare().values(placeholderValues);
-    };
-    async execute() {
-      return this.config.returning ? this.all() : this.run();
-    }
-    $dynamic() {
-      return this;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/query-builders/update.js
-var SQLiteUpdateBuilder, SQLiteUpdateBase;
-var init_update = __esm(() => {
-  init_entity();
-  init_query_promise();
-  init_selection_proxy();
-  init_table3();
-  init_subquery();
-  init_table();
-  init_utils();
-  init_view_common();
-  init_utils2();
-  init_view_base();
-  SQLiteUpdateBuilder = class SQLiteUpdateBuilder {
-    constructor(table2, session, dialect, withList) {
-      this.table = table2;
-      this.session = session;
-      this.dialect = dialect;
-      this.withList = withList;
-    }
-    static [entityKind] = "SQLiteUpdateBuilder";
-    set(values) {
-      return new SQLiteUpdateBase(this.table, mapUpdateSet(this.table, values), this.session, this.dialect, this.withList);
-    }
-  };
-  SQLiteUpdateBase = class SQLiteUpdateBase extends QueryPromise {
-    constructor(table2, set, session, dialect, withList) {
-      super();
-      this.session = session;
-      this.dialect = dialect;
-      this.config = { set, table: table2, withList, joins: [] };
-    }
-    static [entityKind] = "SQLiteUpdate";
-    config;
-    from(source) {
-      this.config.from = source;
-      return this;
-    }
-    createJoin(joinType) {
-      return (table2, on) => {
-        const tableName = getTableLikeName(table2);
-        if (typeof tableName === "string" && this.config.joins.some((join2) => join2.alias === tableName)) {
-          throw new Error(`Alias "${tableName}" is already used in this query`);
-        }
-        if (typeof on === "function") {
-          const from = this.config.from ? is(table2, SQLiteTable) ? table2[Table.Symbol.Columns] : is(table2, Subquery) ? table2._.selectedFields : is(table2, SQLiteViewBase) ? table2[ViewBaseConfig].selectedFields : undefined : undefined;
-          on = on(new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })), from && new Proxy(from, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
-        }
-        this.config.joins.push({ on, table: table2, joinType, alias: tableName });
-        return this;
-      };
-    }
-    leftJoin = this.createJoin("left");
-    rightJoin = this.createJoin("right");
-    innerJoin = this.createJoin("inner");
-    fullJoin = this.createJoin("full");
-    where(where) {
-      this.config.where = where;
-      return this;
-    }
-    orderBy(...columns) {
-      if (typeof columns[0] === "function") {
-        const orderBy = columns[0](new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
-        const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
-        this.config.orderBy = orderByArray;
-      } else {
-        const orderByArray = columns;
-        this.config.orderBy = orderByArray;
-      }
-      return this;
-    }
-    limit(limit) {
-      this.config.limit = limit;
-      return this;
-    }
-    returning(fields = this.config.table[SQLiteTable.Symbol.Columns]) {
-      this.config.returning = orderSelectedFields(fields);
-      return this;
-    }
-    getSQL() {
-      return this.dialect.buildUpdateQuery(this.config);
-    }
-    toSQL() {
-      const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-      return rest;
-    }
-    _prepare(isOneTimeQuery = true) {
-      return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", true, undefined, {
-        type: "insert",
-        tables: extractUsedTable(this.config.table)
-      });
-    }
-    prepare() {
-      return this._prepare(false);
-    }
-    run = (placeholderValues) => {
-      return this._prepare().run(placeholderValues);
-    };
-    all = (placeholderValues) => {
-      return this._prepare().all(placeholderValues);
-    };
-    get = (placeholderValues) => {
-      return this._prepare().get(placeholderValues);
-    };
-    values = (placeholderValues) => {
-      return this._prepare().values(placeholderValues);
-    };
-    async execute() {
-      return this.config.returning ? this.all() : this.run();
-    }
-    $dynamic() {
-      return this;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/query-builders/index.js
-var init_query_builders = __esm(() => {
-  init_delete();
-  init_insert();
-  init_query_builder2();
-  init_select2();
-  init_update();
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/query-builders/count.js
-var SQLiteCountBuilder;
-var init_count = __esm(() => {
-  init_entity();
-  init_sql();
-  SQLiteCountBuilder = class SQLiteCountBuilder extends SQL {
-    constructor(params) {
-      super(SQLiteCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
-      this.params = params;
-      this.session = params.session;
-      this.sql = SQLiteCountBuilder.buildCount(params.source, params.filters);
-    }
-    sql;
-    static [entityKind] = "SQLiteCountBuilderAsync";
-    [Symbol.toStringTag] = "SQLiteCountBuilderAsync";
-    session;
-    static buildEmbeddedCount(source, filters) {
-      return sql`(select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters})`;
-    }
-    static buildCount(source, filters) {
-      return sql`select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters}`;
-    }
-    then(onfulfilled, onrejected) {
-      return Promise.resolve(this.session.count(this.sql)).then(onfulfilled, onrejected);
-    }
-    catch(onRejected) {
-      return this.then(undefined, onRejected);
-    }
-    finally(onFinally) {
-      return this.then((value) => {
-        onFinally?.();
-        return value;
-      }, (reason) => {
-        onFinally?.();
-        throw reason;
-      });
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/query-builders/query.js
-var RelationalQueryBuilder, SQLiteRelationalQuery, SQLiteSyncRelationalQuery;
-var init_query = __esm(() => {
-  init_entity();
-  init_query_promise();
-  init_relations();
-  RelationalQueryBuilder = class RelationalQueryBuilder {
-    constructor(mode, fullSchema, schema, tableNamesMap, table2, tableConfig, dialect, session) {
-      this.mode = mode;
-      this.fullSchema = fullSchema;
-      this.schema = schema;
-      this.tableNamesMap = tableNamesMap;
-      this.table = table2;
-      this.tableConfig = tableConfig;
-      this.dialect = dialect;
-      this.session = session;
-    }
-    static [entityKind] = "SQLiteAsyncRelationalQueryBuilder";
-    findMany(config) {
-      return this.mode === "sync" ? new SQLiteSyncRelationalQuery(this.fullSchema, this.schema, this.tableNamesMap, this.table, this.tableConfig, this.dialect, this.session, config ? config : {}, "many") : new SQLiteRelationalQuery(this.fullSchema, this.schema, this.tableNamesMap, this.table, this.tableConfig, this.dialect, this.session, config ? config : {}, "many");
-    }
-    findFirst(config) {
-      return this.mode === "sync" ? new SQLiteSyncRelationalQuery(this.fullSchema, this.schema, this.tableNamesMap, this.table, this.tableConfig, this.dialect, this.session, config ? { ...config, limit: 1 } : { limit: 1 }, "first") : new SQLiteRelationalQuery(this.fullSchema, this.schema, this.tableNamesMap, this.table, this.tableConfig, this.dialect, this.session, config ? { ...config, limit: 1 } : { limit: 1 }, "first");
-    }
-  };
-  SQLiteRelationalQuery = class SQLiteRelationalQuery extends QueryPromise {
-    constructor(fullSchema, schema, tableNamesMap, table2, tableConfig, dialect, session, config, mode) {
-      super();
-      this.fullSchema = fullSchema;
-      this.schema = schema;
-      this.tableNamesMap = tableNamesMap;
-      this.table = table2;
-      this.tableConfig = tableConfig;
-      this.dialect = dialect;
-      this.session = session;
-      this.config = config;
-      this.mode = mode;
-    }
-    static [entityKind] = "SQLiteAsyncRelationalQuery";
-    mode;
-    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;
-    }
-    _prepare(isOneTimeQuery = false) {
-      const { query, builtQuery } = this._toSQL();
-      return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](builtQuery, undefined, this.mode === "first" ? "get" : "all", true, (rawRows, mapColumnValue) => {
-        const rows = rawRows.map((row) => mapRelationalRow(this.schema, this.tableConfig, row, query.selection, mapColumnValue));
-        if (this.mode === "first") {
-          return rows[0];
-        }
-        return rows;
-      });
-    }
-    prepare() {
-      return this._prepare(false);
-    }
-    _toSQL() {
-      const query = 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
-      });
-      const builtQuery = this.dialect.sqlToQuery(query.sql);
-      return { query, builtQuery };
-    }
-    toSQL() {
-      return this._toSQL().builtQuery;
-    }
-    executeRaw() {
-      if (this.mode === "first") {
-        return this._prepare(false).get();
-      }
-      return this._prepare(false).all();
-    }
-    async execute() {
-      return this.executeRaw();
-    }
-  };
-  SQLiteSyncRelationalQuery = class SQLiteSyncRelationalQuery extends SQLiteRelationalQuery {
-    static [entityKind] = "SQLiteSyncRelationalQuery";
-    sync() {
-      return this.executeRaw();
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/query-builders/raw.js
-var SQLiteRaw;
-var init_raw = __esm(() => {
-  init_entity();
-  init_query_promise();
-  SQLiteRaw = class SQLiteRaw extends QueryPromise {
-    constructor(execute, getSQL, action, dialect, mapBatchResult) {
-      super();
-      this.execute = execute;
-      this.getSQL = getSQL;
-      this.dialect = dialect;
-      this.mapBatchResult = mapBatchResult;
-      this.config = { action };
-    }
-    static [entityKind] = "SQLiteRaw";
-    config;
-    getQuery() {
-      return { ...this.dialect.sqlToQuery(this.getSQL()), method: this.config.action };
-    }
-    mapResult(result, isFromBatch) {
-      return isFromBatch ? this.mapBatchResult(result) : result;
-    }
-    _prepare() {
-      return this;
-    }
-    isResponseInArrayMode() {
-      return false;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/db.js
-var BaseSQLiteDatabase;
-var init_db = __esm(() => {
-  init_entity();
-  init_selection_proxy();
-  init_sql();
-  init_query_builders();
-  init_subquery();
-  init_count();
-  init_query();
-  init_raw();
-  BaseSQLiteDatabase = class BaseSQLiteDatabase {
-    constructor(resultKind, dialect, session, schema) {
-      this.resultKind = resultKind;
-      this.dialect = dialect;
-      this.session = session;
-      this._ = schema ? {
-        schema: schema.schema,
-        fullSchema: schema.fullSchema,
-        tableNamesMap: schema.tableNamesMap
-      } : {
-        schema: undefined,
-        fullSchema: {},
-        tableNamesMap: {}
-      };
-      this.query = {};
-      const query = this.query;
-      if (this._.schema) {
-        for (const [tableName, columns] of Object.entries(this._.schema)) {
-          query[tableName] = new RelationalQueryBuilder(resultKind, schema.fullSchema, this._.schema, this._.tableNamesMap, schema.fullSchema[tableName], columns, dialect, session);
-        }
-      }
-      this.$cache = { invalidate: async (_params) => {} };
-    }
-    static [entityKind] = "BaseSQLiteDatabase";
-    query;
-    $with = (alias3, selection) => {
-      const self = this;
-      const as = (qb) => {
-        if (typeof qb === "function") {
-          qb = qb(new QueryBuilder(self.dialect));
-        }
-        return new Proxy(new WithSubquery(qb.getSQL(), selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}), alias3, true), new SelectionProxyHandler({ alias: alias3, sqlAliasedBehavior: "alias", sqlBehavior: "error" }));
-      };
-      return { as };
-    };
-    $count(source, filters) {
-      return new SQLiteCountBuilder({ source, filters, session: this.session });
-    }
-    with(...queries) {
-      const self = this;
-      function select3(fields) {
-        return new SQLiteSelectBuilder({
-          fields: fields ?? undefined,
-          session: self.session,
-          dialect: self.dialect,
-          withList: queries
-        });
-      }
-      function selectDistinct(fields) {
-        return new SQLiteSelectBuilder({
-          fields: fields ?? undefined,
-          session: self.session,
-          dialect: self.dialect,
-          withList: queries,
-          distinct: true
-        });
-      }
-      function update2(table2) {
-        return new SQLiteUpdateBuilder(table2, self.session, self.dialect, queries);
-      }
-      function insert2(into) {
-        return new SQLiteInsertBuilder(into, self.session, self.dialect, queries);
-      }
-      function delete_(from) {
-        return new SQLiteDeleteBase(from, self.session, self.dialect, queries);
-      }
-      return { select: select3, selectDistinct, update: update2, insert: insert2, delete: delete_ };
-    }
-    select(fields) {
-      return new SQLiteSelectBuilder({ fields: fields ?? undefined, session: this.session, dialect: this.dialect });
-    }
-    selectDistinct(fields) {
-      return new SQLiteSelectBuilder({
-        fields: fields ?? undefined,
-        session: this.session,
-        dialect: this.dialect,
-        distinct: true
-      });
-    }
-    update(table2) {
-      return new SQLiteUpdateBuilder(table2, this.session, this.dialect);
-    }
-    $cache;
-    insert(into) {
-      return new SQLiteInsertBuilder(into, this.session, this.dialect);
-    }
-    delete(from) {
-      return new SQLiteDeleteBase(from, this.session, this.dialect);
-    }
-    run(query) {
-      const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
-      if (this.resultKind === "async") {
-        return new SQLiteRaw(async () => this.session.run(sequel), () => sequel, "run", this.dialect, this.session.extractRawRunValueFromBatchResult.bind(this.session));
-      }
-      return this.session.run(sequel);
-    }
-    all(query) {
-      const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
-      if (this.resultKind === "async") {
-        return new SQLiteRaw(async () => this.session.all(sequel), () => sequel, "all", this.dialect, this.session.extractRawAllValueFromBatchResult.bind(this.session));
-      }
-      return this.session.all(sequel);
-    }
-    get(query) {
-      const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
-      if (this.resultKind === "async") {
-        return new SQLiteRaw(async () => this.session.get(sequel), () => sequel, "get", this.dialect, this.session.extractRawGetValueFromBatchResult.bind(this.session));
-      }
-      return this.session.get(sequel);
-    }
-    values(query) {
-      const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
-      if (this.resultKind === "async") {
-        return new SQLiteRaw(async () => this.session.values(sequel), () => sequel, "values", this.dialect, this.session.extractRawValuesValueFromBatchResult.bind(this.session));
-      }
-      return this.session.values(sequel);
-    }
-    transaction(transaction, config) {
-      return this.session.transaction(transaction, config);
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/alias.js
-var init_alias2 = () => {};
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/cache/core/cache.js
-async function hashQuery(sql4, params) {
-  const dataToHash = `${sql4}-${JSON.stringify(params)}`;
-  const encoder = new TextEncoder;
-  const data = encoder.encode(dataToHash);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-  const hashArray = [...new Uint8Array(hashBuffer)];
-  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-  return hashHex;
-}
-var Cache, NoopCache;
-var init_cache = __esm(() => {
-  init_entity();
-  Cache = class Cache {
-    static [entityKind] = "Cache";
-  };
-  NoopCache = class NoopCache extends Cache {
-    strategy() {
-      return "all";
-    }
-    static [entityKind] = "NoopCache";
-    async get(_key) {
-      return;
-    }
-    async put(_hashedQuery, _response, _tables, _config) {}
-    async onMutate(_params) {}
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/session.js
-var ExecuteResultSync, SQLitePreparedQuery, SQLiteSession, SQLiteTransaction;
-var init_session = __esm(() => {
-  init_cache();
-  init_entity();
-  init_errors();
-  init_query_promise();
-  init_db();
-  ExecuteResultSync = class ExecuteResultSync extends QueryPromise {
-    constructor(resultCb) {
-      super();
-      this.resultCb = resultCb;
-    }
-    static [entityKind] = "ExecuteResultSync";
-    async execute() {
-      return this.resultCb();
-    }
-    sync() {
-      return this.resultCb();
-    }
-  };
-  SQLitePreparedQuery = class SQLitePreparedQuery {
-    constructor(mode, executeMethod, query, cache, queryMetadata, cacheConfig) {
-      this.mode = mode;
-      this.executeMethod = executeMethod;
-      this.query = query;
-      this.cache = cache;
-      this.queryMetadata = queryMetadata;
-      this.cacheConfig = cacheConfig;
-      if (cache && cache.strategy() === "all" && cacheConfig === undefined) {
-        this.cacheConfig = { enable: true, autoInvalidate: true };
-      }
-      if (!this.cacheConfig?.enable) {
-        this.cacheConfig = undefined;
-      }
-    }
-    static [entityKind] = "PreparedQuery";
-    joinsNotNullableMap;
-    async queryWithCache(queryString, params, query) {
-      if (this.cache === undefined || is(this.cache, NoopCache) || this.queryMetadata === undefined) {
-        try {
-          return await query();
-        } catch (e) {
-          throw new DrizzleQueryError(queryString, params, e);
-        }
-      }
-      if (this.cacheConfig && !this.cacheConfig.enable) {
-        try {
-          return await query();
-        } catch (e) {
-          throw new DrizzleQueryError(queryString, params, e);
-        }
-      }
-      if ((this.queryMetadata.type === "insert" || this.queryMetadata.type === "update" || this.queryMetadata.type === "delete") && this.queryMetadata.tables.length > 0) {
-        try {
-          const [res] = await Promise.all([
-            query(),
-            this.cache.onMutate({ tables: this.queryMetadata.tables })
-          ]);
-          return res;
-        } catch (e) {
-          throw new DrizzleQueryError(queryString, params, e);
-        }
-      }
-      if (!this.cacheConfig) {
-        try {
-          return await query();
-        } catch (e) {
-          throw new DrizzleQueryError(queryString, params, e);
-        }
-      }
-      if (this.queryMetadata.type === "select") {
-        const fromCache = await this.cache.get(this.cacheConfig.tag ?? await hashQuery(queryString, params), this.queryMetadata.tables, this.cacheConfig.tag !== undefined, this.cacheConfig.autoInvalidate);
-        if (fromCache === undefined) {
-          let result;
-          try {
-            result = await query();
-          } catch (e) {
-            throw new DrizzleQueryError(queryString, params, e);
-          }
-          await this.cache.put(this.cacheConfig.tag ?? await hashQuery(queryString, params), result, this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [], this.cacheConfig.tag !== undefined, this.cacheConfig.config);
-          return result;
-        }
-        return fromCache;
-      }
-      try {
-        return await query();
-      } catch (e) {
-        throw new DrizzleQueryError(queryString, params, e);
-      }
-    }
-    getQuery() {
-      return this.query;
-    }
-    mapRunResult(result, _isFromBatch) {
-      return result;
-    }
-    mapAllResult(_result, _isFromBatch) {
-      throw new Error("Not implemented");
-    }
-    mapGetResult(_result, _isFromBatch) {
-      throw new Error("Not implemented");
-    }
-    execute(placeholderValues) {
-      if (this.mode === "async") {
-        return this[this.executeMethod](placeholderValues);
-      }
-      return new ExecuteResultSync(() => this[this.executeMethod](placeholderValues));
-    }
-    mapResult(response, isFromBatch) {
-      switch (this.executeMethod) {
-        case "run": {
-          return this.mapRunResult(response, isFromBatch);
-        }
-        case "all": {
-          return this.mapAllResult(response, isFromBatch);
-        }
-        case "get": {
-          return this.mapGetResult(response, isFromBatch);
-        }
-      }
-    }
-  };
-  SQLiteSession = class SQLiteSession {
-    constructor(dialect) {
-      this.dialect = dialect;
-    }
-    static [entityKind] = "SQLiteSession";
-    prepareOneTimeQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
-      return this.prepareQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig);
-    }
-    run(query) {
-      const staticQuery = this.dialect.sqlToQuery(query);
-      try {
-        return this.prepareOneTimeQuery(staticQuery, undefined, "run", false).run();
-      } catch (err) {
-        throw new DrizzleError({ cause: err, message: `Failed to run the query '${staticQuery.sql}'` });
-      }
-    }
-    extractRawRunValueFromBatchResult(result) {
-      return result;
-    }
-    all(query) {
-      return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, "run", false).all();
-    }
-    extractRawAllValueFromBatchResult(_result) {
-      throw new Error("Not implemented");
-    }
-    get(query) {
-      return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, "run", false).get();
-    }
-    extractRawGetValueFromBatchResult(_result) {
-      throw new Error("Not implemented");
-    }
-    values(query) {
-      return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, "run", false).values();
-    }
-    async count(sql4) {
-      const result = await this.values(sql4);
-      return result[0][0];
-    }
-    extractRawValuesValueFromBatchResult(_result) {
-      throw new Error("Not implemented");
-    }
-  };
-  SQLiteTransaction = class SQLiteTransaction extends BaseSQLiteDatabase {
-    constructor(resultType, dialect, session, schema, nestedIndex = 0) {
-      super(resultType, dialect, session, schema);
-      this.schema = schema;
-      this.nestedIndex = nestedIndex;
-    }
-    static [entityKind] = "SQLiteTransaction";
-    rollback() {
-      throw new TransactionRollbackError;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/view.js
-var init_view = () => {};
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/sqlite-core/index.js
-var init_sqlite_core = __esm(() => {
-  init_alias2();
-  init_checks();
-  init_columns();
-  init_db();
-  init_dialect();
-  init_foreign_keys();
-  init_indexes();
-  init_primary_keys2();
-  init_query_builders();
-  init_session();
-  init_table3();
-  init_unique_constraint2();
-  init_utils2();
-  init_view();
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/bun-sqlite/session.js
-var SQLiteBunSession, SQLiteBunTransaction, PreparedQuery;
-var init_session2 = __esm(() => {
-  init_entity();
-  init_logger();
-  init_sql();
-  init_sqlite_core();
-  init_session();
-  init_utils();
-  SQLiteBunSession = class SQLiteBunSession extends SQLiteSession {
-    constructor(client, dialect2, schema, options = {}) {
-      super(dialect2);
-      this.client = client;
-      this.schema = schema;
-      this.logger = options.logger ?? new NoopLogger;
-    }
-    static [entityKind] = "SQLiteBunSession";
-    logger;
-    exec(query) {
-      this.client.exec(query);
-    }
-    prepareQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper) {
-      const stmt = this.client.prepare(query.sql);
-      return new PreparedQuery(stmt, query, this.logger, fields, executeMethod, isResponseInArrayMode, customResultMapper);
-    }
-    transaction(transaction, config = {}) {
-      const tx = new SQLiteBunTransaction("sync", this.dialect, this, this.schema);
-      let result;
-      const nativeTx = this.client.transaction(() => {
-        result = transaction(tx);
-      });
-      nativeTx[config.behavior ?? "deferred"]();
-      return result;
-    }
-  };
-  SQLiteBunTransaction = class SQLiteBunTransaction extends SQLiteTransaction {
-    static [entityKind] = "SQLiteBunTransaction";
-    transaction(transaction) {
-      const savepointName = `sp${this.nestedIndex}`;
-      const tx = new SQLiteBunTransaction("sync", this.dialect, this.session, this.schema, this.nestedIndex + 1);
-      this.session.run(sql.raw(`savepoint ${savepointName}`));
-      try {
-        const result = transaction(tx);
-        this.session.run(sql.raw(`release savepoint ${savepointName}`));
-        return result;
-      } catch (err) {
-        this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
-        throw err;
-      }
-    }
-  };
-  PreparedQuery = class PreparedQuery extends SQLitePreparedQuery {
-    constructor(stmt, query, logger2, fields, executeMethod, _isResponseInArrayMode, customResultMapper) {
-      super("sync", executeMethod, query);
-      this.stmt = stmt;
-      this.logger = logger2;
-      this.fields = fields;
-      this._isResponseInArrayMode = _isResponseInArrayMode;
-      this.customResultMapper = customResultMapper;
-    }
-    static [entityKind] = "SQLiteBunPreparedQuery";
-    run(placeholderValues) {
-      const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-      this.logger.logQuery(this.query.sql, params);
-      return this.stmt.run(...params);
-    }
-    all(placeholderValues) {
-      const { fields, query, logger: logger2, joinsNotNullableMap, stmt, customResultMapper } = this;
-      if (!fields && !customResultMapper) {
-        const params = fillPlaceholders(query.params, placeholderValues ?? {});
-        logger2.logQuery(query.sql, params);
-        return stmt.all(...params);
-      }
-      const rows = this.values(placeholderValues);
-      if (customResultMapper) {
-        return customResultMapper(rows);
-      }
-      return rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
-    }
-    get(placeholderValues) {
-      const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-      this.logger.logQuery(this.query.sql, params);
-      const row = this.stmt.values(...params)[0];
-      if (!row) {
-        return;
-      }
-      const { fields, joinsNotNullableMap, customResultMapper } = this;
-      if (!fields && !customResultMapper) {
-        return row;
-      }
-      if (customResultMapper) {
-        return customResultMapper([row]);
-      }
-      return mapResultRow(fields, row, joinsNotNullableMap);
-    }
-    values(placeholderValues) {
-      const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-      this.logger.logQuery(this.query.sql, params);
-      return this.stmt.values(...params);
-    }
-    isResponseInArrayMode() {
-      return this._isResponseInArrayMode;
-    }
-  };
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/bun-sqlite/driver.js
-import { Database } from "bun:sqlite";
-function construct(client, config = {}) {
-  const dialect2 = new SQLiteSyncDialect({ casing: config.casing });
-  let logger2;
-  if (config.logger === true) {
-    logger2 = new DefaultLogger;
-  } else if (config.logger !== false) {
-    logger2 = config.logger;
-  }
-  let schema;
-  if (config.schema) {
-    const tablesConfig = extractTablesRelationalConfig(config.schema, createTableRelationsHelpers);
-    schema = {
-      fullSchema: config.schema,
-      schema: tablesConfig.tables,
-      tableNamesMap: tablesConfig.tableNamesMap
-    };
-  }
-  const session2 = new SQLiteBunSession(client, dialect2, schema, { logger: logger2 });
-  const db2 = new BunSQLiteDatabase("sync", dialect2, session2, schema);
-  db2.$client = client;
-  return db2;
-}
-function drizzle(...params) {
-  if (params[0] === undefined || typeof params[0] === "string") {
-    const instance = params[0] === undefined ? new Database : new Database(params[0]);
-    return construct(instance, params[1]);
-  }
-  if (isConfig(params[0])) {
-    const { connection, client, ...drizzleConfig } = params[0];
-    if (client)
-      return construct(client, drizzleConfig);
-    if (typeof connection === "object") {
-      const { source, ...opts } = connection;
-      const options = Object.values(opts).filter((v) => v !== undefined).length ? opts : undefined;
-      const instance2 = new Database(source, options);
-      return construct(instance2, drizzleConfig);
-    }
-    const instance = new Database(connection);
-    return construct(instance, drizzleConfig);
-  }
-  return construct(params[0], params[1]);
-}
-var BunSQLiteDatabase;
-var init_driver = __esm(() => {
-  init_entity();
-  init_logger();
-  init_relations();
-  init_db();
-  init_dialect();
-  init_utils();
-  init_session2();
-  BunSQLiteDatabase = class BunSQLiteDatabase extends BaseSQLiteDatabase {
-    static [entityKind] = "BunSQLiteDatabase";
-  };
-  ((drizzle2) => {
-    function mock(config) {
-      return construct({}, config);
-    }
-    drizzle2.mock = mock;
-  })(drizzle || (drizzle = {}));
-});
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/bun-sqlite/index.js
-var init_bun_sqlite = __esm(() => {
-  init_driver();
-  init_session2();
-});
-
 // src/db/schema.ts
 var exports_schema = {};
 __export(exports_schema, {
@@ -4399,10 +113,10 @@ __export(exports_schema, {
   events: () => events,
   conversations: () => conversations
 });
+import { sqliteTable, text, integer, index, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { sql } from "drizzle-orm";
 var groups, labels, sessions, sessionLabels, conversations, events, worktreeAssociations, sessionStats;
 var init_schema = __esm(() => {
-  init_sqlite_core();
-  init_drizzle_orm();
   groups = sqliteTable("groups", {
     id: text("id").primaryKey(),
     parentId: text("parent_id").references(() => groups.id, {
@@ -4503,14 +217,15 @@ var init_schema = __esm(() => {
 });
 
 // src/db/client.ts
-import { Database as Database2 } from "bun:sqlite";
+import { Database } from "bun:sqlite";
+import { drizzle } from "drizzle-orm/bun-sqlite";
 import { mkdirSync } from "fs";
 import { dirname } from "path";
 function getDb() {
   if (_db)
     return _db;
   mkdirSync(dirname(paths.db), { recursive: true });
-  const sqlite = new Database2(paths.db);
+  const sqlite = new Database(paths.db);
   sqlite.exec("PRAGMA journal_mode = WAL");
   sqlite.exec("PRAGMA foreign_keys = ON");
   sqlite.exec("PRAGMA synchronous = NORMAL");
@@ -4521,51 +236,23 @@ function getDb() {
 }
 var _db = null;
 var init_client = __esm(() => {
-  init_bun_sqlite();
   init_paths();
   init_schema();
 });
 
-// node_modules/.pnpm/nanoid@5.1.7/node_modules/nanoid/url-alphabet/index.js
-var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-
-// node_modules/.pnpm/nanoid@5.1.7/node_modules/nanoid/index.js
-import { webcrypto as crypto2 } from "crypto";
-function fillPool(bytes) {
-  if (!pool || pool.length < bytes) {
-    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
-    crypto2.getRandomValues(pool);
-    poolOffset = 0;
-  } else if (poolOffset + bytes > pool.length) {
-    crypto2.getRandomValues(pool);
-    poolOffset = 0;
-  }
-  poolOffset += bytes;
-}
-function nanoid(size = 21) {
-  fillPool(size |= 0);
-  let id = "";
-  for (let i = poolOffset - size;i < poolOffset; i++) {
-    id += urlAlphabet[pool[i] & 63];
-  }
-  return id;
-}
-var POOL_SIZE_MULTIPLIER = 128, pool, poolOffset;
-var init_nanoid = () => {};
-
 // src/lib/id.ts
+import { nanoid } from "nanoid";
 function createId(size = 12) {
   return nanoid(size);
 }
-var init_id = __esm(() => {
-  init_nanoid();
-});
+var init_id = () => {};
 
 // src/db/queries/sessions.ts
+import { eq, and, inArray, sql as sql2 } from "drizzle-orm";
 function createSession(opts) {
-  const db2 = getDb();
+  const db = getDb();
   const id = createId();
-  return db2.insert(sessions).values({ id, ...opts }).returning().get();
+  return db.insert(sessions).values({ id, ...opts }).returning().get();
 }
 function getSession(id) {
   return getDb().select().from(sessions).where(eq(sessions.id, id)).get();
@@ -4580,8 +267,8 @@ function getActiveSessions() {
   return getDb().select({ session: sessions, groupPath: groups.path }).from(sessions).innerJoin(groups, eq(sessions.groupId, groups.id)).where(inArray(sessions.status, ["active", "waiting"])).all();
 }
 function getAllSessions(opts) {
-  const db2 = getDb();
-  const query = db2.select({ session: sessions, groupPath: groups.path }).from(sessions).innerJoin(groups, eq(sessions.groupId, groups.id));
+  const db = getDb();
+  const query = db.select({ session: sessions, groupPath: groups.path }).from(sessions).innerJoin(groups, eq(sessions.groupId, groups.id));
   if (opts?.excludeArchived) {
     return query.where(inArray(sessions.status, [
       "active",
@@ -4592,16 +279,15 @@ function getAllSessions(opts) {
   return query.all();
 }
 function updateSessionStatus(id, status) {
-  return getDb().update(sessions).set({ status, updatedAt: sql`(datetime('now'))` }).where(eq(sessions.id, id)).returning().get();
+  return getDb().update(sessions).set({ status, updatedAt: sql2`(datetime('now'))` }).where(eq(sessions.id, id)).returning().get();
 }
 function updateSession(id, data) {
-  return getDb().update(sessions).set({ ...data, updatedAt: sql`(datetime('now'))` }).where(eq(sessions.id, id)).returning().get();
+  return getDb().update(sessions).set({ ...data, updatedAt: sql2`(datetime('now'))` }).where(eq(sessions.id, id)).returning().get();
 }
 function deleteSession(id) {
   return getDb().delete(sessions).where(eq(sessions.id, id)).run();
 }
 var init_sessions = __esm(() => {
-  init_drizzle_orm();
   init_client();
   init_schema();
   init_id();
@@ -4656,6 +342,7 @@ function normalizeAnsweredMeta(meta) {
 }
 
 // src/db/queries/events.ts
+import { eq as eq2, and as and2, desc } from "drizzle-orm";
 function insertEvent(opts) {
   return getDb().insert(events).values({
     sessionId: opts.sessionId,
@@ -4666,35 +353,34 @@ function insertEvent(opts) {
   }).returning().get();
 }
 function getEventsBySession(sessionId) {
-  return getDb().select().from(events).where(eq(events.sessionId, sessionId)).orderBy(events.createdAt, events.id).all();
+  return getDb().select().from(events).where(eq2(events.sessionId, sessionId)).orderBy(events.createdAt, events.id).all();
 }
 function getEventsByType(sessionId, eventType) {
-  return getDb().select().from(events).where(and(eq(events.sessionId, sessionId), eq(events.event, eventType))).orderBy(events.createdAt).all();
+  return getDb().select().from(events).where(and2(eq2(events.sessionId, sessionId), eq2(events.event, eventType))).orderBy(events.createdAt).all();
 }
 var init_events = __esm(() => {
-  init_drizzle_orm();
   init_client();
   init_schema();
 });
 
 // src/db/queries/conversations.ts
+import { eq as eq3, and as and3, desc as desc2, sql as sql3 } from "drizzle-orm";
 function createConversation(opts) {
   return getDb().insert(conversations).values(opts).returning().get();
 }
 function getConversation(id) {
-  return getDb().select().from(conversations).where(eq(conversations.id, id)).get();
+  return getDb().select().from(conversations).where(eq3(conversations.id, id)).get();
 }
 function getConversationsBySession(sessionId) {
-  return getDb().select().from(conversations).where(and(eq(conversations.sessionId, sessionId), eq(conversations.discarded, false))).orderBy(desc(conversations.startedAt)).all();
+  return getDb().select().from(conversations).where(and3(eq3(conversations.sessionId, sessionId), eq3(conversations.discarded, false))).orderBy(desc2(conversations.startedAt)).all();
 }
 function endConversation(id) {
-  return getDb().update(conversations).set({ endedAt: sql`(datetime('now'))` }).where(eq(conversations.id, id)).returning().get();
+  return getDb().update(conversations).set({ endedAt: sql3`(datetime('now'))` }).where(eq3(conversations.id, id)).returning().get();
 }
 function updateLastQuestion(id, question) {
-  return getDb().update(conversations).set({ lastQuestion: question }).where(eq(conversations.id, id)).returning().get();
+  return getDb().update(conversations).set({ lastQuestion: question }).where(eq3(conversations.id, id)).returning().get();
 }
 var init_conversations = __esm(() => {
-  init_drizzle_orm();
   init_client();
   init_schema();
 });
@@ -4702,7 +388,7 @@ var init_conversations = __esm(() => {
 // src/cli/commands/update.ts
 var exports_update = {};
 var EVENT_STATUS_MAP;
-var init_update2 = __esm(() => {
+var init_update = __esm(() => {
   init_router();
   init_sessions();
   init_events();
@@ -4741,13 +427,13 @@ var init_update2 = __esm(() => {
       console.error("Usage: bertrand update --session-id <id> --event <type> [--meta <json>]");
       process.exit(1);
     }
-    const session3 = getSession(sessionId);
-    if (!session3) {
+    const session = getSession(sessionId);
+    if (!session) {
       console.error(`Session not found: ${sessionId}`);
       process.exit(1);
     }
     const newStatus = EVENT_STATUS_MAP[event];
-    if (newStatus && newStatus === session3.status) {
+    if (newStatus && newStatus === session.status) {
       return;
     }
     let meta;
@@ -4791,8 +477,8 @@ function getContextWindowSize(model) {
 function getLatestAssistantTurn(filePath) {
   if (!existsSync2(filePath))
     return null;
-  const text3 = readFileSync(filePath, "utf-8");
-  const lines = text3.split(`
+  const text2 = readFileSync(filePath, "utf-8");
+  const lines = text2.split(`
 `);
   const assistantEntries = [];
   for (let i = lines.length - 1;i >= 0; i--) {
@@ -4851,8 +537,8 @@ function getLatestAssistantTurn(filePath) {
 function getContextSnapshot(filePath) {
   if (!existsSync2(filePath))
     return null;
-  const text3 = readFileSync(filePath, "utf-8");
-  const lines = text3.split(`
+  const text2 = readFileSync(filePath, "utf-8");
+  const lines = text2.split(`
 `);
   for (let i = lines.length - 1;i >= 0; i--) {
     const line = lines[i];
@@ -4929,8 +615,8 @@ var init_snapshot = __esm(() => {
       console.error("Usage: bertrand snapshot --session-id <id> --transcript-path <path> [--conversation-id <id>]");
       process.exit(1);
     }
-    const session3 = getSession(sessionId);
-    if (!session3) {
+    const session = getSession(sessionId);
+    if (!session) {
       console.error(`Session not found: ${sessionId}`);
       process.exit(1);
     }
@@ -4958,8 +644,8 @@ var init_snapshot = __esm(() => {
 
 // src/cli/commands/assistant-message.ts
 var exports_assistant_message = {};
-function summarize(text3) {
-  const firstLine = text3.split(`
+function summarize(text2) {
+  const firstLine = text2.split(`
 `).find((l) => l.trim()) ?? "";
   const trimmed = firstLine.trim();
   return trimmed.length > 80 ? `${trimmed.slice(0, 77)}...` : trimmed;
@@ -4992,8 +678,8 @@ var init_assistant_message = __esm(() => {
       console.error("Usage: bertrand assistant-message --session-id <id> --transcript-path <path> [--conversation-id <id>]");
       process.exit(1);
     }
-    const session3 = getSession(sessionId);
-    if (!session3) {
+    const session = getSession(sessionId);
+    if (!session) {
       console.error(`Session not found: ${sessionId}`);
       process.exit(1);
     }
@@ -5134,21 +820,21 @@ var init_notify = __esm(() => {
 });
 
 // src/db/queries/stats.ts
+import { eq as eq4, sql as sql4 } from "drizzle-orm";
 function getSessionStats(sessionId) {
-  return getDb().select().from(sessionStats).where(eq(sessionStats.sessionId, sessionId)).get();
+  return getDb().select().from(sessionStats).where(eq4(sessionStats.sessionId, sessionId)).get();
 }
 function upsertSessionStats(sessionId, data) {
   return getDb().insert(sessionStats).values({
     sessionId,
     ...data,
-    updatedAt: sql`(datetime('now'))`
+    updatedAt: sql4`(datetime('now'))`
   }).onConflictDoUpdate({
     target: sessionStats.sessionId,
-    set: { ...data, updatedAt: sql`(datetime('now'))` }
+    set: { ...data, updatedAt: sql4`(datetime('now'))` }
   }).returning().get();
 }
 var init_stats = __esm(() => {
-  init_drizzle_orm();
   init_client();
   init_schema();
 });
@@ -5311,6 +997,7 @@ var init_timing = __esm(() => {
 });
 
 // src/lib/engagement_stats.ts
+import { eq as eq5, sql as sql5 } from "drizzle-orm";
 function aggregateToolUsage(sessionId) {
   const counts = {};
   const applied = getEventsByType(sessionId, "tool.applied");
@@ -5369,9 +1056,9 @@ function permissionDenialCount(sessionId) {
 }
 function discardRate(sessionId) {
   const row = getDb().select({
-    total: sql`count(*)`,
-    discarded: sql`sum(case when ${conversations.discarded} then 1 else 0 end)`
-  }).from(conversations).where(eq(conversations.sessionId, sessionId)).get();
+    total: sql5`count(*)`,
+    discarded: sql5`sum(case when ${conversations.discarded} then 1 else 0 end)`
+  }).from(conversations).where(eq5(conversations.sessionId, sessionId)).get();
   return {
     total: row?.total ?? 0,
     discarded: row?.discarded ?? 0
@@ -5386,7 +1073,6 @@ function computeEngagementStats(sessionId) {
   };
 }
 var init_engagement_stats = __esm(() => {
-  init_drizzle_orm();
   init_client();
   init_schema();
   init_events();
@@ -5454,10 +1140,10 @@ var init_server = __esm(() => {
       return getEventsBySession(sessionId);
     }],
     [/^\/api\/stats\/(?<sessionId>[^/]+)$/, ({ sessionId }) => {
-      const session3 = getSession(sessionId);
-      if (!session3)
+      const session = getSession(sessionId);
+      if (!session)
         return null;
-      const isLive = session3.status === "active" || session3.status === "waiting";
+      const isLive = session.status === "active" || session.status === "waiting";
       if (isLive) {
         return { sessionId, ...computeSessionStats(sessionId), updatedAt: new Date().toISOString() };
       }
@@ -5484,25 +1170,26 @@ var init_serve = __esm(() => {
 });
 
 // src/db/queries/groups.ts
+import { eq as eq6, like, or, isNull } from "drizzle-orm";
 function createGroup(opts) {
-  const db2 = getDb();
+  const db = getDb();
   const id = createId();
   let path = opts.slug;
   let depth = 0;
   if (opts.parentId) {
-    const parent = db2.select().from(groups).where(eq(groups.id, opts.parentId)).get();
+    const parent = db.select().from(groups).where(eq6(groups.id, opts.parentId)).get();
     if (!parent)
       throw new Error(`Parent group ${opts.parentId} not found`);
     path = `${parent.path}/${opts.slug}`;
     depth = parent.depth + 1;
   }
-  return db2.insert(groups).values({ id, slug: opts.slug, name: opts.name, parentId: opts.parentId, path, depth }).returning().get();
+  return db.insert(groups).values({ id, slug: opts.slug, name: opts.name, parentId: opts.parentId, path, depth }).returning().get();
 }
 function getGroup(id) {
-  return getDb().select().from(groups).where(eq(groups.id, id)).get();
+  return getDb().select().from(groups).where(eq6(groups.id, id)).get();
 }
 function getGroupByPath(path) {
-  return getDb().select().from(groups).where(eq(groups.path, path)).get();
+  return getDb().select().from(groups).where(eq6(groups.path, path)).get();
 }
 function getOrCreateGroupPath(path) {
   const existing = getGroupByPath(path);
@@ -5524,7 +1211,6 @@ function getOrCreateGroupPath(path) {
   return parentId;
 }
 var init_groups = __esm(() => {
-  init_drizzle_orm();
   init_client();
   init_schema();
   init_id();
@@ -5589,10 +1275,10 @@ function formatAgo(isoOrDate) {
     return `${Math.floor(ms / DAY)}d ago`;
   return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
 }
-function truncate(text3, maxLen) {
-  if (text3.length <= maxLen)
-    return text3;
-  return text3.slice(0, maxLen - 1) + "\u2026";
+function truncate(text2, maxLen) {
+  if (text2.length <= maxLen)
+    return text2;
+  return text2.slice(0, maxLen - 1) + "\u2026";
 }
 function formatTime(iso, includeDate = false) {
   const date = new Date(iso);
@@ -5694,7 +1380,7 @@ async function launch(opts) {
     }
   }
   const groupId = getOrCreateGroupPath(opts.groupPath);
-  const session3 = createSession({
+  const session = createSession({
     groupId,
     slug: opts.slug,
     name: opts.name ?? opts.slug
@@ -5702,58 +1388,58 @@ async function launch(opts) {
   const claudeId = randomUUID();
   const conversation = createConversation({
     id: claudeId,
-    sessionId: session3.id
+    sessionId: session.id
   });
-  updateSession(session3.id, { status: "active", pid: process.pid });
+  updateSession(session.id, { status: "active", pid: process.pid });
   insertEvent({
-    sessionId: session3.id,
+    sessionId: session.id,
     conversationId: claudeId,
     event: "session.started"
   });
   insertEvent({
-    sessionId: session3.id,
+    sessionId: session.id,
     conversationId: claudeId,
     event: "claude.started",
     meta: { claude_id: claudeId }
   });
   const sessionName = `${opts.groupPath}/${opts.slug}`;
-  const siblingContext = buildSiblingContext(groupId, session3.id);
+  const siblingContext = buildSiblingContext(groupId, session.id);
   const contract = buildContract(sessionName, siblingContext);
   const exitCode = await launchClaude({
-    sessionId: session3.id,
+    sessionId: session.id,
     claudeId,
     sessionName,
     sessionSlug: opts.slug,
     contract
   });
-  finalizeSession(session3.id, claudeId, exitCode);
-  return session3.id;
+  finalizeSession(session.id, claudeId, exitCode);
+  return session.id;
 }
 async function resume(opts) {
-  const session3 = getSession(opts.sessionId);
-  if (!session3)
+  const session = getSession(opts.sessionId);
+  if (!session)
     throw new Error(`Session not found: ${opts.sessionId}`);
-  const group = getGroup(session3.groupId);
-  const sessionName = group ? `${group.path}/${session3.slug}` : session3.name;
-  updateSession(session3.id, { status: "active", pid: process.pid });
+  const group = getGroup(session.groupId);
+  const sessionName = group ? `${group.path}/${session.slug}` : session.name;
+  updateSession(session.id, { status: "active", pid: process.pid });
   insertEvent({
-    sessionId: session3.id,
+    sessionId: session.id,
     conversationId: opts.conversationId,
     event: "session.resumed",
     meta: { claude_id: opts.conversationId }
   });
-  const siblingContext = buildSiblingContext(session3.groupId, session3.id);
+  const siblingContext = buildSiblingContext(session.groupId, session.id);
   const contract = buildContract(sessionName, siblingContext);
   const exitCode = await launchClaude({
-    sessionId: session3.id,
+    sessionId: session.id,
     claudeId: opts.conversationId,
     sessionName,
-    sessionSlug: session3.slug,
+    sessionSlug: session.slug,
     contract,
     resume: true
   });
-  finalizeSession(session3.id, opts.conversationId, exitCode);
-  return session3.id;
+  finalizeSession(session.id, opts.conversationId, exitCode);
+  return session.id;
 }
 function finalizeSession(sessionId, conversationId, exitCode) {
   if (!getSession(sessionId))
@@ -5780,7 +1466,7 @@ function finalizeSession(sessionId, conversationId, exitCode) {
   });
   computeAndPersist(sessionId);
 }
-var init_session3 = __esm(() => {
+var init_session = __esm(() => {
   init_sessions();
   init_conversations();
   init_events();
@@ -5894,7 +1580,7 @@ var SCREEN_ENTRY;
 var init_app = __esm(() => {
   init_sessions();
   init_conversations();
-  init_session3();
+  init_session();
   SCREEN_ENTRY = (() => {
     const built = join3(import.meta.dir, "run-screen.js");
     return existsSync3(built) ? built : join3(import.meta.dir, "run-screen.tsx");
@@ -5933,17 +1619,17 @@ function isProcessAlive(pid) {
 function recoverStaleSessions() {
   const active = getActiveSessions();
   let recovered = 0;
-  for (const { session: session3 } of active) {
-    if (session3.pid && !isProcessAlive(session3.pid)) {
-      updateSession(session3.id, {
+  for (const { session } of active) {
+    if (session.pid && !isProcessAlive(session.pid)) {
+      updateSession(session.id, {
         status: "paused",
         pid: null
       });
       insertEvent({
-        sessionId: session3.id,
+        sessionId: session.id,
         event: "session.paused",
         summary: "Recovered from stale state (process not found)",
-        meta: { stale_pid: session3.pid }
+        meta: { stale_pid: session.pid }
       });
       recovered++;
     }
@@ -5960,7 +1646,7 @@ var exports_launch = {};
 var init_launch = __esm(() => {
   init_router();
   init_app();
-  init_session3();
+  init_session();
   init_recovery();
   register("launch", async (args) => {
     recoverStaleSessions();
@@ -5975,65 +1661,23 @@ var init_launch = __esm(() => {
   });
 });
 
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/migrator.js
-import crypto3 from "crypto";
-import fs from "fs";
-function readMigrationFiles(config) {
-  const migrationFolderTo = config.migrationsFolder;
-  const migrationQueries = [];
-  const journalPath = `${migrationFolderTo}/meta/_journal.json`;
-  if (!fs.existsSync(journalPath)) {
-    throw new Error(`Can't find meta/_journal.json file`);
-  }
-  const journalAsString = fs.readFileSync(`${migrationFolderTo}/meta/_journal.json`).toString();
-  const journal = JSON.parse(journalAsString);
-  for (const journalEntry of journal.entries) {
-    const migrationPath = `${migrationFolderTo}/${journalEntry.tag}.sql`;
-    try {
-      const query = fs.readFileSync(`${migrationFolderTo}/${journalEntry.tag}.sql`).toString();
-      const result = query.split("--> statement-breakpoint").map((it) => {
-        return it;
-      });
-      migrationQueries.push({
-        sql: result,
-        bps: journalEntry.breakpoints,
-        folderMillis: journalEntry.when,
-        hash: crypto3.createHash("sha256").update(query).digest("hex")
-      });
-    } catch {
-      throw new Error(`No file ${migrationPath} found in ${migrationFolderTo} folder`);
-    }
-  }
-  return migrationQueries;
-}
-var init_migrator = () => {};
-
-// node_modules/.pnpm/drizzle-orm@0.44.7_bun-types@1.3.11/node_modules/drizzle-orm/bun-sqlite/migrator.js
-function migrate(db2, config) {
-  const migrations = readMigrationFiles(config);
-  db2.dialect.migrate(migrations, db2.session, config);
-}
-var init_migrator2 = __esm(() => {
-  init_migrator();
-});
-
 // src/db/migrate.ts
-import { Database as Database3 } from "bun:sqlite";
+import { Database as Database2 } from "bun:sqlite";
+import { drizzle as drizzle2 } from "drizzle-orm/bun-sqlite";
+import { migrate } from "drizzle-orm/bun-sqlite/migrator";
 import { mkdirSync as mkdirSync2 } from "fs";
 import { dirname as dirname2 } from "path";
 function runMigrations() {
   mkdirSync2(dirname2(paths.db), { recursive: true });
-  const sqlite = new Database3(paths.db);
+  const sqlite = new Database2(paths.db);
   sqlite.exec("PRAGMA journal_mode = WAL");
   sqlite.exec("PRAGMA foreign_keys = ON");
-  const db2 = drizzle(sqlite);
-  migrate(db2, { migrationsFolder: MIGRATIONS_FOLDER });
+  const db = drizzle2(sqlite);
+  migrate(db, { migrationsFolder: MIGRATIONS_FOLDER });
   sqlite.close();
 }
 var MIGRATIONS_FOLDER;
 var init_migrate = __esm(() => {
-  init_bun_sqlite();
-  init_migrator2();
   init_paths();
   MIGRATIONS_FOLDER = import.meta.dir + "/migrations";
   if (false) {}
@@ -6837,11 +2481,11 @@ var init_compact = __esm(() => {
 
 // src/cli/commands/log.ts
 var exports_log = {};
-function ansi(code, text3) {
-  return `\x1B[${code}m${text3}${RESET}`;
+function ansi(code, text2) {
+  return `\x1B[${code}m${text2}${RESET}`;
 }
-function ansi256(code, text3) {
-  return `\x1B[38;5;${code}m${text3}${RESET}`;
+function ansi256(code, text2) {
+  return `\x1B[38;5;${code}m${text2}${RESET}`;
 }
 function showAllSessions() {
   const rows = getAllSessions().sort((a, b) => new Date(b.session.updatedAt).getTime() - new Date(a.session.updatedAt).getTime());
@@ -7029,12 +2673,12 @@ var init_log = __esm(() => {
       console.error(`Group not found: ${groupPath}`);
       process.exit(1);
     }
-    const session3 = getSessionByGroupSlug(group.id, slug);
-    if (!session3) {
+    const session = getSessionByGroupSlug(group.id, slug);
+    if (!session) {
       console.error(`Session not found: ${target}`);
       process.exit(1);
     }
-    showSessionLog(session3.id, `${groupPath}/${slug}`, isJson);
+    showSessionLog(session.id, `${groupPath}/${slug}`, isJson);
   });
 });
 
@@ -7191,12 +2835,12 @@ var init_stats2 = __esm(() => {
       console.error(`Group not found: ${groupPath}`);
       process.exit(1);
     }
-    const session3 = getSessionByGroupSlug(group.id, slug);
-    if (!session3) {
+    const session = getSessionByGroupSlug(group.id, slug);
+    if (!session) {
       console.error(`Session not found: ${target}`);
       process.exit(1);
     }
-    const m = getMetrics(session3.id, `${groupPath}/${slug}`, session3.status);
+    const m = getMetrics(session.id, `${groupPath}/${slug}`, session.status);
     renderSession(m, isJson);
   });
 });
@@ -7211,9 +2855,9 @@ var init_backfill_stats = __esm(() => {
     const includeArchived = args.includes("--include-archived");
     const rows = getAllSessions({ excludeArchived: !includeArchived });
     console.log(`Backfilling stats for ${rows.length} session(s)${includeArchived ? "" : " (excluding archived)"}...`);
-    for (const { session: session3, groupPath } of rows) {
-      computeAndPersist(session3.id);
-      console.log(`  \u2713 ${groupPath}/${session3.slug}`);
+    for (const { session, groupPath } of rows) {
+      computeAndPersist(session.id);
+      console.log(`  \u2713 ${groupPath}/${session.slug}`);
     }
     console.log("Done.");
   });
@@ -7228,12 +2872,12 @@ function resolveSession(name) {
     console.error(`Group not found: ${groupPath}`);
     process.exit(1);
   }
-  const session3 = getSessionByGroupSlug(group.id, slug);
-  if (!session3) {
+  const session = getSessionByGroupSlug(group.id, slug);
+  if (!session) {
     console.error(`Session not found: ${name}`);
     process.exit(1);
   }
-  return { session: session3, groupPath };
+  return { session, groupPath };
 }
 var ACTIVE_STATUSES2;
 var init_archive = __esm(() => {
@@ -7269,26 +2913,26 @@ Archived ${archived} session${archived === 1 ? "" : "s"}.`);
       console.error("       bertrand archive --all-paused");
       process.exit(1);
     }
-    const { session: session3, groupPath } = resolveSession(sessionName);
-    const fullName = `${groupPath}/${session3.slug}`;
+    const { session, groupPath } = resolveSession(sessionName);
+    const fullName = `${groupPath}/${session.slug}`;
     if (isUndo) {
-      if (session3.status !== "archived") {
-        console.error(`${fullName} is not archived (status: ${session3.status})`);
+      if (session.status !== "archived") {
+        console.error(`${fullName} is not archived (status: ${session.status})`);
         process.exit(1);
       }
-      updateSessionStatus(session3.id, "paused");
+      updateSessionStatus(session.id, "paused");
       console.log(`Unarchived ${fullName}`);
       return;
     }
-    if (ACTIVE_STATUSES2.includes(session3.status)) {
-      console.error(`Cannot archive active session ${fullName} (status: ${session3.status})`);
+    if (ACTIVE_STATUSES2.includes(session.status)) {
+      console.error(`Cannot archive active session ${fullName} (status: ${session.status})`);
       process.exit(1);
     }
-    if (session3.status === "archived") {
+    if (session.status === "archived") {
       console.error(`${fullName} is already archived`);
       process.exit(1);
     }
-    updateSessionStatus(session3.id, "archived");
+    updateSessionStatus(session.id, "archived");
     console.log(`Archived ${fullName}`);
   });
 });
@@ -7297,7 +2941,7 @@ Archived ${archived} session${archived === 1 ? "" : "s"}.`);
 init_router();
 var command = process.argv[2];
 var hotPath = {
-  update: () => Promise.resolve().then(() => (init_update2(), exports_update)),
+  update: () => Promise.resolve().then(() => (init_update(), exports_update)),
   snapshot: () => Promise.resolve().then(() => (init_snapshot(), exports_snapshot)),
   "assistant-message": () => Promise.resolve().then(() => (init_assistant_message(), exports_assistant_message)),
   badge: () => Promise.resolve().then(() => (init_badge(), exports_badge)),
@@ -7315,7 +2959,7 @@ if (command && command in hotPath) {
     Promise.resolve().then(() => (init_stats2(), exports_stats)),
     Promise.resolve().then(() => (init_backfill_stats(), exports_backfill_stats)),
     Promise.resolve().then(() => (init_archive(), exports_archive)),
-    Promise.resolve().then(() => (init_update2(), exports_update)),
+    Promise.resolve().then(() => (init_update(), exports_update)),
     Promise.resolve().then(() => (init_snapshot(), exports_snapshot)),
     Promise.resolve().then(() => (init_assistant_message(), exports_assistant_message)),
     Promise.resolve().then(() => (init_serve(), exports_serve)),