@leemour/cli-messaging 0.59.0 → 0.60.0

package/dist/store/sqlite/drizzle/shared-ZF3LACGD.js

@@ -0,0 +1,4830 @@
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/entity.js
+var entityKind = Symbol.for("drizzle:entityKind");
+var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
+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;
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/column-common.js
+var OriginalColumn = Symbol.for("drizzle:OriginalColumn");
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/column.js
+var noop = (v) => v;
+noop.isNoop = true;
+var Column = class {
+  static [entityKind] = "Column";
+  /** @internal */
+  codec;
+  name;
+  keyAsName;
+  primary;
+  notNull;
+  default;
+  defaultFn;
+  onUpdateFn;
+  hasDefault;
+  isUnique;
+  uniqueName;
+  uniqueType;
+  dataType;
+  columnType;
+  enumValues = void 0;
+  generated = void 0;
+  generatedIdentity = void 0;
+  length;
+  isLengthExact;
+  isAlias;
+  /** @internal */
+  config;
+  /** @internal */
+  table;
+  /** @internal */
+  onInit() {
+  }
+  constructor(table, config) {
+    this.config = config;
+    this.onInit();
+    this.table = table;
+    this.name = config.name;
+    this.isAlias = false;
+    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;
+    this.length = config["length"];
+    this.isLengthExact = config["isLengthExact"];
+  }
+  mapFromDriverValue = noop;
+  mapToDriverValue = noop;
+  /** @internal */
+  postBuild() {
+    return this;
+  }
+  /** @internal */
+  shouldDisableInsert() {
+    return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
+  }
+  /** @internal */
+  [OriginalColumn]() {
+    return this;
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/table.utils.js
+var TableName = Symbol.for("drizzle:Name");
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/table.js
+var TableSchema = Symbol.for("drizzle:Schema");
+var TableColumns = Symbol.for("drizzle:Columns");
+var ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
+var OriginalName = Symbol.for("drizzle:OriginalName");
+var BaseName = Symbol.for("drizzle:BaseName");
+var IsAlias = Symbol.for("drizzle:IsAlias");
+var ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
+var IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
+var Table = class {
+  static [entityKind] = "Table";
+  /** @internal */
+  static Symbol = {
+    Name: TableName,
+    Schema: TableSchema,
+    OriginalName,
+    Columns: TableColumns,
+    ExtraConfigColumns,
+    BaseName,
+    IsAlias,
+    ExtraConfigBuilder
+  };
+  /**
+  * @internal
+  * Can be changed if the table is aliased.
+  */
+  [TableName];
+  /**
+  * @internal
+  * Used to store the original name of the table, before any aliasing.
+  */
+  [OriginalName];
+  /** @internal */
+  [TableSchema];
+  /** @internal */
+  [TableColumns];
+  /** @internal */
+  [ExtraConfigColumns];
+  /**
+  *  @internal
+  * Used to store the table name before the transformation via the `tableCreator` functions.
+  */
+  [BaseName];
+  /** @internal */
+  [IsAlias] = false;
+  /** @internal */
+  [IsDrizzleTable] = true;
+  /** @internal */
+  [ExtraConfigBuilder] = void 0;
+  constructor(name2, schema, baseName) {
+    this[TableName] = this[OriginalName] = name2;
+    this[TableSchema] = schema;
+    this[BaseName] = baseName;
+  }
+};
+function getTableName(table) {
+  return table[TableName];
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/subquery.js
+var Subquery = class {
+  static [entityKind] = "Subquery";
+  constructor(sql2, fields, alias, isWith = false, usedTables = []) {
+    this._ = {
+      brand: "Subquery",
+      sql: sql2,
+      selectedFields: fields,
+      alias,
+      isWith,
+      usedTables
+    };
+  }
+};
+var WithSubquery = class extends Subquery {
+  static [entityKind] = "WithSubquery";
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/tracing.js
+var tracer = { startActiveSpan(name2, fn) {
+  return fn();
+} };
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/view-common.js
+var ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sql/sql.js
+var FakePrimitiveParam = class {
+  static [entityKind] = "FakePrimitiveParam";
+};
+function isSQLWrapper(value) {
+  return value !== null && value !== void 0 && 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);
+  }
+  return result;
+}
+function _mergeQueries(queries) {
+  const result = {
+    sql: "",
+    params: []
+  };
+  const sqls = [];
+  for (const query of queries) {
+    sqls.push(query.sql);
+    result.params.push(...query.params);
+  }
+  result._sql = Object.assign(sqls, { raw: sqls });
+  return result;
+}
+var StringChunk = class {
+  static [entityKind] = "StringChunk";
+  value;
+  constructor(value) {
+    this.value = Array.isArray(value) ? value : [value];
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var SQL = class SQL2 {
+  static [entityKind] = "SQL";
+  /** @internal */
+  decoder = noopDecoder;
+  /** @internal */
+  shouldInlineParams = false;
+  /** @internal */
+  usedTables = [];
+  constructor(queryChunks) {
+    this.queryChunks = queryChunks;
+    for (const chunk of queryChunks) if (is(chunk, Table)) {
+      const schemaName = chunk[Table.Symbol.Schema];
+      this.usedTables.push(schemaName === void 0 ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
+    }
+  }
+  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 { escapeName, escapeParam, codecs, inlineParams, paramStartIndex, invokeSource } = config;
+    const mappedChunks = 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 === void 0) 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, SQL2)) 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];
+        if (invokeSource === "mssql-view-with-schemabinding") return {
+          sql: (schemaName === void 0 ? escapeName("dbo") : escapeName(schemaName)) + "." + escapeName(tableName),
+          params: []
+        };
+        return {
+          sql: schemaName === void 0 || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+          params: []
+        };
+      }
+      if (is(chunk, Column)) {
+        const columnName = chunk.name;
+        if (_config.invokeSource === "indexes") return {
+          sql: escapeName(columnName),
+          params: []
+        };
+        const schemaName = invokeSource === "mssql-check" ? void 0 : chunk.table[Table.Symbol.Schema];
+        return {
+          sql: chunk.isAlias ? escapeName(chunk.name) : chunk.table[IsAlias] || schemaName === void 0 ? 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 === void 0 || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+          params: []
+        };
+      }
+      if (is(chunk, Param)) {
+        if (is(chunk.value, SQL2)) return this.buildQueryFromSourceParams([chunk.value], config);
+        const useCodecs = codecs && is(chunk.encoder, Column);
+        if (is(chunk.value, Placeholder)) {
+          const escaped2 = escapeParam(paramStartIndex.value++, chunk);
+          chunk.codec = useCodecs ? (value) => codecs.apply(chunk.encoder, "normalizeParam", value) : void 0;
+          return {
+            sql: useCodecs ? codecs.apply(chunk.encoder, "castParam", escaped2) : escaped2,
+            params: [chunk]
+          };
+        }
+        let mappedValue;
+        if (chunk.value === null) mappedValue = chunk.value;
+        else {
+          mappedValue = chunk.encoder.mapToDriverValue.isNoop ? chunk.value : chunk.encoder.mapToDriverValue(chunk.value);
+          if (is(mappedValue, SQL2)) return this.buildQueryFromSourceParams([mappedValue], config);
+          if (useCodecs) mappedValue = codecs.apply(chunk.encoder, "normalizeParam", mappedValue);
+        }
+        if (inlineParams) return {
+          sql: this.mapInlineParam(mappedValue, config),
+          params: []
+        };
+        const escaped = escapeParam(paramStartIndex.value++, mappedValue);
+        return {
+          sql: useCodecs ? codecs.apply(chunk.encoder, "castParam", escaped) : escaped,
+          params: [mappedValue]
+        };
+      }
+      if (is(chunk, Placeholder)) return {
+        sql: escapeParam(paramStartIndex.value++, chunk),
+        params: [chunk]
+      };
+      if (is(chunk, SQL2.Aliased) && chunk.fieldAlias !== void 0) return {
+        sql: (chunk.origin !== void 0 ? escapeName(chunk.origin) + "." : "") + 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 (typeof chunk === "function" && "enumName" in chunk) {
+        if ("schema" in chunk && 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]
+      };
+    });
+    if (_config.tagged) return _mergeQueries(mappedChunks);
+    return mergeQueries(mappedChunks);
+  }
+  mapInlineParam(chunk, { escapeString }) {
+    if (chunk === null) return "null";
+    if (typeof chunk === "number" || typeof chunk === "boolean" || typeof chunk === "bigint") 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(alias) {
+    if (alias === void 0) return this;
+    return new SQL2.Aliased(this, alias);
+  }
+  mapWith(decoder) {
+    this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
+    return this;
+  }
+  nullable() {
+    return this;
+  }
+  inlineParams() {
+    this.shouldInlineParams = true;
+    return this;
+  }
+  /**
+  * This method is used to conditionally include a part of the query.
+  *
+  * @param condition - Condition to check
+  * @returns itself if the condition is `true`, otherwise `undefined`
+  */
+  if(condition) {
+    return condition ? this : void 0;
+  }
+};
+var Name = class {
+  static [entityKind] = "Name";
+  brand;
+  constructor(value) {
+    this.value = value;
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+function isDriverValueEncoder(value) {
+  return typeof value === "object" && value !== null && "mapToDriverValue" in value && typeof value.mapToDriverValue === "function";
+}
+var noopDecoder = { mapFromDriverValue: (value) => value };
+noopDecoder.mapFromDriverValue.isNoop = true;
+var noopEncoder = { mapToDriverValue: (value) => value };
+noopEncoder.mapToDriverValue.isNoop = true;
+var noopMapper = {
+  ...noopDecoder,
+  ...noopEncoder
+};
+var Param = class {
+  static [entityKind] = "Param";
+  brand;
+  /**
+  * @param value - Parameter value
+  * @param encoder - Encoder to convert the value to a driver parameter
+  */
+  constructor(value, encoder = noopEncoder, codec) {
+    this.value = value;
+    this.encoder = encoder;
+    this.codec = codec;
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+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(_sql) {
+  function empty() {
+    return new SQL([]);
+  }
+  _sql.empty = empty;
+  function fromList(list) {
+    return new SQL(list);
+  }
+  _sql.fromList = fromList;
+  function raw(str) {
+    return new SQL([new StringChunk(str)]);
+  }
+  _sql.raw = raw;
+  function join(chunks, separator) {
+    const result = [];
+    for (const [i, chunk] of chunks.entries()) {
+      if (i > 0 && separator !== void 0) result.push(separator);
+      result.push(chunk);
+    }
+    return new SQL(result);
+  }
+  _sql.join = join;
+  function identifier(value) {
+    return new Name(value);
+  }
+  _sql.identifier = identifier;
+  function placeholder2(name2) {
+    return new Placeholder(name2);
+  }
+  _sql.placeholder = placeholder2;
+  function param2(value, encoder) {
+    return new Param(value, encoder);
+  }
+  _sql.param = param2;
+  function comment(input) {
+    const encoded = sqlCommenter(input);
+    if (!encoded.length) return void 0;
+    return sql.raw(encoded);
+  }
+  _sql.comment = comment;
+})(sql || (sql = {}));
+function sqlCommenter(input) {
+  const encoded = sqlCommenter.encodeInput(input);
+  if (!encoded.length) return "";
+  return `/*${encoded}*/`;
+}
+(function(_sqlCommenter) {
+  function merge(input1, input2) {
+    let encoded;
+    if (typeof input1 === "object" && typeof input2 === "object") encoded = encodeInput({
+      ...input1,
+      ...input2
+    });
+    else if (input1 && input2) encoded = [encodeInput(input1), encodeInput(input2)].filter((i) => i.length).join(",");
+    else if (input2) encoded = encodeInput(input2);
+    else if (input1) encoded = encodeInput(input1);
+    else return "";
+    if (!encoded.length) return "";
+    return `/*${encoded}*/`;
+  }
+  _sqlCommenter.merge = merge;
+  function encodeInput(input) {
+    if (typeof input === "string") {
+      if (!input.length) return input;
+      return sanitizeStringInput(input);
+    }
+    const parts = [];
+    for (const [key, value] of Object.entries(input)) {
+      if (value === null || value === void 0 || value === "") continue;
+      const encodedKey = sanitizeObjectElement(key);
+      const encodedValue = sanitizeObjectElement(String(value));
+      parts.push(`${encodedKey}='${encodedValue}'`);
+    }
+    if (!parts.length) return "";
+    return parts.sort().join(",");
+  }
+  _sqlCommenter.encodeInput = encodeInput;
+  function sanitizeObjectElement(key) {
+    return encodeURIComponent(key).replace(/'/g, `\\'`);
+  }
+  _sqlCommenter.sanitizeObjectElement = sanitizeObjectElement;
+  function sanitizeStringInput(input) {
+    return input.replace(/\/\*/g, "/ *").replace(/\*\//g, "* /");
+  }
+  _sqlCommenter.sanitizeStringInput = sanitizeStringInput;
+})(sqlCommenter || (sqlCommenter = {}));
+(function(_SQL) {
+  class Aliased {
+    static [entityKind] = "SQL.Aliased";
+    /** @internal */
+    isSelectionField = false;
+    /** @internal */
+    origin;
+    constructor(sql2, fieldAlias) {
+      this.sql = sql2;
+      this.fieldAlias = fieldAlias;
+    }
+    getSQL() {
+      return this.sql;
+    }
+    /** @internal */
+    clone() {
+      return new Aliased(this.sql, this.fieldAlias);
+    }
+  }
+  _SQL.Aliased = Aliased;
+})(SQL || (SQL = {}));
+var Placeholder = class {
+  static [entityKind] = "Placeholder";
+  constructor(name2) {
+    this.name = name2;
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+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`);
+      const value = values[p.value.name];
+      if (value === null) return value;
+      const mapped = p.encoder.mapToDriverValue.isNoop ? value : p.encoder.mapToDriverValue(value);
+      return p.codec ? p.codec(mapped) : mapped;
+    }
+    return p;
+  });
+}
+var IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
+var View = class {
+  static [entityKind] = "View";
+  /** @internal */
+  [ViewBaseConfig];
+  /** @internal */
+  [IsDrizzleView] = true;
+  /** @internal */
+  get [TableName]() {
+    return this[ViewBaseConfig].name;
+  }
+  /** @internal */
+  get [TableSchema]() {
+    return this[ViewBaseConfig].schema;
+  }
+  /** @internal */
+  get [IsAlias]() {
+    return this[ViewBaseConfig].isAlias;
+  }
+  /** @internal */
+  get [OriginalName]() {
+    return this[ViewBaseConfig].originalName;
+  }
+  /** @internal */
+  get [TableColumns]() {
+    return this[ViewBaseConfig].selectedFields;
+  }
+  constructor({ name: name2, schema, selectedFields, query }) {
+    this[ViewBaseConfig] = {
+      name: name2,
+      originalName: name2,
+      schema,
+      selectedFields,
+      query,
+      isExisting: !query,
+      isAlias: false
+    };
+  }
+};
+Column.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Subquery.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/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;
+}
+var eq = (left, right) => {
+  return sql`${left} = ${bindIfParam(right, left)}`;
+};
+var ne = (left, right) => {
+  return sql`${left} <> ${bindIfParam(right, left)}`;
+};
+function and(...unfilteredConditions) {
+  const conditions = unfilteredConditions.filter((c) => c !== void 0);
+  if (conditions.length === 0) return;
+  if (conditions.length === 1) return new SQL(conditions);
+  return new SQL([
+    new StringChunk("("),
+    sql.join(conditions.map((c) => sql`(${c})`), new StringChunk(" and ")),
+    new StringChunk(")")
+  ]);
+}
+function or(...unfilteredConditions) {
+  const conditions = unfilteredConditions.filter((c) => c !== void 0);
+  if (conditions.length === 0) return;
+  if (conditions.length === 1) return new SQL(conditions);
+  return new SQL([
+    new StringChunk("("),
+    sql.join(conditions.map((c) => sql`(${c})`), new StringChunk(" or ")),
+    new StringChunk(")")
+  ]);
+}
+function not(condition) {
+  return is(condition, SQL) ? sql`not (${condition})` : sql`not ${condition}`;
+}
+var gt = (left, right) => {
+  return sql`${left} > ${bindIfParam(right, left)}`;
+};
+var gte = (left, right) => {
+  return sql`${left} >= ${bindIfParam(right, left)}`;
+};
+var lt = (left, right) => {
+  return sql`${left} < ${bindIfParam(right, left)}`;
+};
+var lte = (left, right) => {
+  return sql`${left} <= ${bindIfParam(right, left)}`;
+};
+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}`;
+}
+function arrayContains(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) throw new Error("arrayContains requires at least one value");
+    const par = bindIfParam(values, column);
+    return sql`${column} @> ${sql`${Array.isArray(par) ? new Param(par) : par}`}`;
+  }
+  return sql`${column} @> ${bindIfParam(values, column)}`;
+}
+function arrayContained(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) throw new Error("arrayContained requires at least one value");
+    const par = bindIfParam(values, column);
+    return sql`${column} <@ ${sql`${Array.isArray(par) ? new Param(par) : par}`}`;
+  }
+  return sql`${column} <@ ${bindIfParam(values, column)}`;
+}
+function arrayOverlaps(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) throw new Error("arrayOverlaps requires at least one value");
+    const par = bindIfParam(values, column);
+    return sql`${column} && ${sql`${Array.isArray(par) ? new Param(par) : par}`}`;
+  }
+  return sql`${column} && ${bindIfParam(values, column)}`;
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sql/expressions/select.js
+function asc(column) {
+  return sql`${column} asc`;
+}
+function desc(column) {
+  return sql`${column} desc`;
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/column-builder.js
+var ColumnBuilder = class {
+  static [entityKind] = "ColumnBuilder";
+  /** @internal */
+  config;
+  constructor(name2, dataType, columnType) {
+    this.config = {
+      name: name2,
+      keyAsName: name2 === "",
+      notNull: false,
+      default: void 0,
+      hasDefault: false,
+      primaryKey: false,
+      isUnique: false,
+      uniqueName: void 0,
+      uniqueType: void 0,
+      dataType,
+      columnType,
+      generated: void 0
+    };
+  }
+  /**
+  * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+  *
+  * @example
+  * ```ts
+  * const users = pgTable('users', {
+  * 	id: integer('id').$type<UserId>().primaryKey(),
+  * 	details: json('details').$type<UserDetails>().notNull(),
+  * });
+  * ```
+  */
+  $type() {
+    return this;
+  }
+  /**
+  * Adds a `not null` clause to the column definition.
+  *
+  * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
+  */
+  notNull() {
+    this.config.notNull = true;
+    return this;
+  }
+  /**
+  * Adds a `default <value>` clause to the column definition.
+  *
+  * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+  *
+  * If you need to set a dynamic default value, use {@link $defaultFn} instead.
+  */
+  default(value) {
+    this.config.default = value;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+  * Adds a dynamic default value to the column.
+  * The function will be called when the row is inserted, and the returned value will be used as the column value.
+  *
+  * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+  */
+  $defaultFn(fn) {
+    this.config.defaultFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+  * Alias for {@link $defaultFn}.
+  */
+  $default = this.$defaultFn;
+  /**
+  * Adds a dynamic update value to the column.
+  * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
+  * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
+  *
+  * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+  */
+  $onUpdateFn(fn) {
+    this.config.onUpdateFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+  * Alias for {@link $onUpdateFn}.
+  */
+  $onUpdate = this.$onUpdateFn;
+  /**
+  * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+  *
+  * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+  */
+  primaryKey() {
+    this.config.primaryKey = true;
+    this.config.notNull = true;
+    return this;
+  }
+  /** @internal Sets the name of the column to the key within the table definition if a name was not given. */
+  setName(name2, casingFn) {
+    if (this.config.name !== "") return;
+    this.config.name = casingFn(name2);
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
+var ForeignKeyBuilder = class {
+  static [entityKind] = "SQLiteForeignKeyBuilder";
+  /** @internal */
+  reference;
+  /** @internal */
+  _onUpdate;
+  /** @internal */
+  _onDelete;
+  constructor(config, actions) {
+    this.reference = () => {
+      const { name: name2, columns, foreignColumns } = config();
+      return {
+        name: name2,
+        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;
+  }
+  /** @internal */
+  build(table) {
+    return new ForeignKey(table, this);
+  }
+};
+var ForeignKey = class {
+  static [entityKind] = "SQLiteForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  constructor(table, builder) {
+    this.table = table;
+    this.reference = builder.reference;
+    this.onUpdate = builder._onUpdate;
+    this.onDelete = builder._onDelete;
+  }
+  getName() {
+    const { name: name2, columns, foreignColumns } = this.reference();
+    const columnNames = columns.map((column) => column.name);
+    const foreignColumnNames = foreignColumns.map((column) => column.name);
+    const chunks = [
+      this.table[TableName],
+      ...columnNames,
+      foreignColumns[0].table[TableName],
+      ...foreignColumnNames
+    ];
+    return name2 ?? `${chunks.join("_")}_fk`;
+  }
+  isNameExplicit() {
+    return !!this.reference().name;
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/columns/common.js
+var SQLiteColumnBuilder = class extends ColumnBuilder {
+  static [entityKind] = "SQLiteColumnBuilder";
+  foreignKeyConfigs = [];
+  references(ref, actions = {}) {
+    this.foreignKeyConfigs.push({
+      ref,
+      actions
+    });
+    return this;
+  }
+  unique(name2) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name2;
+    return this;
+  }
+  generatedAlwaysAs(as, config) {
+    this.config.generated = {
+      as,
+      type: "always",
+      mode: config?.mode ?? "virtual"
+    };
+    return this;
+  }
+  /** @internal */
+  buildForeignKeys(column, table) {
+    return this.foreignKeyConfigs.map(({ ref, actions }) => {
+      return ((ref2, actions2) => {
+        const builder = new ForeignKeyBuilder(() => {
+          const foreignColumn = ref2();
+          return {
+            columns: [column],
+            foreignColumns: [foreignColumn]
+          };
+        });
+        if (actions2.onUpdate) builder.onUpdate(actions2.onUpdate);
+        if (actions2.onDelete) builder.onDelete(actions2.onDelete);
+        return builder.build(table);
+      })(ref, actions);
+    });
+  }
+};
+var SQLiteColumn = class extends Column {
+  static [entityKind] = "SQLiteColumn";
+  /** @internal */
+  table;
+  constructor(table, config) {
+    super(table, config);
+    this.table = table;
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/utils.js
+var FnConstructor = Object.getPrototypeOf(() => null).constructor;
+function makeJitQueryMapperInner(columns, joinsNotNullableMap = {}) {
+  const preFn = [];
+  const fn = [];
+  fn.push(`const [ ${columns.map((_, i) => `c${i}`).join(", ")} ] = rows[i];`);
+  const nullifyMap = {};
+  const objectIds = {};
+  const decodes = Array.from({ length: columns.length });
+  for (let idx = 0; idx < columns.length; ++idx) {
+    const { field, path, codec, arrayDimensions } = columns[idx];
+    let decoder;
+    let decoderStr;
+    let decoderFieldDestructure;
+    let isColumn = false;
+    if (is(field, Column)) {
+      isColumn = true;
+      decoder = field;
+      decoderFieldDestructure = `field: decoder${idx}`;
+    } else if (is(field, SQL)) {
+      decoder = field.decoder;
+      decoderFieldDestructure = `field: { decoder: decoder${idx} }`;
+    } else if (is(field, Subquery)) {
+      decoder = field._.sql.decoder;
+      decoderFieldDestructure = `field: { _: { sql: { decoder: decoder${idx} } } }`;
+    } else {
+      decoder = field.sql.decoder;
+      decoderFieldDestructure = `field: { sql: { decoder: decoder${idx} } }`;
+    }
+    decoderStr = `decoder${idx}.mapFromDriverValue`;
+    if (decoder.mapFromDriverValue.isNoop) decoderStr = "";
+    if (decoderStr) preFn.push(`const { ${decoderFieldDestructure}${codec ? `, codec: codec${idx}` : ""} } = columns[${idx}];`);
+    else if (codec) preFn.push(`const { codec: codec${idx} } = columns[${idx}];`);
+    const colStr = `c${idx}`;
+    let decodedValue = colStr;
+    if (codec) decodedValue = `codec${idx}(${decodedValue}, ${arrayDimensions})`;
+    if (decoderStr) decodedValue = `${decoderStr}(${decodedValue})`;
+    decodes[idx] = colStr === decodedValue ? `${colStr}` : `${colStr} === null ? ${colStr} : ${decodedValue}`;
+    if (path.length !== 2 || !isColumn) continue;
+    if (objectIds[path[0]] === void 0) objectIds[path[0]] = [`c${idx}`];
+    else objectIds[path[0]]?.push(`c${idx}`);
+    const [objectName] = path;
+    const tableName = getTableName(field.table);
+    nullifyMap[objectName] = joinsNotNullableMap[tableName] ? false : typeof nullifyMap[objectName] === "string" ? nullifyMap[objectName] === tableName ? tableName : false : tableName;
+  }
+  fn.push(`mapped[i] = {`);
+  let currentObjectPath = [];
+  for (let idx = 0; idx < columns.length; ++idx) {
+    const { path } = columns[idx];
+    const jsonPath = path.map((e) => JSON.stringify(e));
+    const decodedValue = decodes[idx];
+    const objectPath = path.slice(0, -1);
+    let commonLen = 0;
+    while (commonLen < currentObjectPath.length && commonLen < objectPath.length && currentObjectPath[commonLen] === objectPath[commonLen]) commonLen++;
+    for (let d = currentObjectPath.length - 1; d >= commonLen; --d) fn.push(`${"	".repeat(d + 1)}},`);
+    for (let d = commonLen; d < objectPath.length; ++d) fn.push(`${"	".repeat(d + 1)}${jsonPath[d]}: ${d === 0 && objectPath.length === 1 && typeof nullifyMap[path[0]] === "string" ? `${objectIds[path[0]]?.map((c) => `${c} === null`).join(" && ")} ? null : {` : "{"}`);
+    currentObjectPath = objectPath;
+    fn.push(`${"	".repeat(path.length)}${jsonPath[path.length - 1]}: ${decodedValue},`);
+  }
+  for (let d = currentObjectPath.length - 1; d >= 0; --d) fn.push(`${"	".repeat(d + 1)}},`);
+  fn.push(`};`);
+  return `${preFn.length ? `${preFn.join("\n	")}
+	` : ""}for (let i = 0; i < length; ++i) {
+		${fn.join("\n		")}
+	}`;
+}
+function makeJitQueryMapper(columns, joinsNotNullableMap) {
+  const internals = `	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	${makeJitQueryMapperInner(columns, joinsNotNullableMap)}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper`;
+  return Object.assign(new FnConstructor("rows", internals).bind({ columns }), { body: `function jitQueryMapper (rows) {
+${internals}
+}` });
+}
+function jitCompatCheck(isEnabled) {
+  if (!isEnabled) return false;
+  try {
+    const res = new FnConstructor("input", '"use strict"; return input;')(true);
+    if (res !== true) {
+      console.warn("Unable to use jit mappers due to incompatibility: corrupted jit function output.\nFalling back to premade mappers.\nError details:");
+      console.error(`Expected to receive \`true\`, got: ${res}`);
+    }
+    return true;
+  } catch (e) {
+    console.warn("Unable to use jit mappers due to incompatibility.\nFalling back to premade mappers.\nError details:");
+    console.error(e);
+    return false;
+  }
+}
+function makeDefaultQueryMapper(columns, joinsNotNullableMap) {
+  const interpretedData = columns.map(({ field, codec, arrayDimensions, path }) => {
+    let processNullifyMap;
+    let decoderSrc;
+    if (is(field, Column)) {
+      decoderSrc = field;
+      if (joinsNotNullableMap && path.length === 2) {
+        const objectName = path[0];
+        processNullifyMap = (nullifyMap, value) => {
+          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;
+        };
+      }
+    } else if (is(field, SQL)) decoderSrc = field.decoder;
+    else if (is(field, Subquery)) decoderSrc = field._.sql.decoder;
+    else decoderSrc = field.sql.decoder;
+    let decoder;
+    if (decoderSrc.mapFromDriverValue.isNoop) decoder = codec ? (v) => codec(v, arrayDimensions) : void 0;
+    else decoder = codec ? (v) => decoderSrc.mapFromDriverValue(codec(v, arrayDimensions)) : (v) => decoderSrc.mapFromDriverValue(v);
+    return [decoder, processNullifyMap];
+  });
+  return ((rows) => rows.map((row) => {
+    const nullifyMap = {};
+    const result = columns.reduce((result2, { path }, columnIndex) => {
+      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 [decoder, processNullifyMap] = interpretedData[columnIndex];
+        const rawValue = row[columnIndex];
+        const value = node[pathChunk] = rawValue === null ? null : decoder ? decoder(rawValue) : rawValue;
+        processNullifyMap?.(nullifyMap, value);
+      }
+      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, codecs) {
+  return Object.entries(fields).reduce((result, [name2, field]) => {
+    if (typeof name2 !== "string") return result;
+    const newPath = pathPrefix ? [...pathPrefix, name2] : [name2];
+    if (is(field, Column)) result.push({
+      path: newPath,
+      field,
+      codec: codecs?.get(field, "normalize"),
+      arrayDimensions: field.dimensions,
+      column: field
+    });
+    else if (is(field, SQL) || is(field, SQL.Aliased)) {
+      const col = getColumnFromDecoder(field);
+      result.push(col ? {
+        path: newPath,
+        field,
+        codec: codecs?.get(col, "normalize"),
+        arrayDimensions: col.dimensions,
+        column: col
+      } : {
+        path: newPath,
+        field
+      });
+    } else if (is(field, Subquery)) {
+      let column;
+      const entry = Object.values(field._.selectedFields)[0];
+      let fieldDecoder;
+      if (is(entry, Column)) {
+        column = entry;
+        fieldDecoder = entry;
+      } else if (is(entry, SQL)) {
+        column = getColumnFromDecoder(entry);
+        fieldDecoder = entry.decoder;
+      } else {
+        column = getColumnFromDecoder(entry);
+        fieldDecoder = entry.sql.decoder;
+      }
+      if (fieldDecoder) field._.sql.decoder = fieldDecoder;
+      result.push(column ? {
+        path: newPath,
+        field,
+        codec: codecs?.get(column, "normalize"),
+        arrayDimensions: column.dimensions,
+        column
+      } : {
+        path: newPath,
+        field
+      });
+    } else if (is(field, Table)) result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath, codecs));
+    else result.push(...orderSelectedFields(field, newPath, codecs));
+    return result;
+  }, []);
+}
+function getColumnFromDecoder(source) {
+  const query = source.getSQL();
+  if (is(query.decoder, Column)) return query.decoder;
+}
+function haveSameKeys(left, right) {
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) return false;
+  for (const [index2, key] of leftKeys.entries()) if (key !== rightKeys[index2]) return false;
+  return true;
+}
+function mapUpdateSet(table, values) {
+  const entries = Object.entries(values).filter(([, value]) => value !== void 0).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 name2 of Object.getOwnPropertyNames(extendedClass.prototype)) {
+    if (name2 === "constructor") continue;
+    Object.defineProperty(baseClass.prototype, name2, Object.getOwnPropertyDescriptor(extendedClass.prototype, name2) || /* @__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) ? void 0 : 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
+  };
+}
+var textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder();
+function assertUnreachable(_x) {
+  throw new Error("Didn't expect to get here");
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/columns/integer.js
+var SQLiteBaseIntegerBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBaseIntegerBuilder";
+  constructor(name2, dataType, columnType) {
+    super(name2, dataType, columnType);
+    this.config.autoIncrement = false;
+  }
+  primaryKey(config) {
+    if (config?.autoIncrement) this.config.autoIncrement = true;
+    this.config.hasDefault = true;
+    return super.primaryKey();
+  }
+};
+var SQLiteBaseInteger = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBaseInteger";
+  autoIncrement = this.config.autoIncrement;
+  getSQLType() {
+    return "integer";
+  }
+};
+var SQLiteIntegerBuilder = class extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteIntegerBuilder";
+  constructor(name2) {
+    super(name2, "number int53", "SQLiteInteger");
+  }
+  build(table) {
+    return new SQLiteInteger(table, this.config);
+  }
+};
+var SQLiteInteger = class extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteInteger";
+};
+var SQLiteTimestampBuilder = class extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteTimestampBuilder";
+  constructor(name2, mode) {
+    super(name2, "object date", "SQLiteTimestamp");
+    this.config.mode = mode;
+  }
+  /**
+  * @deprecated Use `default()` with your own expression instead.
+  *
+  * Adds `DEFAULT (cast((julianday('now') - 2440587.5)*86400000 as integer))` to the column, which is the current epoch timestamp in milliseconds.
+  */
+  defaultNow() {
+    return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
+  }
+  build(table) {
+    return new SQLiteTimestamp(table, this.config);
+  }
+};
+var SQLiteTimestamp = class extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteTimestamp";
+  mode = this.config.mode;
+  mapFromDriverValue = (value) => {
+    if (typeof value === "string") return new Date(value.replaceAll('"', ""));
+    if (this.config.mode === "timestamp") return /* @__PURE__ */ new Date(value * 1e3);
+    return new Date(value);
+  };
+  mapToDriverValue = (value) => {
+    if (typeof value === "number") return value;
+    const unix = value.getTime();
+    if (this.config.mode === "timestamp") return Math.floor(unix / 1e3);
+    return unix;
+  };
+};
+var SQLiteBooleanBuilder = class extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteBooleanBuilder";
+  constructor(name2, mode) {
+    super(name2, "boolean", "SQLiteBoolean");
+    this.config.mode = mode;
+  }
+  build(table) {
+    return new SQLiteBoolean(table, this.config);
+  }
+};
+var SQLiteBoolean = class extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteBoolean";
+  mode = this.config.mode;
+  mapFromDriverValue = (value) => {
+    return Number(value) === 1;
+  };
+  mapToDriverValue = (value) => {
+    return value ? 1 : 0;
+  };
+};
+function integer(a, b) {
+  const { name: name2, config } = getColumnNameAndConfig(a, b);
+  if (config?.mode === "timestamp" || config?.mode === "timestamp_ms") return new SQLiteTimestampBuilder(name2, config.mode);
+  if (config?.mode === "boolean") return new SQLiteBooleanBuilder(name2, config.mode);
+  return new SQLiteIntegerBuilder(name2);
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/columns/real.js
+var SQLiteRealBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteRealBuilder";
+  constructor(name2) {
+    super(name2, "number double", "SQLiteReal");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteReal(table, this.config);
+  }
+};
+var SQLiteReal = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteReal";
+  getSQLType() {
+    return "real";
+  }
+};
+function real(name2) {
+  return new SQLiteRealBuilder(name2 ?? "");
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/columns/text.js
+var SQLiteTextBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteTextBuilder";
+  constructor(name2, config) {
+    super(name2, config.enum?.length ? "string enum" : "string", "SQLiteText");
+    this.config.enumValues = config.enum;
+    this.config.length = config.length;
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteText(table, this.config);
+  }
+};
+var SQLiteText = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteText";
+  enumValues = this.config.enumValues;
+  constructor(table, config) {
+    super(table, config);
+  }
+  getSQLType() {
+    return `text${this.config.length ? `(${this.config.length})` : ""}`;
+  }
+};
+var SQLiteTextJsonBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteTextJsonBuilder";
+  constructor(name2) {
+    super(name2, "object json", "SQLiteTextJson");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteTextJson(table, this.config);
+  }
+};
+var SQLiteTextJson = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteTextJson";
+  getSQLType() {
+    return "text";
+  }
+  mapFromDriverValue = (value) => {
+    return JSON.parse(value);
+  };
+  mapToDriverValue = (value) => {
+    return JSON.stringify(value);
+  };
+};
+function text(a, b = {}) {
+  const { name: name2, config } = getColumnNameAndConfig(a, b);
+  if (config.mode === "json") return new SQLiteTextJsonBuilder(name2);
+  return new SQLiteTextBuilder(name2, config);
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/columns/blob.js
+function hexToText(hexString) {
+  let result = "";
+  for (let i = 0; i < hexString.length; i += 2) {
+    const hexPair = hexString.slice(i, i + 2);
+    const decimalValue = Number.parseInt(hexPair, 16);
+    result += String.fromCodePoint(decimalValue);
+  }
+  return result;
+}
+var SQLiteBigIntBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBigIntBuilder";
+  constructor(name2) {
+    super(name2, "bigint int64", "SQLiteBigInt");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBigInt(table, this.config);
+  }
+};
+var SQLiteBigInt = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBigInt";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue = (value) => {
+    if (typeof value === "string") return BigInt(hexToText(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());
+  };
+};
+var SQLiteBlobJsonBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobJsonBuilder";
+  constructor(name2) {
+    super(name2, "object json", "SQLiteBlobJson");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBlobJson(table, this.config);
+  }
+};
+var SQLiteBlobJson = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobJson";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue = (value) => {
+    if (typeof value === "string") return JSON.parse(hexToText(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));
+  };
+};
+var SQLiteBlobBufferBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobBufferBuilder";
+  constructor(name2) {
+    super(name2, "object buffer", "SQLiteBlobBuffer");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBlobBuffer(table, this.config);
+  }
+};
+var SQLiteBlobBuffer = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobBuffer";
+  mapFromDriverValue = (value) => {
+    if (Buffer.isBuffer(value)) return value;
+    if (typeof value === "string") return Buffer.from(value, "hex");
+    return Buffer.from(value);
+  };
+  getSQLType() {
+    return "blob";
+  }
+};
+function blob(a, b) {
+  const { name: name2, config } = getColumnNameAndConfig(a, b);
+  if (config?.mode === "bigint") return new SQLiteBigIntBuilder(name2);
+  if (config?.mode === "buffer") return new SQLiteBlobBufferBuilder(name2);
+  return new SQLiteBlobJsonBuilder(name2);
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/columns/custom.js
+var SQLiteCustomColumnBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteCustomColumnBuilder";
+  constructor(name2, fieldConfig, customTypeParams) {
+    super(name2, "custom", "SQLiteCustomColumn");
+    this.config.fieldConfig = fieldConfig;
+    this.config.customTypeParams = customTypeParams;
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteCustomColumn(table, this.config);
+  }
+};
+var SQLiteCustomColumn = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteCustomColumn";
+  sqlName;
+  mapTo;
+  mapFrom;
+  mapJson;
+  forJsonSelect;
+  constructor(table, config) {
+    super(table, config);
+    this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+    this.mapTo = config.customTypeParams.toDriver;
+    this.mapFrom = config.customTypeParams.fromDriver;
+    this.mapJson = config.customTypeParams.fromJson;
+    this.forJsonSelect = config.customTypeParams.forJsonSelect;
+  }
+  getSQLType() {
+    return this.sqlName;
+  }
+  mapFromDriverValue = (value) => {
+    return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
+  };
+  mapFromJsonValue(value) {
+    return typeof this.mapJson === "function" ? this.mapJson(value) : this.mapFromDriverValue(value);
+  }
+  jsonSelectIdentifier(identifier, sql2) {
+    if (typeof this.forJsonSelect === "function") return this.forJsonSelect(identifier, sql2);
+    const rawType = this.getSQLType().toLowerCase();
+    const parenPos = rawType.indexOf("(");
+    switch (parenPos + 1 ? rawType.slice(0, parenPos) : rawType) {
+      case "numeric":
+      case "decimal":
+      case "bigint":
+        return sql2`cast(${identifier} as text)`;
+      case "blob":
+        return sql2`hex(${identifier})`;
+      default:
+        return identifier;
+    }
+  }
+  mapToDriverValue = (value) => {
+    return typeof this.mapTo === "function" ? this.mapTo(value) : value;
+  };
+};
+function customType(customTypeParams) {
+  return (a, b) => {
+    const { name: name2, config } = getColumnNameAndConfig(a, b);
+    return new SQLiteCustomColumnBuilder(name2, config, customTypeParams);
+  };
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
+var SQLiteNumericBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBuilder";
+  constructor(name2) {
+    super(name2, "string numeric", "SQLiteNumeric");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumeric(table, this.config);
+  }
+};
+var SQLiteNumeric = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumeric";
+  mapFromDriverValue = (value) => {
+    if (typeof value === "string") return value;
+    return String(value);
+  };
+  getSQLType() {
+    return "numeric";
+  }
+};
+var SQLiteNumericNumberBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericNumberBuilder";
+  constructor(name2) {
+    super(name2, "number", "SQLiteNumericNumber");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumericNumber(table, this.config);
+  }
+};
+var SQLiteNumericNumber = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumericNumber";
+  mapFromDriverValue = (value) => {
+    if (typeof value === "number") return value;
+    return Number(value);
+  };
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+};
+var SQLiteNumericBigIntBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBigIntBuilder";
+  constructor(name2) {
+    super(name2, "bigint int64", "SQLiteNumericBigInt");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumericBigInt(table, this.config);
+  }
+};
+var SQLiteNumericBigInt = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumericBigInt";
+  mapFromDriverValue = BigInt;
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+};
+function numeric(a, b) {
+  const { name: name2, config } = getColumnNameAndConfig(a, b);
+  const mode = config?.mode;
+  return mode === "number" ? new SQLiteNumericNumberBuilder(name2) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name2) : new SQLiteNumericBuilder(name2);
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/columns/all.js
+function getSQLiteColumnBuilders() {
+  return {
+    blob,
+    customType,
+    integer,
+    numeric,
+    real,
+    text
+  };
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/casing.js
+function toSnakeCase(input) {
+  return (input.replace(/['\u2019]/g, "").match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? []).map((word) => word.toLowerCase()).join("_");
+}
+function toCamelCase(input) {
+  return (input.replace(/['\u2019]/g, "").match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? []).reduce((acc, word, i) => {
+    return acc + (i === 0 ? word.toLowerCase() : `${word[0].toUpperCase()}${word.slice(1)}`);
+  }, "");
+}
+function getCasingFn(casing) {
+  if (casing === "snake_case") return toSnakeCase;
+  if (casing === "camelCase") return toCamelCase;
+  return (name2) => name2;
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/table.js
+var InlineForeignKeys = Symbol.for("drizzle:SQLiteInlineForeignKeys");
+var SQLiteTable = class extends Table {
+  static [entityKind] = "SQLiteTable";
+  /** @internal */
+  static Symbol = Object.assign({}, Table.Symbol, { InlineForeignKeys });
+  /** @internal */
+  [Table.Symbol.Columns];
+  /** @internal */
+  [InlineForeignKeys] = [];
+  /** @internal */
+  [Table.Symbol.ExtraConfigBuilder] = void 0;
+};
+function sqliteTableBase(name2, columns, extraConfig, schema, casing, baseName = name2) {
+  const casingFn = getCasingFn(casing);
+  const rawTable = new SQLiteTable(name2, schema, baseName);
+  const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
+  const builtColumns = Object.fromEntries(Object.entries(parsedColumns).map(([name3, colBuilderBase]) => {
+    const colBuilder = colBuilderBase;
+    colBuilder.setName(name3, casingFn);
+    const column = colBuilder.build(rawTable).postBuild();
+    rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+    return [name3, column];
+  }));
+  const table = Object.assign(rawTable, builtColumns);
+  table[Table.Symbol.Columns] = builtColumns;
+  table[Table.Symbol.ExtraConfigColumns] = builtColumns;
+  if (extraConfig) table[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
+  return table;
+}
+function sqliteTableWithCasing(casing) {
+  return (name2, columns, extraConfig) => sqliteTableBase(name2, columns, extraConfig, void 0, casing);
+}
+var sqliteTable = sqliteTableWithCasing(void 0);
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/indexes.js
+var IndexBuilderOn = class {
+  static [entityKind] = "SQLiteIndexBuilderOn";
+  constructor(name2, unique2) {
+    this.name = name2;
+    this.unique = unique2;
+  }
+  on(...columns) {
+    return new IndexBuilder(this.name, columns, this.unique);
+  }
+};
+var IndexBuilder = class {
+  static [entityKind] = "SQLiteIndexBuilder";
+  /** @internal */
+  config;
+  constructor(name2, columns, unique2) {
+    this.config = {
+      name: name2,
+      columns,
+      unique: unique2,
+      where: void 0
+    };
+  }
+  /**
+  * Condition for partial index.
+  */
+  where(condition) {
+    this.config.where = condition;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new Index(this.config, table);
+  }
+};
+var Index = class {
+  static [entityKind] = "SQLiteIndex";
+  config;
+  isNameExplicit;
+  constructor(config, table) {
+    this.config = {
+      ...config,
+      table
+    };
+    this.isNameExplicit = !!config.name;
+  }
+};
+function index(name2) {
+  return new IndexBuilderOn(name2, false);
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/primary-keys.js
+function primaryKey(...config) {
+  if (config[0].columns) return new PrimaryKeyBuilder(config[0].columns, config[0].name);
+  return new PrimaryKeyBuilder(config);
+}
+var PrimaryKeyBuilder = class {
+  static [entityKind] = "SQLitePrimaryKeyBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  name;
+  constructor(columns, name2) {
+    this.columns = columns;
+    this.name = name2;
+  }
+  /** @internal */
+  build(table) {
+    return new PrimaryKey(table, this.columns, this.name);
+  }
+};
+var PrimaryKey = class {
+  static [entityKind] = "SQLitePrimaryKey";
+  columns;
+  name;
+  isNameExplicit;
+  constructor(table, columns, name2) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name2;
+    this.isNameExplicit = !!name2;
+  }
+  getName() {
+    return this.name ?? `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+function unique(name2) {
+  return new UniqueOnConstraintBuilder(name2);
+}
+var UniqueConstraintBuilder = class {
+  static [entityKind] = "SQLiteUniqueConstraintBuilder";
+  /** @internal */
+  columns;
+  constructor(columns, name2) {
+    this.name = name2;
+    this.columns = columns;
+  }
+  /** @internal */
+  build(table) {
+    return new UniqueConstraint(table, this.columns, this.name);
+  }
+};
+var UniqueOnConstraintBuilder = class {
+  static [entityKind] = "SQLiteUniqueOnConstraintBuilder";
+  /** @internal */
+  name;
+  constructor(name2) {
+    this.name = name2;
+  }
+  on(...columns) {
+    return new UniqueConstraintBuilder(columns, this.name);
+  }
+};
+var UniqueConstraint = class {
+  static [entityKind] = "SQLiteUniqueConstraint";
+  columns;
+  name;
+  isNameExplicit;
+  constructor(table, columns, name2) {
+    this.table = table;
+    this.columns = columns;
+    this.isNameExplicit = !!name2;
+    this.name = name2 ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
+  }
+  getName() {
+    return this.name;
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/query-promise.js
+var QueryPromise = class {
+  static [entityKind] = "QueryPromise";
+  [Symbol.toStringTag] = "QueryPromise";
+  catch(onRejected) {
+    return this.then(void 0, 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@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/errors.js
+var DrizzleError = class extends Error {
+  static [entityKind] = "DrizzleError";
+  constructor({ message, cause }) {
+    super(message);
+    this.name = "DrizzleError";
+    this.cause = cause;
+  }
+};
+var DrizzleQueryError = class DrizzleQueryError2 extends Error {
+  static [entityKind] = "DrizzleQueryError";
+  constructor(query, params, cause) {
+    super(`Failed query: ${query}
+params: ${params}`);
+    this.query = query;
+    this.params = params;
+    this.cause = cause;
+    this.name = "DrizzleQueryError";
+    Error.captureStackTrace(this, DrizzleQueryError2);
+    if (cause) this.cause = cause;
+  }
+};
+var TransactionRollbackError = class extends DrizzleError {
+  static [entityKind] = "TransactionRollbackError";
+  constructor() {
+    super({ message: "Rollback" });
+    this.name = "TransactionRollbackError";
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/alias.js
+var ColumnTableAliasProxyHandler = class {
+  static [entityKind] = "ColumnTableAliasProxyHandler";
+  constructor(table, ignoreColumnAlias) {
+    this.table = table;
+    this.ignoreColumnAlias = ignoreColumnAlias;
+  }
+  get(columnObj, prop) {
+    if (prop === "table") return this.table;
+    if (prop === "isAlias" && this.ignoreColumnAlias) return false;
+    return columnObj[prop];
+  }
+};
+var ViewSelectionAliasProxyHandler = class {
+  static [entityKind] = "ViewSelectionAliasProxyHandler";
+  constructor(view, selection, ignoreColumnAlias) {
+    this.view = view;
+    this.selection = selection;
+    this.ignoreColumnAlias = ignoreColumnAlias;
+  }
+  get(selection, prop) {
+    const value = selection[prop];
+    if (is(value, Column)) return new Proxy(value, new ColumnTableAliasProxyHandler(this.view, this.ignoreColumnAlias));
+    if (is(value, Subquery) || is(value, SQL) || is(value, SQL.Aliased) || isSQLWrapper(value) || typeof value !== "object" || value === null) return value;
+    return new Proxy(value, this);
+  }
+};
+var TableAliasProxyHandler = class {
+  static [entityKind] = "TableAliasProxyHandler";
+  constructor(alias, replaceOriginalName, ignoreColumnAlias) {
+    this.alias = alias;
+    this.replaceOriginalName = replaceOriginalName;
+    this.ignoreColumnAlias = ignoreColumnAlias;
+  }
+  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,
+      selectedFields: new Proxy(target[ViewBaseConfig].selectedFields, new ViewSelectionAliasProxyHandler(new Proxy(target, this), target[ViewBaseConfig].selectedFields, this.ignoreColumnAlias))
+    };
+    if (prop === Table.Symbol.Columns) {
+      const columns = target[Table.Symbol.Columns];
+      if (!columns) return columns;
+      if (is(target, View)) return new Proxy(target[Table.Symbol.Columns], new ViewSelectionAliasProxyHandler(new Proxy(target, this), target[Table.Symbol.Columns], this.ignoreColumnAlias));
+      const proxiedColumns = {};
+      Object.keys(columns).map((key) => {
+        proxiedColumns[key] = new Proxy(columns[key], new ColumnTableAliasProxyHandler(new Proxy(target, this), this.ignoreColumnAlias));
+      });
+      return proxiedColumns;
+    }
+    const value = target[prop];
+    if (is(value, Column)) return new Proxy(value, new ColumnTableAliasProxyHandler(new Proxy(target, this), this.ignoreColumnAlias));
+    return value;
+  }
+};
+var ColumnAliasProxyHandler = class {
+  static [entityKind] = "ColumnAliasProxyHandler";
+  constructor(alias) {
+    this.alias = alias;
+  }
+  get(target, prop) {
+    if (prop === "isAlias") return true;
+    if (prop === "name") return this.alias;
+    if (prop === "keyAsName") return false;
+    if (prop === OriginalColumn) return () => target;
+    return target[prop];
+  }
+};
+var RelationTableAliasProxyHandler = class {
+  static [entityKind] = "RelationTableAliasProxyHandler";
+  constructor(alias) {
+    this.alias = alias;
+  }
+  get(target, prop) {
+    if (prop === "sourceTable") return aliasedTable(target.sourceTable, this.alias);
+    return target[prop];
+  }
+};
+function aliasedTable(table, tableAlias) {
+  return new Proxy(table, new TableAliasProxyHandler(tableAlias, false, false));
+}
+function aliasedColumn(column, alias) {
+  return new Proxy(column, new ColumnAliasProxyHandler(alias));
+}
+Column.prototype.as = function(alias) {
+  return aliasedColumn(this, alias);
+};
+function getOriginalColumnFromAlias(column) {
+  return column[OriginalColumn]();
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/relations.js
+var Relation = class {
+  static [entityKind] = "RelationV2";
+  fieldName;
+  sourceColumns;
+  targetColumns;
+  alias;
+  where;
+  sourceTable;
+  targetTable;
+  through;
+  throughTable;
+  isReversed;
+  /** @internal */
+  sourceColumnTableNames = [];
+  /** @internal */
+  targetColumnTableNames = [];
+  constructor(targetTable, targetTableName) {
+    this.targetTableName = targetTableName;
+    this.targetTable = targetTable;
+  }
+};
+var One = class extends Relation {
+  static [entityKind] = "OneV2";
+  relationType = "one";
+  optional;
+  constructor(tables, targetTable, targetTableName, config) {
+    super(targetTable, targetTableName);
+    this.alias = config?.alias;
+    this.where = config?.where;
+    if (config?.from) this.sourceColumns = (Array.isArray(config.from) ? config.from : [config.from]).map((it) => {
+      this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
+      this.sourceColumnTableNames.push(it._.tableName);
+      return it._.column;
+    });
+    if (config?.to) this.targetColumns = (Array.isArray(config.to) ? config.to : [config.to]).map((it) => {
+      this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
+      this.targetColumnTableNames.push(it._.tableName);
+      return it._.column;
+    });
+    if (this.throughTable) this.through = {
+      source: (Array.isArray(config?.from) ? config.from : config?.from ? [config.from] : []).map((c) => c._.through),
+      target: (Array.isArray(config?.to) ? config.to : config?.to ? [config.to] : []).map((c) => c._.through)
+    };
+    this.optional = config?.optional ?? true;
+  }
+};
+var Many = class extends Relation {
+  static [entityKind] = "ManyV2";
+  relationType = "many";
+  constructor(tables, targetTable, targetTableName, config) {
+    super(targetTable, targetTableName);
+    this.config = config;
+    this.alias = config?.alias;
+    this.where = config?.where;
+    if (config?.from) this.sourceColumns = (Array.isArray(config.from) ? config.from : [config.from]).map((it) => {
+      this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
+      this.sourceColumnTableNames.push(it._.tableName);
+      return it._.column;
+    });
+    if (config?.to) this.targetColumns = (Array.isArray(config.to) ? config.to : [config.to]).map((it) => {
+      this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
+      this.targetColumnTableNames.push(it._.tableName);
+      return it._.column;
+    });
+    if (this.throughTable) this.through = {
+      source: (Array.isArray(config?.from) ? config.from : config?.from ? [config.from] : []).map((c) => c._.through),
+      target: (Array.isArray(config?.to) ? config.to : config?.to ? [config.to] : []).map((c) => c._.through)
+    };
+  }
+};
+var AggregatedField = class {
+  static [entityKind] = "AggregatedField";
+  table;
+  onTable(table) {
+    this.table = table;
+    return this;
+  }
+};
+var Count = class extends AggregatedField {
+  static [entityKind] = "AggregatedFieldCount";
+  query;
+  getSQL() {
+    if (!this.query) {
+      if (!this.table) throw new Error("Table must be set before building aggregate field");
+      this.query = sql`select count(*) as ${sql.identifier("r")} from ${getTableAsAliasSQL(this.table)}`.mapWith(Number);
+    }
+    return this.query;
+  }
+};
+var operators = {
+  and,
+  between,
+  eq,
+  exists,
+  gt,
+  gte,
+  ilike,
+  inArray,
+  arrayContains,
+  arrayContained,
+  arrayOverlaps,
+  isNull,
+  isNotNull,
+  like,
+  lt,
+  lte,
+  ne,
+  not,
+  notBetween,
+  notExists,
+  notLike,
+  notIlike,
+  notInArray,
+  or,
+  sql
+};
+var orderByOperators = {
+  sql,
+  asc,
+  desc
+};
+function mapRelationalRow(rows, isOne, buildQueryResultSelection, parseJson = false, parseJsonIfString = false, useJsonMappers = true) {
+  const maxIdx = isOne ? 1 : rows.length;
+  const decoders = buildQueryResultSelection.map(({ field, codec, arrayDimensions }) => {
+    let decoder;
+    if (is(field, Column)) decoder = field;
+    else if (is(field, SQL)) decoder = field.decoder;
+    else if (is(field, SQL.Aliased)) decoder = field.sql.decoder;
+    else if (is(field, Table) || is(field, View)) decoder = noopDecoder;
+    else decoder = field.getSQL().decoder;
+    if (useJsonMappers && field.mapFromJsonValue) return (v) => field.mapFromJsonValue(v);
+    return decoder.mapFromDriverValue.isNoop ? codec ? (value) => codec(value, arrayDimensions) : void 0 : codec ? (value) => decoder.mapFromDriverValue(codec(value, arrayDimensions)) : (value) => decoder.mapFromDriverValue(value);
+  });
+  for (let i = 0; i < maxIdx; ++i) {
+    const row = isOne ? rows : rows[i];
+    for (let selectionItemIdx = 0; selectionItemIdx < buildQueryResultSelection.length; ++selectionItemIdx) {
+      const selectionItem = buildQueryResultSelection[selectionItemIdx];
+      if (selectionItem.selection) {
+        if (row[selectionItem.key] === null) continue;
+        if (parseJson) {
+          row[selectionItem.key] = JSON.parse(row[selectionItem.key]);
+          if (row[selectionItem.key] === null) continue;
+        } else if (parseJsonIfString && typeof row[selectionItem.key] === "string") row[selectionItem.key] = JSON.parse(row[selectionItem.key]);
+        if (selectionItem.isArray) {
+          mapRelationalRow(row[selectionItem.key], false, selectionItem.selection, false, parseJsonIfString);
+          continue;
+        }
+        mapRelationalRow(row[selectionItem.key], true, selectionItem.selection, false, parseJsonIfString);
+        continue;
+      }
+      if (row[selectionItem.key] === null) continue;
+      const decoder = decoders[selectionItemIdx];
+      if (!decoder) continue;
+      row[selectionItem.key] = decoder(row[selectionItem.key]);
+    }
+  }
+  return rows;
+}
+function mapRelationalRowFromArrays(rows, isOne, buildQueryResultSelection, parseJson = false, parseJsonIfString = false) {
+  const maxIdx = isOne ? 1 : rows.length;
+  const decoders = buildQueryResultSelection.map(({ field, codec, arrayDimensions }) => {
+    let decoder;
+    if (is(field, Column)) decoder = field;
+    else if (is(field, SQL)) decoder = field.decoder;
+    else if (is(field, SQL.Aliased)) decoder = field.sql.decoder;
+    else if (is(field, Table) || is(field, View)) decoder = noopDecoder;
+    else decoder = field.getSQL().decoder;
+    return decoder.mapFromDriverValue.isNoop ? codec ? (value) => codec(value, arrayDimensions) : void 0 : codec ? (value) => decoder.mapFromDriverValue(codec(value, arrayDimensions)) : (value) => decoder.mapFromDriverValue(value);
+  });
+  const results = Array.from({ length: maxIdx });
+  for (let i = 0; i < maxIdx; ++i) {
+    const row = isOne ? rows : rows[i];
+    const result = {};
+    for (let selectionItemIdx = 0; selectionItemIdx < buildQueryResultSelection.length; ++selectionItemIdx) {
+      const selectionItem = buildQueryResultSelection[selectionItemIdx];
+      let value = row[selectionItemIdx];
+      if (selectionItem.selection) {
+        if (value === null) {
+          result[selectionItem.key] = null;
+          continue;
+        }
+        if (parseJson) {
+          value = JSON.parse(value);
+          if (value === null) {
+            result[selectionItem.key] = null;
+            continue;
+          }
+        } else if (parseJsonIfString && typeof value === "string") value = JSON.parse(value);
+        if (selectionItem.isArray) mapRelationalRow(value, false, selectionItem.selection, false, parseJsonIfString);
+        else mapRelationalRow(value, true, selectionItem.selection, false, parseJsonIfString);
+        result[selectionItem.key] = value;
+        continue;
+      }
+      if (value === null) {
+        result[selectionItem.key] = null;
+        continue;
+      }
+      const decoder = decoders[selectionItemIdx];
+      result[selectionItem.key] = decoder ? decoder(value) : value;
+    }
+    results[i] = result;
+  }
+  return isOne ? results[0] : results;
+}
+function makeDefaultRqbMapper({ selection, isFirst, parseJson, parseJsonIfString, rootJsonMappers, arrayModeRoot }) {
+  return ((rows) => {
+    if (isFirst && !rows[0]) return rows[0];
+    return arrayModeRoot ? mapRelationalRowFromArrays(isFirst ? rows[0] : rows, isFirst, selection, parseJson, parseJsonIfString) : mapRelationalRow(isFirst ? rows[0] : rows, isFirst, selection, parseJson, parseJsonIfString, rootJsonMappers);
+  });
+}
+function makeJitRqbMapperInner(selection, rowExpr, selectionVar, parseJson, parseJsonIfString, useJsonMappers, preFn, counter, accessByIdx) {
+  const bodyStmts = [];
+  const literalEntries = [];
+  let hasWork = false;
+  const fieldVars = selection.map(() => `c${counter.n++}`);
+  const destructurePieces = selection.map((item, idx) => accessByIdx ? fieldVars[idx] : `${JSON.stringify(item.key)}: ${fieldVars[idx]}`);
+  bodyStmts.push(accessByIdx ? `let [ ${destructurePieces.join(", ")} ] = ${rowExpr};` : `let { ${destructurePieces.join(", ")} } = ${rowExpr};`);
+  for (const [idx, { field, key, codec, isArray, selection: innerSelection, arrayDimensions }] of selection.entries()) {
+    const sel = `${selectionVar}[${idx}]`;
+    const keyStr = JSON.stringify(key);
+    const slot = fieldVars[idx];
+    if (innerSelection) {
+      if (parseJson) {
+        bodyStmts.push(`if (${slot} !== null) ${slot} = JSON.parse(${slot});`);
+        hasWork = true;
+      } else if (parseJsonIfString) {
+        bodyStmts.push(`if (typeof ${slot} === 'string') ${slot} = JSON.parse(${slot});`);
+        hasWork = true;
+      }
+      const nestedSelVar = `s${counter.n++}`;
+      const savedPreFnLen = preFn.length;
+      preFn.push(`const { selection: ${nestedSelVar} } = ${sel};`);
+      if (isArray) {
+        const j = `j${counter.n++}`;
+        const inner = makeJitRqbMapperInner(innerSelection, `${slot}[${j}]`, nestedSelVar, false, parseJsonIfString, true, preFn, counter, false);
+        if (inner.hasWork) {
+          hasWork = true;
+          bodyStmts.push(`if (${slot} !== null) {`);
+          bodyStmts.push(`	for (let ${j} = 0; ${j} < ${slot}.length; ++${j}) {`);
+          for (const s of inner.bodyStmts) bodyStmts.push(`		${s}`);
+          bodyStmts.push(`		${slot}[${j}] = ${inner.literal};`);
+          bodyStmts.push(`	}`);
+          bodyStmts.push(`}`);
+        } else preFn.splice(savedPreFnLen, 1);
+      } else {
+        const inner = makeJitRqbMapperInner(innerSelection, slot, nestedSelVar, false, parseJsonIfString, true, preFn, counter, false);
+        if (inner.hasWork) {
+          hasWork = true;
+          bodyStmts.push(`if (${slot} !== null) {`);
+          for (const s of inner.bodyStmts) bodyStmts.push(`	${s}`);
+          bodyStmts.push(`	${slot} = ${inner.literal};`);
+          bodyStmts.push(`}`);
+        } else preFn.splice(savedPreFnLen, 1);
+      }
+      literalEntries.push(`${keyStr}: ${slot}`);
+      continue;
+    }
+    let decoderExpr = "";
+    let destructure = "";
+    let bypassCodecs = false;
+    if (is(field, Column)) {
+      if (useJsonMappers && field.mapFromJsonValue) {
+        bypassCodecs = true;
+        const id = counter.n++;
+        destructure = `field: dec${id}`;
+        decoderExpr = `dec${id}.mapFromJsonValue`;
+      } else if (!field.mapFromDriverValue.isNoop) {
+        const id = counter.n++;
+        destructure = `field: dec${id}`;
+        decoderExpr = `dec${id}.mapFromDriverValue`;
+      }
+    } else if (is(field, SQL)) {
+      if (useJsonMappers && field.decoder.mapFromJsonValue) {
+        bypassCodecs = true;
+        const id = counter.n++;
+        destructure = `field: { decoder: dec${id} }`;
+        decoderExpr = `dec${id}.mapFromJsonValue`;
+      } else if (!field.decoder.mapFromDriverValue.isNoop) {
+        const id = counter.n++;
+        destructure = `field: { decoder: dec${id} }`;
+        decoderExpr = `dec${id}.mapFromDriverValue`;
+      }
+    } else if (is(field, SQL.Aliased)) {
+      if (useJsonMappers && field.sql.decoder.mapFromJsonValue) {
+        bypassCodecs = true;
+        const id = counter.n++;
+        destructure = `field: { sql: { decoder: dec${id} } }`;
+        decoderExpr = `dec${id}.mapFromJsonValue`;
+      } else if (!field.sql.decoder.mapFromDriverValue.isNoop) {
+        const id = counter.n++;
+        destructure = `field: { sql: { decoder: dec${id} } }`;
+        decoderExpr = `dec${id}.mapFromDriverValue`;
+      }
+    } else if (is(field, Table) || is(field, View)) {
+    } else {
+      const sqlExpr = field.getSQL();
+      if (useJsonMappers && sqlExpr.decoder.mapFromJsonValue) {
+        bypassCodecs = true;
+        const id = counter.n++;
+        preFn.push(`const dec${id} = ${sel}.field.getSQL().decoder;`);
+        decoderExpr = `dec${id}.mapFromJsonValue`;
+      } else if (!sqlExpr.decoder.mapFromDriverValue.isNoop) {
+        const id = counter.n++;
+        preFn.push(`const dec${id} = ${sel}.field.getSQL().decoder;`);
+        decoderExpr = `dec${id}.mapFromDriverValue`;
+      }
+    }
+    let codecVar = "";
+    if (!bypassCodecs && codec) codecVar = `codec${counter.n++}`;
+    if (destructure || codecVar) {
+      const parts = [];
+      if (destructure) parts.push(destructure);
+      if (codecVar) parts.push(`codec: ${codecVar}`);
+      preFn.push(`const { ${parts.join(", ")} } = ${sel};`);
+    }
+    if (decoderExpr || codecVar) {
+      hasWork = true;
+      let decoded = slot;
+      if (codecVar) decoded = `${codecVar}(${decoded}, ${arrayDimensions})`;
+      if (decoderExpr) decoded = `${decoderExpr}(${decoded})`;
+      literalEntries.push(`${keyStr}: ${slot} === null ? null : ${decoded}`);
+    } else literalEntries.push(`${keyStr}: ${slot}`);
+  }
+  return {
+    bodyStmts,
+    literal: `{ ${literalEntries.join(", ")} }`,
+    hasWork
+  };
+}
+function makeJitRqbMapper({ selection, isFirst, parseJson, parseJsonIfString, rootJsonMappers, arrayModeRoot }) {
+  const preFn = [];
+  const inner = makeJitRqbMapperInner(selection, "row", "selection", parseJson, parseJsonIfString, arrayModeRoot ? false : rootJsonMappers, preFn, { n: 0 }, !!arrayModeRoot);
+  const lines = [];
+  lines.push(`	"use strict";
+	const { selection } = this;`);
+  for (const p of preFn) lines.push(`	${p}`);
+  if (arrayModeRoot) if (isFirst) {
+    lines.push(`	const row = rows[0];`);
+    lines.push(`	if (!row) return undefined;`);
+    for (const s of inner.bodyStmts) lines.push(`	${s}`);
+    lines.push(`	return ${inner.literal};`);
+  } else {
+    lines.push(`	const { length } = rows;`);
+    lines.push(`	const mapped = Array.from({ length });`);
+    lines.push(`	for (let i = 0; i < length; ++i) {`);
+    lines.push(`		const row = rows[i];`);
+    for (const s of inner.bodyStmts) lines.push(`		${s}`);
+    lines.push(`		mapped[i] = ${inner.literal};`);
+    lines.push(`	}`);
+    lines.push(`	return mapped;`);
+  }
+  else if (!inner.hasWork) lines.push(isFirst ? `	return rows[0];` : `	return rows;`);
+  else if (isFirst) {
+    lines.push(`	const row = rows[0];`);
+    lines.push(`	if (!row) return undefined;`);
+    for (const s of inner.bodyStmts) lines.push(`	${s}`);
+    lines.push(`	rows[0] = ${inner.literal};`);
+    lines.push(`	return rows[0];`);
+  } else {
+    lines.push(`	for (let i = 0; i < rows.length; ++i) {`);
+    lines.push(`		const row = rows[i];`);
+    for (const s of inner.bodyStmts) lines.push(`		${s}`);
+    lines.push(`		rows[i] = ${inner.literal};`);
+    lines.push(`	}`);
+    lines.push(`	return rows;`);
+  }
+  lines.push("	//# sourceURL=drizzle:jit-relational-query-mapper");
+  const compiled = lines.join("\n");
+  return Object.assign(new FnConstructor("rows", compiled).bind({ selection }), { body: `function jitRqbMapper (rows) {
+${compiled}
+}` });
+}
+var RelationsBuilderTable = class {
+  static [entityKind] = "RelationsBuilderTable";
+  _;
+  constructor(table, name2) {
+    this._ = {
+      name: name2,
+      table
+    };
+  }
+};
+var RelationsBuilderColumn = class {
+  static [entityKind] = "RelationsBuilderColumn";
+  _;
+  constructor(column, tableName, key) {
+    this._ = {
+      tableName,
+      column,
+      key
+    };
+  }
+  through(column) {
+    return new RelationsBuilderJunctionColumn(this._.column, this._.tableName, this._.key, column);
+  }
+};
+var RelationsBuilderJunctionColumn = class {
+  static [entityKind] = "RelationsBuilderColumn";
+  _;
+  constructor(column, tableName, key, through) {
+    this._ = {
+      tableName,
+      column,
+      through,
+      key
+    };
+  }
+};
+var RelationsHelperStatic = class {
+  static [entityKind] = "RelationsHelperStatic";
+  _;
+  constructor(tables) {
+    this._ = { tables };
+    const one = {};
+    const many = {};
+    for (const [tableName, table] of Object.entries(tables)) {
+      one[tableName] = (config) => {
+        return new One(tables, table, tableName, config);
+      };
+      many[tableName] = (config) => {
+        return new Many(tables, table, tableName, config);
+      };
+    }
+    this.one = one;
+    this.many = many;
+  }
+  one;
+  many;
+  /** @internal - to be reworked */
+  aggs = { count() {
+    return new Count();
+  } };
+};
+function fieldSelectionToSQL(table, target) {
+  const field = table[TableColumns][target];
+  return field ? is(field, Column) ? field : is(field, SQL.Aliased) ? sql`${table}.${sql.identifier(field.fieldAlias)}` : sql`${table}.${sql.identifier(target)}` : sql`${table}.${sql.identifier(target)}`;
+}
+function relationsFieldFilterToSQL(column, filter) {
+  if (typeof filter !== "object" || is(filter, Placeholder)) return eq(column, filter);
+  const entries = Object.entries(filter);
+  if (!entries.length) return void 0;
+  const parts = [];
+  for (const [target, value] of entries) {
+    if (value === void 0) continue;
+    switch (target) {
+      case "NOT": {
+        const res = relationsFieldFilterToSQL(column, value);
+        if (!res) continue;
+        parts.push(not(res));
+        continue;
+      }
+      case "OR":
+        if (!value.length) continue;
+        parts.push(or(...value.map((subFilter) => relationsFieldFilterToSQL(column, subFilter))));
+        continue;
+      case "AND":
+        if (!value.length) continue;
+        parts.push(and(...value.map((subFilter) => relationsFieldFilterToSQL(column, subFilter))));
+        continue;
+      case "isNotNull":
+      case "isNull":
+        if (!value) continue;
+        parts.push(operators[target](column));
+        continue;
+      case "in":
+        parts.push(operators.inArray(column, value));
+        continue;
+      case "notIn":
+        parts.push(operators.notInArray(column, value));
+        continue;
+      default:
+        parts.push(operators[target](column, value));
+        continue;
+    }
+  }
+  if (!parts.length) return void 0;
+  return and(...parts);
+}
+function relationsFilterToSQL(table, filter, tableRelations = {}, tablesRelations = {}, depth = 0) {
+  const entries = Object.entries(filter);
+  if (!entries.length) return void 0;
+  const parts = [];
+  for (const [target, value] of entries) {
+    if (value === void 0) continue;
+    switch (target) {
+      case "RAW": {
+        const processed = typeof value === "function" ? value(table, operators) : value.getSQL();
+        parts.push(processed);
+        continue;
+      }
+      case "OR":
+        if (!value?.length) continue;
+        parts.push(or(...value.map((subFilter) => relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, depth))));
+        continue;
+      case "AND":
+        if (!value?.length) continue;
+        parts.push(and(...value.map((subFilter) => relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, depth))));
+        continue;
+      case "NOT": {
+        if (value === void 0) continue;
+        const built = relationsFilterToSQL(table, value, tableRelations, tablesRelations, depth);
+        if (!built) continue;
+        parts.push(not(built));
+        continue;
+      }
+      default: {
+        if (table[TableColumns][target]) {
+          const colFilter = relationsFieldFilterToSQL(fieldSelectionToSQL(table, target), value);
+          if (colFilter) parts.push(colFilter);
+          continue;
+        }
+        const relation = tableRelations[target];
+        if (!relation) throw new DrizzleError({ message: `Unknown relational filter field: "${target}"` });
+        const targetTable = aliasedTable(relation.targetTable, `f${depth}`);
+        const throughTable = relation.throughTable ? aliasedTable(relation.throughTable, `ft${depth}`) : void 0;
+        const targetConfig = tablesRelations[relation.targetTableName];
+        const { filter: relationFilter, joinCondition } = relationToSQL(relation, table, targetTable, throughTable);
+        const filter2 = and(relationFilter, typeof value === "boolean" ? void 0 : relationsFilterToSQL(targetTable, value, targetConfig.relations, tablesRelations, depth + 1));
+        const subquery = throughTable ? sql`(select * from ${getTableAsAliasSQL(targetTable)} inner join ${getTableAsAliasSQL(throughTable)} on ${joinCondition}${sql` where ${filter2}`.if(filter2)} limit 1)` : sql`(select * from ${getTableAsAliasSQL(targetTable)}${sql` where ${filter2}`.if(filter2)} limit 1)`;
+        if (filter2) parts.push((value ? exists : notExists)(subquery));
+      }
+    }
+  }
+  return and(...parts);
+}
+function relationsOrderToSQL(table, orders) {
+  if (typeof orders === "function") {
+    const data = orders(table, orderByOperators);
+    return is(data, SQL) ? data : Array.isArray(data) ? data.length ? sql.join(data.map((o) => is(o, SQL) ? o : asc(o)), sql`, `) : void 0 : is(data, Column) ? asc(data) : void 0;
+  }
+  const entries = Object.entries(orders).filter(([_, value]) => value);
+  if (!entries.length) return void 0;
+  return sql.join(entries.map(([target, value]) => (value === "asc" ? asc : desc)(fieldSelectionToSQL(table, target))), sql`, `);
+}
+function relationExtrasToSQL(table, extras, codecs, inJson) {
+  const subqueries = [];
+  const selection = [];
+  for (const [key, field] of Object.entries(extras)) {
+    if (!field) continue;
+    const subq = (typeof field === "function" ? field(table, { sql: operators.sql }) : field).getSQL();
+    const column = codecs ? getColumnFromDecoder(subq) : void 0;
+    const query = column && (!inJson || !column.jsonSelectIdentifier) ? sql`${codecs.apply(column, inJson ? "castInJson" : "cast", sql`(${subq})`)} as ${sql.identifier(key)}` : sql`(${subq}) as ${sql.identifier(key)}`;
+    query.decoder = subq.decoder;
+    subqueries.push(query);
+    selection.push(column && (!inJson || !column.mapFromJsonValue) ? {
+      key,
+      field: query,
+      codec: codecs.get(column, inJson ? "normalizeInJson" : "normalize"),
+      arrayDimensions: column.dimensions
+    } : {
+      key,
+      field: query
+    });
+  }
+  return {
+    sql: subqueries.length ? sql.join(subqueries, sql`, `) : void 0,
+    selection
+  };
+}
+function relationToSQL(relation, sourceTable, targetTable, throughTable) {
+  if (relation.through) {
+    const outerColumnWhere = relation.sourceColumns.map((s, i) => {
+      const t = relation.through.source[i];
+      return eq(sql`${sourceTable}.${sql.identifier(s.name)}`, sql`${throughTable}.${sql.identifier(is(t._.column, Column) ? t._.column.name : t._.key)}`);
+    });
+    const innerColumnWhere = relation.targetColumns.map((s, i) => {
+      const t = relation.through.target[i];
+      return eq(sql`${throughTable}.${sql.identifier(is(t._.column, Column) ? t._.column.name : t._.key)}`, sql`${targetTable}.${sql.identifier(s.name)}`);
+    });
+    return {
+      filter: and(relation.where ? relationsFilterToSQL(relation.isReversed ? sourceTable : targetTable, relation.where) : void 0, ...outerColumnWhere),
+      joinCondition: and(...innerColumnWhere)
+    };
+  }
+  return { filter: and(...relation.sourceColumns.map((s, i) => {
+    const t = relation.targetColumns[i];
+    return eq(sql`${sourceTable}.${sql.identifier(s.name)}`, sql`${targetTable}.${sql.identifier(t.name)}`);
+  }), relation.where ? relationsFilterToSQL(relation.isReversed ? sourceTable : targetTable, relation.where) : void 0) };
+}
+function getTableAsAliasSQL(table) {
+  return sql`${table[IsAlias] ? sql`${sql`${sql.identifier(table[TableSchema] ?? "")}.`.if(table[TableSchema])}${sql.identifier(table[OriginalName])} as ${table}` : table}`;
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/logger.js
+var ConsoleLogWriter = class {
+  static [entityKind] = "ConsoleLogWriter";
+  write(message) {
+    console.log(message);
+  }
+};
+var DefaultLogger = class {
+  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}`);
+  }
+};
+var NoopLogger = class {
+  static [entityKind] = "NoopLogger";
+  logQuery() {
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/utils.js
+function extractUsedTable(table) {
+  if (is(table, SQLiteTable)) return [`${table[Table.Symbol.BaseName]}`];
+  if (is(table, Subquery)) return table._.usedTables ?? [];
+  if (is(table, SQL)) return table.usedTables ?? [];
+  return [];
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/view-base.js
+var SQLiteViewBase = class extends View {
+  static [entityKind] = "SQLiteViewBase";
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/selection-proxy.js
+var SelectionProxyHandler = class SelectionProxyHandler2 {
+  static [entityKind] = "SelectionProxyHandler";
+  config;
+  constructor(config) {
+    this.config = { ...config };
+  }
+  get(subquery, prop) {
+    if (prop === "_") return {
+      ...subquery["_"],
+      selectedFields: new Proxy(subquery._.selectedFields, this)
+    };
+    if (prop === ViewBaseConfig) return {
+      ...subquery[ViewBaseConfig],
+      selectedFields: new Proxy(subquery[ViewBaseConfig].selectedFields, this)
+    };
+    if (typeof prop === "symbol") return subquery[prop];
+    const value = (is(subquery, Subquery) ? subquery._.selectedFields : is(subquery, View) ? subquery[ViewBaseConfig].selectedFields : subquery)[prop];
+    if (is(value, SQL.Aliased)) {
+      if (this.config.sqlAliasedBehavior === "sql" && !value.isSelectionField) return value.sql;
+      const newValue = value.clone();
+      newValue.isSelectionField = true;
+      newValue.origin = this.config.alias;
+      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 ColumnTableAliasProxyHandler(new Proxy(value.table, new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false, true)), true));
+      return value;
+    }
+    if (typeof value !== "object" || value === null) return value;
+    return new Proxy(value, new SelectionProxyHandler2(this.config));
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/query-builders/query-builder.js
+var TypedQueryBuilder = class {
+  static [entityKind] = "TypedQueryBuilder";
+  /** @internal */
+  getSelectedFields() {
+    return this._.selectedFields;
+  }
+  /** @internal */
+  withoutSelectionCastCodecs() {
+    return this;
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/query-builders/select.js
+var SQLiteSelectBuilder = class {
+  static [entityKind] = "SQLiteSelectBuilder";
+  fields;
+  session;
+  dialect;
+  withList;
+  distinct;
+  constructor(config, builder = SQLiteSelectBase) {
+    this.builder = builder;
+    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 this.builder({
+      table: source,
+      fields,
+      isPartialSelect,
+      session: this.session,
+      dialect: this.dialect,
+      withList: this.withList ?? [],
+      distinct: this.distinct
+    });
+  }
+};
+var SQLiteSelectBase = class extends TypedQueryBuilder {
+  static [entityKind] = "SQLiteSelectQueryBuilder";
+  _;
+  /** @internal */
+  config;
+  joinsNotNullableMap;
+  tableName;
+  isPartialSelect;
+  session;
+  dialect;
+  cacheConfig = void 0;
+  usedTables = /* @__PURE__ */ new Set();
+  constructor({ table, fields, isPartialSelect, session, dialect, withList, distinct }) {
+    super();
+    this.config = {
+      withList,
+      table,
+      fields: { ...fields },
+      distinct,
+      setOperators: []
+    };
+    this.isPartialSelect = isPartialSelect;
+    this.session = session;
+    this.dialect = dialect;
+    this._ = {
+      selectedFields: fields,
+      config: this.config
+    };
+    this.tableName = getTableLikeName(table);
+    this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
+    for (const item of extractUsedTable(table)) this.usedTables.add(item);
+  }
+  /** @internal */
+  getUsedTables() {
+    return [...this.usedTables];
+  }
+  createJoin(joinType) {
+    return (table, on) => {
+      const baseTableName = this.tableName;
+      const tableName = getTableLikeName(table);
+      for (const item of extractUsedTable(table)) this.usedTables.add(item);
+      if (typeof tableName === "string" && this.config.joins?.some((join) => join.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(table, SQL)) {
+          const selection = is(table, Subquery) ? table._.selectedFields : is(table, View) ? table[ViewBaseConfig].selectedFields : table[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,
+        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;
+    };
+  }
+  /**
+  * Executes a `left join` operation by adding another table to the current query.
+  *
+  * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/joins#left-join}
+  *
+  * @param table the table to join.
+  * @param on the `on` clause.
+  *
+  * @example
+  *
+  * ```ts
+  * // Select all users and their pets
+  * const usersWithPets: { user: User; pets: Pet | null; }[] = await db.select()
+  *   .from(users)
+  *   .leftJoin(pets, eq(users.id, pets.ownerId))
+  *
+  * // Select userId and petId
+  * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
+  *   userId: users.id,
+  *   petId: pets.id,
+  * })
+  *   .from(users)
+  *   .leftJoin(pets, eq(users.id, pets.ownerId))
+  * ```
+  */
+  leftJoin = this.createJoin("left");
+  /**
+  * Executes a `right join` operation by adding another table to the current query.
+  *
+  * Calling this method associates each row of the joined table with the corresponding row from the main table, if a match is found. If no matching row exists, it sets all columns of the main table to null.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/joins#right-join}
+  *
+  * @param table the table to join.
+  * @param on the `on` clause.
+  *
+  * @example
+  *
+  * ```ts
+  * // Select all users and their pets
+  * const usersWithPets: { user: User | null; pets: Pet; }[] = await db.select()
+  *   .from(users)
+  *   .rightJoin(pets, eq(users.id, pets.ownerId))
+  *
+  * // Select userId and petId
+  * const usersIdsAndPetIds: { userId: number | null; petId: number; }[] = await db.select({
+  *   userId: users.id,
+  *   petId: pets.id,
+  * })
+  *   .from(users)
+  *   .rightJoin(pets, eq(users.id, pets.ownerId))
+  * ```
+  */
+  rightJoin = this.createJoin("right");
+  /**
+  * Executes an `inner join` operation, creating a new table by combining rows from two tables that have matching values.
+  *
+  * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join}
+  *
+  * @param table the table to join.
+  * @param on the `on` clause.
+  *
+  * @example
+  *
+  * ```ts
+  * // Select all users and their pets
+  * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
+  *   .from(users)
+  *   .innerJoin(pets, eq(users.id, pets.ownerId))
+  *
+  * // Select userId and petId
+  * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
+  *   userId: users.id,
+  *   petId: pets.id,
+  * })
+  *   .from(users)
+  *   .innerJoin(pets, eq(users.id, pets.ownerId))
+  * ```
+  */
+  innerJoin = this.createJoin("inner");
+  /**
+  * Executes a `full join` operation by combining rows from two tables into a new table.
+  *
+  * Calling this method retrieves all rows from both main and joined tables, merging rows with matching values and filling in `null` for non-matching columns.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/joins#full-join}
+  *
+  * @param table the table to join.
+  * @param on the `on` clause.
+  *
+  * @example
+  *
+  * ```ts
+  * // Select all users and their pets
+  * const usersWithPets: { user: User | null; pets: Pet | null; }[] = await db.select()
+  *   .from(users)
+  *   .fullJoin(pets, eq(users.id, pets.ownerId))
+  *
+  * // Select userId and petId
+  * const usersIdsAndPetIds: { userId: number | null; petId: number | null; }[] = await db.select({
+  *   userId: users.id,
+  *   petId: pets.id,
+  * })
+  *   .from(users)
+  *   .fullJoin(pets, eq(users.id, pets.ownerId))
+  * ```
+  */
+  fullJoin = this.createJoin("full");
+  /**
+  * Executes a `cross join` operation by combining rows from two tables into a new table.
+  *
+  * Calling this method retrieves all rows from both main and joined tables, merging all rows from each table.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join}
+  *
+  * @param table the table to join.
+  *
+  * @example
+  *
+  * ```ts
+  * // Select all users, each user with every pet
+  * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
+  *   .from(users)
+  *   .crossJoin(pets)
+  *
+  * // Select userId and petId
+  * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
+  *   userId: users.id,
+  *   petId: pets.id,
+  * })
+  *   .from(users)
+  *   .crossJoin(pets)
+  * ```
+  */
+  crossJoin = this.createJoin("cross");
+  createSetOperator(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;
+    };
+  }
+  /**
+  * Adds `union` set operator to the query.
+  *
+  * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}
+  *
+  * @example
+  *
+  * ```ts
+  * // Select all unique names from customers and users tables
+  * await db.select({ name: users.name })
+  *   .from(users)
+  *   .union(
+  *     db.select({ name: customers.name }).from(customers)
+  *   );
+  * // or
+  * import { union } from 'drizzle-orm/sqlite-core'
+  *
+  * await union(
+  *   db.select({ name: users.name }).from(users),
+  *   db.select({ name: customers.name }).from(customers)
+  * );
+  * ```
+  */
+  union = this.createSetOperator("union", false);
+  /**
+  * Adds `union all` set operator to the query.
+  *
+  * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}
+  *
+  * @example
+  *
+  * ```ts
+  * // Select all transaction ids from both online and in-store sales
+  * await db.select({ transaction: onlineSales.transactionId })
+  *   .from(onlineSales)
+  *   .unionAll(
+  *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+  *   );
+  * // or
+  * import { unionAll } from 'drizzle-orm/sqlite-core'
+  *
+  * await unionAll(
+  *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
+  *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+  * );
+  * ```
+  */
+  unionAll = this.createSetOperator("union", true);
+  /**
+  * Adds `intersect` set operator to the query.
+  *
+  * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}
+  *
+  * @example
+  *
+  * ```ts
+  * // Select course names that are offered in both departments A and B
+  * await db.select({ courseName: depA.courseName })
+  *   .from(depA)
+  *   .intersect(
+  *     db.select({ courseName: depB.courseName }).from(depB)
+  *   );
+  * // or
+  * import { intersect } from 'drizzle-orm/sqlite-core'
+  *
+  * await intersect(
+  *   db.select({ courseName: depA.courseName }).from(depA),
+  *   db.select({ courseName: depB.courseName }).from(depB)
+  * );
+  * ```
+  */
+  intersect = this.createSetOperator("intersect", false);
+  /**
+  * Adds `except` set operator to the query.
+  *
+  * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}
+  *
+  * @example
+  *
+  * ```ts
+  * // Select all courses offered in department A but not in department B
+  * await db.select({ courseName: depA.courseName })
+  *   .from(depA)
+  *   .except(
+  *     db.select({ courseName: depB.courseName }).from(depB)
+  *   );
+  * // or
+  * import { except } from 'drizzle-orm/sqlite-core'
+  *
+  * await except(
+  *   db.select({ courseName: depA.courseName }).from(depA),
+  *   db.select({ courseName: depB.courseName }).from(depB)
+  * );
+  * ```
+  */
+  except = this.createSetOperator("except", false);
+  /** @internal */
+  addSetOperators(setOperators) {
+    this.config.setOperators.push(...setOperators);
+    return this;
+  }
+  /**
+  * Adds a `where` clause to the query.
+  *
+  * Calling this method will select only those rows that fulfill a specified condition.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/select#filtering}
+  *
+  * @param where the `where` clause.
+  *
+  * @example
+  * You can use conditional operators and `sql function` to filter the rows to be selected.
+  *
+  * ```ts
+  * // Select all cars with green color
+  * await db.select().from(cars).where(eq(cars.color, 'green'));
+  * // or
+  * await db.select().from(cars).where(sql`${cars.color} = 'green'`)
+  * ```
+  *
+  * You can logically combine conditional operators with `and()` and `or()` operators:
+  *
+  * ```ts
+  * // Select all BMW cars with a green color
+  * await db.select().from(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+  *
+  * // Select all cars with the green or blue color
+  * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+  * ```
+  */
+  where(where) {
+    if (typeof where === "function") where = where(new Proxy(this.config.fields, new SelectionProxyHandler({
+      sqlAliasedBehavior: "sql",
+      sqlBehavior: "sql"
+    })));
+    this.config.where = where;
+    return this;
+  }
+  /**
+  * Adds a `having` clause to the query.
+  *
+  * Calling this method will select only those rows that fulfill a specified condition. It is typically used with aggregate functions to filter the aggregated data based on a specified condition.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
+  *
+  * @param having the `having` clause.
+  *
+  * @example
+  *
+  * ```ts
+  * // Select all brands with more than one car
+  * await db.select({
+  * 	brand: cars.brand,
+  * 	count: sql<number>`cast(count(${cars.id}) as int)`,
+  * })
+  *   .from(cars)
+  *   .groupBy(cars.brand)
+  *   .having(({ count }) => gt(count, 1));
+  * ```
+  */
+  having(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;
+  }
+  /**
+  * Adds a `limit` clause to the query.
+  *
+  * Calling this method will set the maximum number of rows that will be returned by this query.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
+  *
+  * @param limit the `limit` clause.
+  *
+  * @example
+  *
+  * ```ts
+  * // Get the first 10 people from this query.
+  * await db.select().from(people).limit(10);
+  * ```
+  */
+  limit(limit) {
+    if (this.config.setOperators.length > 0) this.config.setOperators.at(-1).limit = limit;
+    else this.config.limit = limit;
+    return this;
+  }
+  /**
+  * Adds an `offset` clause to the query.
+  *
+  * Calling this method will skip a number of rows when returning results from this query.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
+  *
+  * @param offset the `offset` clause.
+  *
+  * @example
+  *
+  * ```ts
+  * // Get the 10th-20th people from this query.
+  * await db.select().from(people).offset(10).limit(10);
+  * ```
+  */
+  offset(offset) {
+    if (this.config.setOperators.length > 0) this.config.setOperators.at(-1).offset = offset;
+    else this.config.offset = offset;
+    return this;
+  }
+  $withCache(config) {
+    this.cacheConfig = config === void 0 ? {
+      config: {},
+      enabled: true,
+      autoInvalidate: true
+    } : config === false ? { enabled: false } : {
+      enabled: true,
+      autoInvalidate: true,
+      ...config
+    };
+    return this;
+  }
+  getSQL() {
+    this.config.fieldsFlat = orderSelectedFields(this.config.fields);
+    return this.dialect.buildSelectQuery(this.config);
+  }
+  toSQL() {
+    return this.dialect.sqlToQuery(this.getSQL());
+  }
+  as(alias) {
+    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, alias, false, [...new Set(usedTables)]), new SelectionProxyHandler({
+      alias,
+      sqlAliasedBehavior: "alias",
+      sqlBehavior: "error"
+    }));
+  }
+  /** @internal */
+  getSelectedFields() {
+    return new Proxy(this.config.fields, new SelectionProxyHandler({
+      alias: this.tableName,
+      sqlAliasedBehavior: "alias",
+      sqlBehavior: "error"
+    }));
+  }
+  /** @internal */
+  withoutSelectionCastCodecs() {
+    return this;
+  }
+  $dynamic() {
+    return this;
+  }
+};
+function createSetOperator(type, isAll) {
+  return (leftSelect, rightSelect, ...restSelects) => {
+    const setOperators = [rightSelect, ...restSelects].map((select) => ({
+      type,
+      isAll,
+      rightSelect: select
+    }));
+    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 getSQLiteSetOperators = () => ({
+  union,
+  unionAll,
+  intersect,
+  except
+});
+var union = createSetOperator("union", false);
+var unionAll = createSetOperator("union", true);
+var intersect = createSetOperator("intersect", false);
+var except = createSetOperator("except", false);
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/dialect.js
+var SQLiteDialect = class {
+  static [entityKind] = "SQLiteDialect";
+  mapperGenerators;
+  constructor(config) {
+    this.mapperGenerators = config?.useJitMappers ? {
+      rows: makeJitQueryMapper,
+      relationalRows: makeJitRqbMapper
+    } : {
+      rows: makeDefaultQueryMapper,
+      relationalRows: makeDefaultRqbMapper
+    };
+  }
+  escapeName(name2) {
+    return `"${name2.replace(/"/g, '""')}"`;
+  }
+  escapeParam(_num) {
+    return "?";
+  }
+  escapeString(str) {
+    return `'${str.replace(/'/g, "''")}'`;
+  }
+  buildWithCTE(queries) {
+    if (!queries?.length) return void 0;
+    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, where, returning, withList, limit, orderBy }) {
+    const withSql = this.buildWithCTE(withList);
+    const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
+    return sql`${withSql}delete from ${table}${where ? sql` where ${where}` : void 0}${returningSql}${this.buildOrderBy(orderBy)}${this.buildLimit(limit)}`;
+  }
+  buildUpdateSet(table, set) {
+    const tableColumns = table[Table.Symbol.Columns];
+    const columnNames = Object.keys(tableColumns).filter((colName) => set[colName] !== void 0 || tableColumns[colName]?.onUpdateFn !== void 0);
+    const setLength = columnNames.length;
+    return sql.join(columnNames.flatMap((colName, i) => {
+      const col = tableColumns[colName];
+      const onUpdateFnResult = col.onUpdateFn?.();
+      const value = set[colName] ?? (is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col));
+      const res = sql`${sql.identifier(col.name)} = ${value}`;
+      if (i < setLength - 1) return [res, sql.raw(", ")];
+      return [res];
+    }));
+  }
+  buildUpdateQuery({ table, set, where, returning, withList, joins, from, limit, orderBy }) {
+    const withSql = this.buildWithCTE(withList);
+    const setSql = this.buildUpdateSet(table, 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 })}` : void 0;
+    return sql`${withSql}update ${table} set ${setSql}${fromSql}${joinsSql}${where ? sql` where ${where}` : void 0}${returningSql}${this.buildOrderBy(orderBy)}${this.buildLimit(limit)}`;
+  }
+  /**
+  * Builds selection SQL with provided fields/expressions
+  *
+  * Examples:
+  *
+  * `select <selection> from`
+  *
+  * `insert ... returning <selection>`
+  *
+  * If `isSingleTable` is true, then columns won't be prefixed with table name
+  */
+  buildSelection(fields, { isSingleTable = false } = {}) {
+    const columnsLen = fields.length;
+    const chunks = fields.flatMap(({ field }, i) => {
+      const chunk = [];
+      if (is(field, SQL.Aliased)) if (field.isSelectionField) {
+        if (!isSingleTable && field.origin !== void 0) chunk.push(sql.identifier(field.origin), sql.raw("."));
+        chunk.push(sql.identifier(field.fieldAlias));
+      } else {
+        const query = field.sql;
+        if (isSingleTable) {
+          const newSql = new SQL(query.queryChunks.map((c) => {
+            if (is(c, Column)) return sql.identifier(c.name);
+            return c;
+          }));
+          chunk.push(query.shouldInlineParams ? newSql.inlineParams() : newSql);
+        } else chunk.push(query);
+        chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
+      }
+      else if (is(field, SQL)) {
+        const query = field;
+        if (isSingleTable) {
+          const newSql = new SQL(query.queryChunks.map((c) => {
+            if (is(c, Column)) return sql.identifier(c.name);
+            return c;
+          }));
+          chunk.push(query.shouldInlineParams ? newSql.inlineParams() : newSql);
+        } else chunk.push(query);
+      } else if (is(field, Column)) if (field.columnType === "SQLiteNumericBigInt" || field.columnType === "SQLiteNumeric") if (isSingleTable) chunk.push(field.isAlias ? sql`cast(${sql.identifier(getOriginalColumnFromAlias(field).name)} as text) as ${field}` : sql`cast(${sql.identifier(field.name)} as text)`);
+      else chunk.push(field.isAlias ? sql`cast(${getOriginalColumnFromAlias(field)} as text) as ${field}` : sql`cast(${field} as text)`);
+      else if (isSingleTable) chunk.push(field.isAlias ? sql`${sql.identifier(getOriginalColumnFromAlias(field).name)} as ${field}` : sql.identifier(field.name));
+      else chunk.push(field.isAlias ? sql`${getOriginalColumnFromAlias(field)} as ${field}` : field);
+      else if (is(field, Subquery)) if (!field._.isWith) chunk.push(sql`(${field._.sql}) ${sql.identifier(field._.alias)}`);
+      else chunk.push(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 table = joinMeta.table;
+      const onSql = joinMeta.on ? sql` on ${joinMeta.on}` : void 0;
+      if (is(table, SQLiteTable)) {
+        const tableName = table[SQLiteTable.Symbol.Name];
+        const tableSchema = table[SQLiteTable.Symbol.Schema];
+        const origTableName = table[SQLiteTable.Symbol.OriginalName];
+        const alias = tableName === origTableName ? void 0 : joinMeta.alias;
+        joinsArray.push(sql`${sql.raw(joinMeta.joinType)} join ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`}${onSql}`);
+      } else joinsArray.push(sql`${sql.raw(joinMeta.joinType)} join ${table}${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}` : void 0;
+  }
+  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)}` : void 0;
+  }
+  buildFromTable(table) {
+    if (is(table, Table) && table[Table.Symbol.IsAlias]) return sql`${sql`${sql.identifier(table[Table.Symbol.Schema] ?? "")}.`.if(table[Table.Symbol.Schema])}${sql.identifier(table[Table.Symbol.OriginalName])} ${sql.identifier(table[Table.Symbol.Name])}`;
+    if (is(table, View) && table[ViewBaseConfig].isAlias) {
+      let fullName = sql`${sql.identifier(table[ViewBaseConfig].originalName)}`;
+      if (table[ViewBaseConfig].schema) fullName = sql`${sql.identifier(table[ViewBaseConfig].schema)}.${fullName}`;
+      return sql`${fullName} ${sql.identifier(table[ViewBaseConfig].name)}`;
+    }
+    return table;
+  }
+  buildSelectQuery({ withList, fields, fieldsFlat, where, having, table, 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(table, Subquery) ? table._.alias : is(table, SQLiteViewBase) ? table[ViewBaseConfig].name : is(table, SQL) ? void 0 : getTableName(table)) && !((table2) => joins?.some(({ alias }) => alias === (table2[Table.Symbol.IsAlias] ? getTableName(table2) : table2[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` : void 0;
+    const selection = this.buildSelection(fieldsList, { isSingleTable });
+    const tableSql = this.buildFromTable(table);
+    const joinsSql = this.buildJoins(joins);
+    const whereSql = where ? sql` where ${where}` : void 0;
+    const havingSql = having ? sql` having ${having}` : void 0;
+    const groupByList = [];
+    if (groupBy) for (const [index2, groupByValue] of groupBy.entries()) {
+      groupByList.push(groupByValue);
+      if (index2 < groupBy.length - 1) groupByList.push(sql`, `);
+    }
+    const finalQuery = sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupByList.length > 0 ? sql` group by ${sql.join(groupByList)}` : void 0}${havingSql}${this.buildOrderBy(orderBy)}${this.buildLimit(limit)}${offset ? sql` offset ${offset}` : void 0}`;
+    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(chunk.name);
+        }
+        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}` : void 0;
+    const operatorChunk = sql.raw(`${type} ${isAll ? "all " : ""}`);
+    const offsetSql = offset ? sql` offset ${offset}` : void 0;
+    return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
+  }
+  buildInsertQuery({ table, values: valuesOrSelect, onConflict, returning, withList, select }) {
+    const valuesSqlList = [];
+    const columns = table[Table.Symbol.Columns];
+    const colEntries = Object.entries(columns);
+    const colEntriesFiltered = select && !is(valuesOrSelect, SQL) ? Object.keys(valuesOrSelect.getSelectedFields()).map((key) => [key, columns[key]]) : colEntries.filter(([_, col]) => !col.shouldDisableInsert());
+    const insertOrder = colEntriesFiltered.map(([, column]) => sql.identifier(column.name));
+    if (select) {
+      const select2 = valuesOrSelect;
+      if (is(select2, SQL)) valuesSqlList.push(select2);
+      else valuesSqlList.push(select2.getSQL());
+    } else {
+      const values = valuesOrSelect;
+      valuesSqlList.push(sql.raw("values "));
+      for (const [valueIndex, value] of values.entries()) {
+        const valueList = [];
+        for (const [fieldName, col] of colEntriesFiltered) {
+          const colValue = value[fieldName];
+          if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
+            let defaultValue;
+            if (col.default !== null && col.default !== void 0) defaultValue = is(col.default, SQL) ? col.default : sql.param(col.default, col);
+            else if (col.defaultFn !== void 0) {
+              const defaultFnResult = col.defaultFn();
+              defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
+            } else if (!col.default && col.onUpdateFn !== void 0) {
+              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 })}` : void 0;
+    return sql`${withSql}insert into ${table} ${insertOrder} ${valuesSql}${onConflict?.length ? sql.join(onConflict) : void 0}${returningSql}`;
+  }
+  sqlToQuery(sql2, invokeSource) {
+    return sql2.toQuery({
+      escapeName: this.escapeName,
+      escapeParam: this.escapeParam,
+      escapeString: this.escapeString,
+      invokeSource
+    });
+  }
+  nestedSelectionerror() {
+    throw new DrizzleError({ message: `Views with nested selections are not supported by the relational query builder` });
+  }
+  buildRqbColumn(table, column, key, inJson) {
+    if (is(column, Column)) {
+      const name2 = sql`${table}.${sql.identifier(column.name)}`;
+      switch (column.columnType) {
+        case "SQLiteBigInt":
+        case "SQLiteBlobJson":
+        case "SQLiteBlobBuffer":
+          if (!inJson) return sql`${name2} as ${sql.identifier(key)}`;
+          return sql`hex(${name2}) as ${sql.identifier(key)}`;
+        case "SQLiteNumeric":
+        case "SQLiteNumericNumber":
+        case "SQLiteNumericBigInt":
+          return sql`cast(${name2} as text) as ${sql.identifier(key)}`;
+        case "SQLiteCustomColumn":
+          if (!inJson) return sql`${name2} as ${sql.identifier(key)}`;
+          return sql`${column.jsonSelectIdentifier(name2, sql)} as ${sql.identifier(key)}`;
+        default:
+          return sql`${name2} as ${sql.identifier(key)}`;
+      }
+    }
+    return sql`${table}.${is(column, SQL.Aliased) ? sql.identifier(column.fieldAlias) : isSQLWrapper(column) ? sql.identifier(key) : this.nestedSelectionerror()} as ${sql.identifier(key)}`;
+  }
+  unwrapAllColumns = (table, selection, inJson) => {
+    return sql.join(Object.entries(table[TableColumns]).map(([k, v]) => {
+      selection.push({
+        key: k,
+        field: v
+      });
+      return this.buildRqbColumn(table, v, k, inJson);
+    }), sql`, `);
+  };
+  getSelectedTableColumns = (table, columns) => {
+    const selectedColumns = [];
+    const columnContainer = table[TableColumns];
+    const entries = Object.entries(columns);
+    let colSelectionMode;
+    for (const [k, v] of entries) {
+      if (v === void 0) continue;
+      colSelectionMode = colSelectionMode || v;
+      if (v) {
+        const column = columnContainer[k];
+        selectedColumns.push({
+          column,
+          tsName: k
+        });
+      }
+    }
+    if (colSelectionMode === false) for (const [k, v] of Object.entries(columnContainer)) {
+      if (columns[k] === false) continue;
+      selectedColumns.push({
+        column: v,
+        tsName: k
+      });
+    }
+    return selectedColumns;
+  };
+  buildColumns = (table, selection, inJson, params) => params?.columns ? (() => {
+    const columnIdentifiers = [];
+    const selectedColumns = this.getSelectedTableColumns(table, params?.columns);
+    for (const { column, tsName } of selectedColumns) {
+      columnIdentifiers.push(this.buildRqbColumn(table, column, tsName, inJson));
+      selection.push({
+        key: tsName,
+        field: column
+      });
+    }
+    return columnIdentifiers.length ? sql.join(columnIdentifiers, sql`, `) : void 0;
+  })() : this.unwrapAllColumns(table, selection, inJson);
+  buildRelationalQuery({ schema, table, tableConfig, queryConfig: config, relationWhere, mode, isNested, errorPath, depth, throughJoin, jsonb }) {
+    const selection = [];
+    const isSingle = mode === "first";
+    const params = config === true ? void 0 : config;
+    const currentPath = errorPath ?? "";
+    const currentDepth = depth ?? 0;
+    if (!currentDepth) table = aliasedTable(table, `d${currentDepth}`);
+    const limit = isSingle ? 1 : params?.limit;
+    const offset = params?.offset;
+    const columns = this.buildColumns(table, selection, !!isNested, params);
+    const where = params?.where && relationWhere ? and(relationsFilterToSQL(table, params.where, tableConfig.relations, schema), relationWhere) : params?.where ? relationsFilterToSQL(table, params.where, tableConfig.relations, schema) : relationWhere;
+    const order = params?.orderBy ? relationsOrderToSQL(table, params.orderBy) : void 0;
+    const extras = params?.extras ? relationExtrasToSQL(table, params.extras) : void 0;
+    if (extras) selection.push(...extras.selection);
+    const joins = params ? (() => {
+      const { with: joins2 } = params;
+      if (!joins2) return;
+      const withEntries = Object.entries(joins2).filter(([_, v]) => v);
+      if (!withEntries.length) return;
+      return sql.join(withEntries.map(([k, join]) => {
+        const relation = tableConfig.relations[k];
+        const isSingle2 = is(relation, One);
+        const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
+        const throughTable = relation.throughTable ? aliasedTable(relation.throughTable, `tr${currentDepth}`) : void 0;
+        const { filter, joinCondition } = relationToSQL(relation, table, targetTable, throughTable);
+        const throughJoin2 = throughTable ? sql` inner join ${getTableAsAliasSQL(throughTable)} on ${joinCondition}` : void 0;
+        const innerQuery = this.buildRelationalQuery({
+          table: targetTable,
+          mode: isSingle2 ? "first" : "many",
+          schema,
+          queryConfig: join,
+          tableConfig: schema[relation.targetTableName],
+          relationWhere: filter,
+          isNested: true,
+          errorPath: `${currentPath.length ? `${currentPath}.` : ""}${k}`,
+          depth: currentDepth + 1,
+          throughJoin: throughJoin2,
+          jsonb
+        });
+        selection.push({
+          field: targetTable,
+          key: k,
+          selection: innerQuery.selection,
+          isArray: !isSingle2,
+          isOptional: (relation.optional ?? false) || join !== true && !!join.where
+        });
+        const jsonColumns = sql.join(innerQuery.selection.map((s) => {
+          return sql`${sql.raw(this.escapeString(s.key))}, ${s.selection ? sql`${jsonb}(${sql.identifier(s.key)})` : sql.identifier(s.key)}`;
+        }), sql`, `);
+        const json = isNested ? jsonb : sql`json`;
+        return isSingle2 ? sql`(select ${json}_object(${jsonColumns}) as ${sql.identifier("r")} from (${innerQuery.sql}) as ${sql.identifier("t")}) as ${sql.identifier(k)}` : sql`coalesce((select ${json}_group_array(json_object(${jsonColumns})) as ${sql.identifier("r")} from (${innerQuery.sql}) as ${sql.identifier("t")}), ${jsonb}_array()) as ${sql.identifier(k)}`;
+      }), sql`, `);
+    })() : void 0;
+    const selectionArr = [
+      columns,
+      extras?.sql,
+      joins
+    ].filter((e) => e !== void 0);
+    if (!selectionArr.length) throw new DrizzleError({ message: `No fields selected for table "${tableConfig.name}"${currentPath ? ` ("${currentPath}")` : ""}` });
+    return {
+      sql: sql`select ${sql.join(selectionArr, sql`, `)} from ${getTableAsAliasSQL(table)}${throughJoin}${sql` where ${where}`.if(where)}${sql` order by ${order}`.if(order)}${sql` limit ${limit}`.if(limit !== void 0)}${sql` offset ${offset}`.if(offset !== void 0)}`,
+      selection
+    };
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/query-builders/query-builder.js
+var QueryBuilder = class {
+  static [entityKind] = "SQLiteQueryBuilder";
+  dialect;
+  dialectConfig;
+  constructor(dialect) {
+    this.dialect = is(dialect, SQLiteDialect) ? dialect : void 0;
+    this.dialectConfig = is(dialect, SQLiteDialect) ? void 0 : dialect;
+  }
+  $with = (alias, 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() ?? {} : {}), alias, true), new SelectionProxyHandler({
+        alias,
+        sqlAliasedBehavior: "alias",
+        sqlBehavior: "error"
+      }));
+    };
+    return { as };
+  };
+  with(...queries) {
+    const self = this;
+    function select(fields) {
+      return new SQLiteSelectBuilder({
+        fields: fields ?? void 0,
+        session: void 0,
+        dialect: self.getDialect(),
+        withList: queries
+      });
+    }
+    function selectDistinct(fields) {
+      return new SQLiteSelectBuilder({
+        fields: fields ?? void 0,
+        session: void 0,
+        dialect: self.getDialect(),
+        withList: queries,
+        distinct: true
+      });
+    }
+    return {
+      select,
+      selectDistinct
+    };
+  }
+  select(fields) {
+    return new SQLiteSelectBuilder({
+      fields: fields ?? void 0,
+      session: void 0,
+      dialect: this.getDialect()
+    });
+  }
+  selectDistinct(fields) {
+    return new SQLiteSelectBuilder({
+      fields: fields ?? void 0,
+      session: void 0,
+      dialect: this.getDialect(),
+      distinct: true
+    });
+  }
+  getDialect() {
+    if (!this.dialect) this.dialect = new SQLiteDialect(this.dialectConfig);
+    return this.dialect;
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/query-builders/count.js
+var SQLiteCountBuilder = class SQLiteCountBuilder2 extends SQL {
+  static [entityKind] = "SQLiteCountBuilder";
+  dialect;
+  session;
+  static buildCount(source, filters, parens) {
+    const query = sql`select count(*) from ${source}${sql` where ${filters}`.if(filters)}`;
+    return parens ? sql`(${query})` : query;
+  }
+  constructor(countConfig) {
+    super(SQLiteCountBuilder2.buildCount(countConfig.source, countConfig.filters, true).queryChunks);
+    this.countConfig = countConfig;
+    this.dialect = countConfig.dialect;
+    this.session = countConfig.session;
+    this.mapWith((e) => {
+      if (typeof e === "number") return e;
+      return Number(e ?? 0);
+    });
+  }
+  executableSql;
+  build() {
+    if (!this.executableSql) {
+      const { source, filters } = this.countConfig;
+      this.executableSql = SQLiteCountBuilder2.buildCount(source, filters);
+    }
+    return this.dialect.sqlToQuery(this.executableSql);
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/async/count.js
+var SQLiteAsyncCountBuilder = class extends SQLiteCountBuilder {
+  static [entityKind] = "SQLiteAsyncCountBuilder";
+  constructor(countConfig) {
+    super(countConfig);
+  }
+  /** @internal */
+  executeRaw(placeholderValues) {
+    return this.session.prepareQuery(this.build(), "arrays", false, "all", (rows) => {
+      const v = rows[0]?.[0];
+      if (typeof v === "number") return v;
+      return v ? Number(v) : 0;
+    }).execute(placeholderValues);
+  }
+  async execute(placeholderValues) {
+    return await this.executeRaw(placeholderValues);
+  }
+};
+applyMixins(SQLiteAsyncCountBuilder, [QueryPromise]);
+var SQLiteSyncCountBuilder = class extends SQLiteAsyncCountBuilder {
+  static [entityKind] = "SQLiteSyncCountBuilder";
+  sync(placeholderValues) {
+    return this.executeRaw(placeholderValues).sync();
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/query-builders/query.js
+var RelationalQueryBuilder = class {
+  static [entityKind] = "SQLiteRelationalQueryBuilderV2";
+  constructor(mode, schema, table, tableConfig, dialect, session, forbidJsonb, builder = SQLiteRelationalQuery) {
+    this.mode = mode;
+    this.schema = schema;
+    this.table = table;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+    this.forbidJsonb = forbidJsonb;
+    this.builder = builder;
+  }
+  findMany(config) {
+    return new this.builder(this.mode, this.schema, this.table, this.tableConfig, this.dialect, this.session, config ?? true, "many", this.forbidJsonb);
+  }
+  findFirst(config) {
+    return new this.builder(this.mode, this.schema, this.table, this.tableConfig, this.dialect, this.session, config ?? true, "first", this.forbidJsonb);
+  }
+};
+var SQLiteRelationalQuery = class {
+  static [entityKind] = "SQLiteRelationalQueryV2";
+  /** @internal */
+  mode;
+  /** @internal */
+  table;
+  /** @internal */
+  resultKind;
+  constructor(resultKind, schema, table, tableConfig, dialect, session, config, mode, forbidJsonb) {
+    this.schema = schema;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+    this.config = config;
+    this.forbidJsonb = forbidJsonb;
+    this.resultKind = resultKind;
+    this.mode = mode;
+    this.table = table;
+  }
+  getSQL() {
+    return this._getQuery().sql;
+  }
+  _getQuery() {
+    const jsonb = this.forbidJsonb ? sql`json` : sql`jsonb`;
+    return this.dialect.buildRelationalQuery({
+      schema: this.schema,
+      table: this.table,
+      tableConfig: this.tableConfig,
+      queryConfig: this.config,
+      mode: this.mode,
+      jsonb
+    });
+  }
+  _toSQL() {
+    const query = this._getQuery();
+    return {
+      query,
+      builtQuery: this.dialect.sqlToQuery(query.sql)
+    };
+  }
+  toSQL() {
+    return this._toSQL().builtQuery;
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/async/query.js
+var SQLiteAsyncRelationalQuery = class extends SQLiteRelationalQuery {
+  static [entityKind] = "SQLiteAsyncRelationalQueryV2";
+  /** @internal */
+  _prepare(prepare = false) {
+    const { query, builtQuery } = this._toSQL();
+    const mapper = this.dialect.mapperGenerators.relationalRows({
+      isFirst: this.mode === "first",
+      parseJson: true,
+      parseJsonIfString: false,
+      rootJsonMappers: false,
+      selection: query.selection,
+      arrayModeRoot: true
+    });
+    return this.session.prepareQuery(builtQuery, "arrays", prepare, "all", mapper);
+  }
+  prepare() {
+    return this._prepare(true);
+  }
+  async execute(placeholderValues) {
+    return this._prepare().execute(placeholderValues);
+  }
+};
+var SQLiteSyncRelationalQuery = class extends SQLiteAsyncRelationalQuery {
+  static [entityKind] = "SQLiteSyncRelationalQueryV2";
+  sync(placeholderValues) {
+    return this._prepare().execute(placeholderValues).sync();
+  }
+};
+applyMixins(SQLiteAsyncRelationalQuery, [QueryPromise]);
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/query-builders/delete.js
+var SQLiteDeleteBase = class {
+  static [entityKind] = "SQLiteDelete";
+  /** @internal */
+  config;
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.config = {
+      table,
+      withList
+    };
+  }
+  /**
+  * Adds a `where` clause to the query.
+  *
+  * Calling this method will delete only those rows that fulfill a specified condition.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/delete}
+  *
+  * @param where the `where` clause.
+  *
+  * @example
+  * You can use conditional operators and `sql function` to filter the rows to be deleted.
+  *
+  * ```ts
+  * // Delete all cars with green color
+  * db.delete(cars).where(eq(cars.color, 'green'));
+  * // or
+  * db.delete(cars).where(sql`${cars.color} = 'green'`)
+  * ```
+  *
+  * You can logically combine conditional operators with `and()` and `or()` operators:
+  *
+  * ```ts
+  * // Delete all BMW cars with a green color
+  * db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+  *
+  * // Delete all cars with the green or blue color
+  * db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+  * ```
+  */
+  where(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() {
+    return this.dialect.sqlToQuery(this.getSQL());
+  }
+  $dynamic() {
+    return this;
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/async/delete.js
+var SQLiteAsyncDeleteBase = class extends SQLiteDeleteBase {
+  static [entityKind] = "SQLiteAsyncDelete";
+  /** @internal */
+  _prepare(prepare = false) {
+    return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), "arrays", prepare, this.config.returning ? "all" : "run", this.config.returning ? this.dialect.mapperGenerators.rows(this.config.returning, void 0) : void 0, {
+      type: "delete",
+      tables: extractUsedTable(this.config.table)
+    });
+  }
+  prepare() {
+    return this._prepare(true);
+  }
+  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);
+  }
+};
+applyMixins(SQLiteAsyncDeleteBase, [QueryPromise]);
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/query-builders/insert.js
+var SQLiteInsertBuilder = class {
+  static [entityKind] = "SQLiteInsertBuilder";
+  constructor(table, session, dialect, withList, builder = SQLiteInsertBase) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+    this.builder = builder;
+  }
+  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 this.builder(this.table, mappedValues, this.session, this.dialect, this.withList);
+  }
+  select(selectQuery) {
+    const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder()) : selectQuery;
+    if (!is(select, SQL)) {
+      const insertCols = Object.keys(this.table[Table.Symbol.Columns]);
+      const selected = Object.keys(select._.selectedFields);
+      for (const col of selected) if (!insertCols.includes(col)) throw new Error(`Insert select error: column "${col}" does not exist in table "${this.table[Table.Symbol.Name]}"`);
+    }
+    return new this.builder(this.table, select, this.session, this.dialect, this.withList, true);
+  }
+};
+var SQLiteInsertBase = class {
+  static [entityKind] = "SQLiteInsert";
+  /** @internal */
+  config;
+  constructor(table, values, session, dialect, withList, select) {
+    this.session = session;
+    this.dialect = dialect;
+    this.config = {
+      table,
+      values,
+      withList,
+      select
+    };
+  }
+  returning(fields = this.config.table[SQLiteTable.Symbol.Columns]) {
+    this.config.returning = orderSelectedFields(fields);
+    return this;
+  }
+  /**
+  * Adds an `on conflict do nothing` clause to the query.
+  *
+  * Calling this method simply avoids inserting a row as its alternative action.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
+  *
+  * @param config The `target` and `where` clauses.
+  *
+  * @example
+  * ```ts
+  * // Insert one row and cancel the insert if there's a conflict
+  * await db.insert(cars)
+  *   .values({ id: 1, brand: 'BMW' })
+  *   .onConflictDoNothing();
+  *
+  * // Explicitly specify conflict target
+  * await db.insert(cars)
+  *   .values({ id: 1, brand: 'BMW' })
+  *   .onConflictDoNothing({ target: cars.id });
+  * ```
+  */
+  onConflictDoNothing(config = {}) {
+    if (!this.config.onConflict) this.config.onConflict = [];
+    if (config.target === void 0) 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;
+  }
+  /**
+  * Adds an `on conflict do update` clause to the query.
+  *
+  * Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
+  *
+  * @param config The `target`, `set` and `where` clauses.
+  *
+  * @example
+  * ```ts
+  * // Update the row if there's a conflict
+  * await db.insert(cars)
+  *   .values({ id: 1, brand: 'BMW' })
+  *   .onConflictDoUpdate({
+  *     target: cars.id,
+  *     set: { brand: 'Porsche' }
+  *   });
+  *
+  * // Upsert with 'where' clause
+  * await db.insert(cars)
+  *   .values({ id: 1, brand: 'BMW' })
+  *   .onConflictDoUpdate({
+  *     target: cars.id,
+  *     set: { brand: 'newBMW' },
+  *     where: sql`${cars.createdAt} > '2023-01-01'::date`,
+  *   });
+  * ```
+  */
+  onConflictDoUpdate(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}` : void 0;
+    const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
+    const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
+    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() {
+    return this.dialect.sqlToQuery(this.getSQL());
+  }
+  $dynamic() {
+    return this;
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/async/insert.js
+var SQLiteAsyncInsertBase = class extends SQLiteInsertBase {
+  static [entityKind] = "SQLiteAsyncInsert";
+  /** @internal */
+  _prepare(prepare = false) {
+    return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), "arrays", prepare, this.config.returning ? "all" : "run", this.config.returning ? this.dialect.mapperGenerators.rows(this.config.returning, void 0) : void 0, {
+      type: "insert",
+      tables: extractUsedTable(this.config.table)
+    });
+  }
+  prepare() {
+    return this._prepare(true);
+  }
+  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._prepare().execute();
+  }
+};
+applyMixins(SQLiteAsyncInsertBase, [QueryPromise]);
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/query-builders/raw.js
+var SQLiteRaw = class {
+  static [entityKind] = "SQLiteRaw";
+  constructor(prepared, sql2, query) {
+    this.prepared = prepared;
+    this.sql = sql2;
+    this.query = query;
+  }
+  getSQL() {
+    return this.sql;
+  }
+  getQuery() {
+    return this.query;
+  }
+  _prepare() {
+    return this.prepared;
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/async/raw.js
+var SQLiteAsyncRaw = class extends SQLiteRaw {
+  static [entityKind] = "SQLiteAsyncRaw";
+  constructor(prepared, sql2, query) {
+    super(prepared, sql2, query);
+  }
+  execute(placeholderValues) {
+    return this.prepared.execute(placeholderValues);
+  }
+};
+applyMixins(SQLiteAsyncRaw, [QueryPromise]);
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/async/select.js
+var SQLiteAsyncSelectBase = class extends SQLiteSelectBase {
+  static [entityKind] = "SQLiteAsyncSelect";
+  /** @internal */
+  _prepare(prepare = false) {
+    const query = this.dialect.sqlToQuery(this.getSQL());
+    const fieldsList = this.config.fieldsFlat;
+    const mapper = this.dialect.mapperGenerators.rows(fieldsList, this.joinsNotNullableMap);
+    return this.session.prepareQuery(query, "arrays", prepare, "all", mapper, {
+      type: "select",
+      tables: [...this.usedTables]
+    }, this.cacheConfig);
+  }
+  prepare() {
+    return this._prepare(true);
+  }
+  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._prepare().execute();
+  }
+};
+applyMixins(SQLiteAsyncSelectBase, [QueryPromise]);
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/query-builders/update.js
+var SQLiteUpdateBuilder = class {
+  static [entityKind] = "SQLiteUpdateBuilder";
+  constructor(table, session, dialect, withList, builder = SQLiteUpdateBase) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+    this.builder = builder;
+  }
+  set(values) {
+    return new this.builder(this.table, mapUpdateSet(this.table, values), this.session, this.dialect, this.withList);
+  }
+};
+var SQLiteUpdateBase = class {
+  static [entityKind] = "SQLiteUpdate";
+  /** @internal */
+  config;
+  constructor(table, set, session, dialect, withList) {
+    this.session = session;
+    this.dialect = dialect;
+    this.config = {
+      set,
+      table,
+      withList,
+      joins: []
+    };
+  }
+  from(source) {
+    this.config.from = source;
+    return this;
+  }
+  createJoin(joinType) {
+    return ((table, on) => {
+      const tableName = getTableLikeName(table);
+      if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+      if (typeof on === "function") {
+        const from = this.config.from ? is(table, SQLiteTable) ? table[Table.Symbol.Columns] : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? table[ViewBaseConfig].selectedFields : void 0 : void 0;
+        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,
+        joinType,
+        alias: tableName
+      });
+      return this;
+    });
+  }
+  leftJoin = this.createJoin("left");
+  rightJoin = this.createJoin("right");
+  innerJoin = this.createJoin("inner");
+  fullJoin = this.createJoin("full");
+  /**
+  * Adds a 'where' clause to the query.
+  *
+  * Calling this method will update only those rows that fulfill a specified condition.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/update}
+  *
+  * @param where the 'where' clause.
+  *
+  * @example
+  * You can use conditional operators and `sql function` to filter the rows to be updated.
+  *
+  * ```ts
+  * // Update all cars with green color
+  * db.update(cars).set({ color: 'red' })
+  *   .where(eq(cars.color, 'green'));
+  * // or
+  * db.update(cars).set({ color: 'red' })
+  *   .where(sql`${cars.color} = 'green'`)
+  * ```
+  *
+  * You can logically combine conditional operators with `and()` and `or()` operators:
+  *
+  * ```ts
+  * // Update all BMW cars with a green color
+  * db.update(cars).set({ color: 'red' })
+  *   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+  *
+  * // Update all cars with the green or blue color
+  * db.update(cars).set({ color: 'red' })
+  *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+  * ```
+  */
+  where(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() {
+    return this.dialect.sqlToQuery(this.getSQL());
+  }
+  $dynamic() {
+    return this;
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/async/update.js
+var SQLiteAsyncUpdateBase = class extends SQLiteUpdateBase {
+  static [entityKind] = "SQLiteAsyncUpdate";
+  /** @internal */
+  _prepare(prepare = false) {
+    return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), "arrays", prepare, this.config.returning ? "all" : "run", this.config.returning ? this.dialect.mapperGenerators.rows(this.config.returning, void 0) : void 0, {
+      type: "update",
+      tables: extractUsedTable(this.config.table)
+    });
+  }
+  prepare() {
+    return this._prepare(true);
+  }
+  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();
+  }
+};
+applyMixins(SQLiteAsyncUpdateBase, [QueryPromise]);
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/async/db.js
+var SQLiteAsyncDatabase = class {
+  static [entityKind] = "BaseSQLiteDatabase";
+  query;
+  constructor(resultKind, dialect, session, relations, forbidJsonb) {
+    this.resultKind = resultKind;
+    this.dialect = dialect;
+    this.session = session;
+    this.forbidJsonb = forbidJsonb;
+    this._ = {
+      relations,
+      session,
+      resultKind
+    };
+    this.query = {};
+    for (const [tableName, relation] of Object.entries(relations)) this.query[tableName] = new RelationalQueryBuilder(resultKind, relations, relations[relation.name].table, relation, dialect, session, forbidJsonb, resultKind === "sync" ? SQLiteSyncRelationalQuery : SQLiteAsyncRelationalQuery);
+    this.$cache = { invalidate: async (_params) => {
+    } };
+  }
+  /**
+  * Creates a subquery that defines a temporary named result set as a CTE.
+  *
+  * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+  *
+  * @param alias The alias for the subquery.
+  *
+  * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
+  *
+  * @example
+  *
+  * ```ts
+  * // Create a subquery with alias 'sq' and use it in the select query
+  * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+  *
+  * const result = await db.with(sq).select().from(sq);
+  * ```
+  *
+  * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
+  *
+  * ```ts
+  * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
+  * const sq = db.$with('sq').as(db.select({
+  *   name: sql<string>`upper(${users.name})`.as('name'),
+  * })
+  * .from(users));
+  *
+  * const result = await db.with(sq).select({ name: sq.name }).from(sq);
+  * ```
+  */
+  $with = (alias, 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() ?? {} : {}), alias, true), new SelectionProxyHandler({
+        alias,
+        sqlAliasedBehavior: "alias",
+        sqlBehavior: "error"
+      }));
+    };
+    return { as };
+  };
+  $count(source, filters) {
+    return this.resultKind === "async" ? new SQLiteAsyncCountBuilder({
+      source,
+      filters,
+      session: this.session,
+      dialect: this.dialect
+    }) : new SQLiteSyncCountBuilder({
+      source,
+      filters,
+      session: this.session,
+      dialect: this.dialect
+    });
+  }
+  /**
+  * Incorporates a previously defined CTE (using `$with`) into the main query.
+  *
+  * This method allows the main query to reference a temporary named result set.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+  *
+  * @param queries The CTEs to incorporate into the main query.
+  *
+  * @example
+  *
+  * ```ts
+  * // Define a subquery 'sq' as a CTE using $with
+  * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+  *
+  * // Incorporate the CTE 'sq' into the main query and select from it
+  * const result = await db.with(sq).select().from(sq);
+  * ```
+  */
+  with(...queries) {
+    const self = this;
+    function select(fields) {
+      return new SQLiteSelectBuilder({
+        fields: fields ?? void 0,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries
+      }, SQLiteAsyncSelectBase);
+    }
+    function selectDistinct(fields) {
+      return new SQLiteSelectBuilder({
+        fields: fields ?? void 0,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries,
+        distinct: true
+      }, SQLiteAsyncSelectBase);
+    }
+    function update(table) {
+      return new SQLiteUpdateBuilder(table, self.session, self.dialect, queries, SQLiteAsyncUpdateBase);
+    }
+    function insert(into) {
+      return new SQLiteInsertBuilder(into, self.session, self.dialect, queries, SQLiteAsyncInsertBase);
+    }
+    function delete_(from) {
+      return new SQLiteAsyncDeleteBase(from, self.session, self.dialect, queries);
+    }
+    return {
+      select,
+      selectDistinct,
+      update,
+      insert,
+      delete: delete_
+    };
+  }
+  select(fields) {
+    return new SQLiteSelectBuilder({
+      fields: fields ?? void 0,
+      session: this.session,
+      dialect: this.dialect
+    }, SQLiteAsyncSelectBase);
+  }
+  selectDistinct(fields) {
+    return new SQLiteSelectBuilder({
+      fields: fields ?? void 0,
+      session: this.session,
+      dialect: this.dialect,
+      distinct: true
+    }, SQLiteAsyncSelectBase);
+  }
+  /**
+  * Creates an update query.
+  *
+  * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+  *
+  * Use `.set()` method to specify which values to update.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/update}
+  *
+  * @param table The table to update.
+  *
+  * @example
+  *
+  * ```ts
+  * // Update all rows in the 'cars' table
+  * await db.update(cars).set({ color: 'red' });
+  *
+  * // Update rows with filters and conditions
+  * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+  *
+  * // Update with returning clause
+  * const updatedCar: Car[] = await db.update(cars)
+  *   .set({ color: 'red' })
+  *   .where(eq(cars.id, 1))
+  *   .returning();
+  * ```
+  */
+  update(table) {
+    return new SQLiteUpdateBuilder(table, this.session, this.dialect, void 0, SQLiteAsyncUpdateBase);
+  }
+  $cache;
+  /**
+  * Creates an insert query.
+  *
+  * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/insert}
+  *
+  * @param table The table to insert into.
+  *
+  * @example
+  *
+  * ```ts
+  * // Insert one row
+  * await db.insert(cars).values({ brand: 'BMW' });
+  *
+  * // Insert multiple rows
+  * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+  *
+  * // Insert with returning clause
+  * const insertedCar: Car[] = await db.insert(cars)
+  *   .values({ brand: 'BMW' })
+  *   .returning();
+  * ```
+  */
+  insert(into) {
+    return new SQLiteInsertBuilder(into, this.session, this.dialect, void 0, SQLiteAsyncInsertBase);
+  }
+  /**
+  * Creates a delete query.
+  *
+  * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/delete}
+  *
+  * @param table The table to delete from.
+  *
+  * @example
+  *
+  * ```ts
+  * // Delete all rows in the 'cars' table
+  * await db.delete(cars);
+  *
+  * // Delete rows with filters and conditions
+  * await db.delete(cars).where(eq(cars.color, 'green'));
+  *
+  * // Delete with returning clause
+  * const deletedCar: Car[] = await db.delete(cars)
+  *   .where(eq(cars.id, 1))
+  *   .returning();
+  * ```
+  */
+  delete(from) {
+    return new SQLiteAsyncDeleteBase(from, this.session, this.dialect);
+  }
+  run(query) {
+    const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
+    const builtQuery = this.dialect.sqlToQuery(sequel);
+    const prepared = this.session.prepareQuery(builtQuery, "raw", false, "run");
+    if (this.resultKind === "async") return new SQLiteAsyncRaw(prepared, sequel, builtQuery);
+    return this.session.run(sequel);
+  }
+  all(query) {
+    const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
+    const builtQuery = this.dialect.sqlToQuery(sequel);
+    const prepared = this.session.prepareQuery(builtQuery, "objects", false, "all");
+    if (this.resultKind === "async") return new SQLiteAsyncRaw(prepared, sequel, builtQuery);
+    return this.session.objects(sequel);
+  }
+  get(query) {
+    const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
+    const builtQuery = this.dialect.sqlToQuery(sequel);
+    const prepared = this.session.prepareQuery(builtQuery, "objects", false, "get");
+    if (this.resultKind === "async") return new SQLiteAsyncRaw(prepared, sequel, builtQuery);
+    return this.session.object(sequel);
+  }
+  values(query) {
+    const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
+    const builtQuery = this.dialect.sqlToQuery(sequel);
+    const prepared = this.session.prepareQuery(builtQuery, "objects", false, "values");
+    if (this.resultKind === "async") return new SQLiteAsyncRaw(prepared, sequel, builtQuery);
+    return this.session.arrays(sequel);
+  }
+  transaction(transaction, config) {
+    return this.session.transaction(transaction, config);
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/session.js
+var SQLitePreparedQuery = class {
+  static [entityKind] = "SQLiteBasePreparedQuery";
+  /** @internal */
+  mapper;
+  /** @internal */
+  executeMethod;
+  constructor(executeMethod, query, mapper, mode) {
+    this.query = query;
+    this.mode = mode;
+    this.mapper = mapper;
+    this.executeMethod = executeMethod;
+  }
+  getQuery() {
+    return this.query;
+  }
+};
+var SQLiteSession = class {
+  static [entityKind] = "SQLiteSession";
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+};
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/cache/core/cache.js
+var Cache = class {
+  static [entityKind] = "Cache";
+};
+var NoopCache = class extends Cache {
+  static [entityKind] = "NoopCache";
+  strategy() {
+    return "all";
+  }
+  async get(_key) {
+  }
+  async put(_hashedQuery, _response, _tables, _config) {
+  }
+  async onMutate(_params) {
+  }
+};
+var strategyFor = async (query, params, queryMetadata, withCacheConfig) => {
+  if (!queryMetadata) return { type: "skip" };
+  const { type, tables } = queryMetadata;
+  if ((type === "insert" || type === "update" || type === "delete") && tables.length > 0) return {
+    type: "invalidate",
+    tables
+  };
+  if (!withCacheConfig) return { type: "skip" };
+  if (!withCacheConfig.enabled) return { type: "skip" };
+  if (type === "select") return {
+    type: "try",
+    key: withCacheConfig.tag ?? await hashQuery(query, params),
+    isTag: typeof withCacheConfig.tag !== "undefined",
+    autoInvalidate: withCacheConfig.autoInvalidate,
+    tables: queryMetadata.tables,
+    config: withCacheConfig.config
+  };
+  return { type: "skip" };
+};
+async function hashQuery(sql2, params) {
+  const dataToHash = `${sql2}-${JSON.stringify(params, (_, v) => typeof v === "bigint" ? `${v}n` : v)}`;
+  const data = new TextEncoder().encode(dataToHash);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  return [...new Uint8Array(hashBuffer)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/drizzle-orm/sqlite-core/async/session.js
+var ExecuteResultSync = class extends QueryPromise {
+  static [entityKind] = "ExecuteResultSync";
+  constructor(resultCb) {
+    super();
+    this.resultCb = resultCb;
+  }
+  async execute() {
+    return this.resultCb();
+  }
+  sync() {
+    return this.resultCb();
+  }
+};
+var SQLiteAsyncPreparedQuery = class extends SQLitePreparedQuery {
+  static [entityKind] = "SQLiteAsyncPreparedQuery";
+  fastPath;
+  constructor(resultKind, executeMethod = "all", executors, query, mapper, mode, logger, cache, queryMetadata, cacheConfig) {
+    super(executeMethod, query, mapper, mode);
+    this.resultKind = resultKind;
+    this.executors = executors;
+    this.logger = logger;
+    this.cache = cache;
+    this.queryMetadata = queryMetadata;
+    this.cacheConfig = cacheConfig;
+    if (cache && cache.strategy() === "all" && cacheConfig === void 0) this.cacheConfig = {
+      enabled: true,
+      autoInvalidate: true
+    };
+    if (!this.cacheConfig?.enabled) this.cacheConfig = void 0;
+    this.fastPath = cacheConfig === void 0 && (cache === void 0 || is(cache, NoopCache));
+  }
+  /** @internal */
+  async queryWithCache(queryString, params, executeMethod, query) {
+    const cacheStrat = this.cache !== void 0 && !is(this.cache, NoopCache) ? await strategyFor(queryString, params, this.queryMetadata, this.cacheConfig) : { type: "skip" };
+    if (cacheStrat.type === "skip") return query().catch((e) => {
+      throw new DrizzleQueryError(queryString, params, e);
+    });
+    const cache = this.cache;
+    if (cacheStrat.type === "invalidate") return Promise.all([query(), cache.onMutate({ tables: cacheStrat.tables })]).then((res) => res[0]).catch((e) => {
+      throw new DrizzleQueryError(queryString, params, e);
+    });
+    if (cacheStrat.type === "try") {
+      const { tables, key: _key, isTag, autoInvalidate, config } = cacheStrat;
+      const key = `${executeMethod}_${_key}`;
+      const fromCache = await cache.get(key, tables, isTag, autoInvalidate);
+      if (fromCache === void 0) {
+        const result = await query().catch((e) => {
+          throw new DrizzleQueryError(queryString, params, e);
+        });
+        await cache.put(key, result, autoInvalidate ? tables : [], isTag, config);
+        return result;
+      }
+      return fromCache;
+    }
+    assertUnreachable(cacheStrat);
+  }
+  run(placeholderValues = {}) {
+    const { query, logger, executors, fastPath, resultKind } = this;
+    const sql2 = query._sql ? query._sql.join(" ") : query.sql;
+    const params = query.params.length === 0 ? query.params : fillPlaceholders(query.params, placeholderValues);
+    logger.logQuery(sql2, params);
+    if (resultKind === "sync") try {
+      return executors.run(params);
+    } catch (e) {
+      throw new DrizzleQueryError(sql2, params, e);
+    }
+    return fastPath ? executors.run(params).catch((e) => {
+      throw new DrizzleQueryError(sql2, params, e);
+    }) : this.queryWithCache(sql2, params, "run", () => executors.run(params));
+  }
+  all(placeholderValues = {}) {
+    const { query, logger, executors, mapper, fastPath, resultKind } = this;
+    const sql2 = query._sql ? query._sql.join(" ") : query.sql;
+    const params = query.params.length === 0 ? query.params : fillPlaceholders(query.params, placeholderValues);
+    logger.logQuery(sql2, params);
+    if (resultKind === "sync") {
+      let res2;
+      try {
+        res2 = executors.all(params);
+      } catch (e) {
+        throw new DrizzleQueryError(sql2, params, e);
+      }
+      if (!mapper) return res2;
+      return mapper(res2);
+    }
+    const res = fastPath ? executors.all(params).catch((e) => {
+      throw new DrizzleQueryError(sql2, params, e);
+    }) : this.queryWithCache(sql2, params, "all", () => executors.all(params));
+    if (!mapper) return res;
+    return res.then((rows) => mapper(rows));
+  }
+  get(placeholderValues = {}) {
+    const { query, logger, executors, mapper, fastPath, resultKind } = this;
+    const sql2 = query._sql ? query._sql.join(" ") : query.sql;
+    const params = query.params.length === 0 ? query.params : fillPlaceholders(query.params, placeholderValues);
+    logger.logQuery(sql2, params);
+    if (resultKind === "sync") {
+      let res2;
+      try {
+        res2 = executors.get(params);
+      } catch (e) {
+        throw new DrizzleQueryError(sql2, params, e);
+      }
+      if (!res2) return void 0;
+      if (!mapper) return res2;
+      return mapper([res2])[0];
+    }
+    const res = fastPath ? executors.get(params).catch((e) => {
+      throw new DrizzleQueryError(sql2, params, e);
+    }) : this.queryWithCache(sql2, params, "get", () => executors.get(params));
+    if (!mapper) return res.then((row) => row ? row : void 0);
+    return res.then((row) => row ? mapper([row])[0] : void 0);
+  }
+  values(placeholderValues = {}) {
+    const { query, logger, executors, fastPath, resultKind } = this;
+    const sql2 = query._sql ? query._sql.join(" ") : query.sql;
+    const params = query.params.length === 0 ? query.params : fillPlaceholders(query.params, placeholderValues);
+    logger.logQuery(sql2, params);
+    if (resultKind === "sync") try {
+      return executors.values(params);
+    } catch (e) {
+      throw new DrizzleQueryError(sql2, params, e);
+    }
+    return fastPath ? executors.values(params).catch((e) => {
+      throw new DrizzleQueryError(sql2, params, e);
+    }) : this.queryWithCache(sql2, params, "values", () => executors.values(params));
+  }
+  execute(placeholderValues) {
+    if (this.resultKind === "async") return this[this.executeMethod](placeholderValues);
+    return new ExecuteResultSync(() => this[this.executeMethod](placeholderValues));
+  }
+};
+var SQLiteAsyncSession = class extends SQLiteSession {
+  static [entityKind] = "SQLiteAsyncSession";
+  constructor(dialect, resultKind) {
+    super(dialect);
+    this.resultKind = resultKind;
+  }
+  run(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), "raw", false).run();
+  }
+  objects(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), "objects", false).all();
+  }
+  object(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), "objects", false).get();
+  }
+  arrays(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), "arrays", false).all();
+  }
+  array(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), "arrays", false).get();
+  }
+};
+var SQLiteAsyncTransaction = class extends SQLiteAsyncDatabase {
+  static [entityKind] = "SQLiteAsyncTransaction";
+  constructor(resultType, dialect, session, relations, nestedIndex = 0, forbidJsonb) {
+    super(resultType, dialect, session, relations, forbidJsonb);
+    this.nestedIndex = nestedIndex;
+  }
+  rollback() {
+    throw new TransactionRollbackError();
+  }
+};
+
+export {
+  entityKind,
+  sql,
+  DrizzleQueryError,
+  eq,
+  desc,
+  jitCompatCheck,
+  DefaultLogger,
+  NoopLogger,
+  integer,
+  real,
+  text,
+  sqliteTable,
+  index,
+  primaryKey,
+  unique,
+  SQLiteDialect,
+  SQLiteAsyncDatabase,
+  SQLiteAsyncPreparedQuery,
+  SQLiteAsyncSession,
+  SQLiteAsyncTransaction
+};
+//# sourceMappingURL=shared-ZF3LACGD.js.map