@absolutejs/auth 0.56.8 → 0.56.10

package/dist/server.js

@@ -12763,6 +12763,9 @@ var SQL = class SQL2 {
     this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
     return this;
   }
+  nullable() {
+    return this;
+  }
   inlineParams() {
     this.shouldInlineParams = true;
     return this;
@@ -12948,9 +12951,10 @@ function fillPlaceholders(params, values) {
     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`);
-      if (values[p.value.name] === null)
-        return values[p.value.name];
-      const mapped = p.encoder.mapToDriverValue.isNoop ? values[p.value.name] : p.encoder.mapToDriverValue(values[p.value.name]);
+      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;
@@ -13320,6 +13324,9 @@ var PgColumn = class extends Column {
     }
     return this;
   }
+  shouldDisableInsert() {
+    return this.config.generatedIdentity !== undefined && this.config.generatedIdentity.type !== "byDefault" || this.config.generated !== undefined && this.config.generated.type !== "byDefault";
+  }
   mapArrayElements(value, mapper, depth) {
     if (depth > 0 && Array.isArray(value))
       return value.map((v) => v === null ? null : this.mapArrayElements(v, mapper, depth - 1));
@@ -13585,20 +13592,59 @@ function orderSelectedFields2(fields, pathPrefix, codecs) {
         path: newPath,
         field,
         codec: codecs?.get(field, "normalize"),
-        arrayDimensions: field.dimensions
+        arrayDimensions: field.dimensions,
+        column: field
       });
-    else if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased) || is(field, Subquery))
-      result.push({
+    else if (is(field, SQL) || is(field, SQL.Aliased)) {
+      const col = getColumnFromDecoder2(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 = getColumnFromDecoder2(entry);
+        fieldDecoder = entry.decoder;
+      } else {
+        column = getColumnFromDecoder2(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))
+    } else if (is(field, Table))
       result.push(...orderSelectedFields2(field[Table.Symbol.Columns], newPath, codecs));
     else
       result.push(...orderSelectedFields2(field, newPath, codecs));
     return result;
   }, []);
 }
+function getColumnFromDecoder2(source) {
+  const query = source.getSQL();
+  if (is(query.decoder, Column))
+    return query.decoder;
+}
 function haveSameKeys2(left, right) {
   const leftKeys = Object.keys(left);
   const rightKeys = Object.keys(right);
@@ -13742,832 +13788,1458 @@ var PgBoolean = class extends PgColumn {
 function boolean(name2) {
   return new PgBooleanBuilder(name2 ?? "");
 }
-// node_modules/drizzle-orm/pg-core/columns/double-precision.js
-var PgDoublePrecisionBuilder = class extends PgColumnBuilder {
-  static [entityKind] = "PgDoublePrecisionBuilder";
-  constructor(name2) {
-    super(name2, "number double", "PgDoublePrecision");
-  }
-  build(table) {
-    return new PgDoublePrecision(table, this.config);
-  }
-};
-var PgDoublePrecision = class extends PgColumn {
-  static [entityKind] = "PgDoublePrecision";
-  codec = "float8";
-  getSQLType() {
-    return "double precision";
+// node_modules/drizzle-orm/pg-core/array.js
+function parsePgArrayValue(arrayString, startFrom, inQuotes) {
+  for (let i = startFrom;i < arrayString.length; i++) {
+    const char = arrayString[i];
+    if (char === "\\") {
+      i++;
+      continue;
+    }
+    if (char === '"')
+      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i + 1];
+    if (inQuotes)
+      continue;
+    if (char === "," || char === "}")
+      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i];
   }
-};
-function doublePrecision(name2) {
-  return new PgDoublePrecisionBuilder(name2 ?? "");
+  return [arrayString.slice(startFrom).replace(/\\/g, ""), arrayString.length];
 }
-// node_modules/drizzle-orm/pg-core/columns/integer.js
-var PgIntegerBuilder = class extends PgIntColumnBuilder {
-  static [entityKind] = "PgIntegerBuilder";
-  constructor(name2) {
-    super(name2, "number int32", "PgInteger");
-  }
-  build(table) {
-    return new PgInteger(table, this.config);
-  }
-};
-var PgInteger = class extends PgColumn {
-  static [entityKind] = "PgInteger";
-  codec = "int";
-  getSQLType() {
-    return "integer";
+function parsePgNestedArray(arrayString, startFrom = 0) {
+  const result = [];
+  let i = startFrom;
+  let lastCharIsComma = false;
+  while (i < arrayString.length) {
+    const char = arrayString[i];
+    if (char === ",") {
+      if (lastCharIsComma || i === startFrom)
+        result.push("");
+      lastCharIsComma = true;
+      i++;
+      continue;
+    }
+    lastCharIsComma = false;
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (char === '"') {
+      const [value2, startFrom2] = parsePgArrayValue(arrayString, i + 1, true);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    if (char === "}")
+      return [result, i + 1];
+    if (char === "{") {
+      const [value2, startFrom2] = parsePgNestedArray(arrayString, i + 1);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);
+    result.push(value);
+    i = newStartFrom;
   }
-};
-function integer(name2) {
-  return new PgIntegerBuilder(name2 ?? "");
+  return [result, i];
 }
-// node_modules/drizzle-orm/pg-core/columns/jsonb.js
-var PgJsonbBuilder = class extends PgColumnBuilder {
-  static [entityKind] = "PgJsonbBuilder";
-  constructor(name2) {
-    super(name2, "object json", "PgJsonb");
-  }
-  build(table) {
-    return new PgJsonb(table, this.config);
-  }
-};
-var PgJsonb = class extends PgColumn {
-  static [entityKind] = "PgJsonb";
-  codec = "jsonb";
-  constructor(table, config) {
-    super(table, config);
-  }
-  getSQLType() {
-    return "jsonb";
-  }
-};
-function jsonb(name2) {
-  return new PgJsonbBuilder(name2 ?? "");
+function parsePgArray(arrayString) {
+  const [result] = parsePgNestedArray(arrayString, 1);
+  return result;
 }
-// node_modules/drizzle-orm/pg-core/columns/smallint.js
-var PgSmallIntBuilder = class extends PgIntColumnBuilder {
-  static [entityKind] = "PgSmallIntBuilder";
-  constructor(name2) {
-    super(name2, "number int16", "PgSmallInt");
+function makePgArray(array) {
+  return `{${array.map((item) => {
+    if (Array.isArray(item))
+      return makePgArray(item);
+    if (typeof item === "string")
+      return `"${item.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+    return `${item}`;
+  }).join(",")}}`;
+}
+
+// node_modules/drizzle-orm/pg-core/columns/postgis_extension/utils.js
+function hexToBytes(hex) {
+  const bytes = [];
+  for (let c = 0;c < hex.length; c += 2)
+    bytes.push(Number.parseInt(hex.slice(c, c + 2), 16));
+  return new Uint8Array(bytes);
+}
+function bytesToFloat64(bytes, offset) {
+  const buffer = /* @__PURE__ */ new ArrayBuffer(8);
+  const view = new DataView(buffer);
+  for (let i = 0;i < 8; i++)
+    view.setUint8(i, bytes[offset + i]);
+  return view.getFloat64(0, true);
+}
+function parseEWKB(hex) {
+  const bytes = hexToBytes(hex);
+  let offset = 0;
+  const byteOrder = bytes[offset];
+  offset += 1;
+  const view = new DataView(bytes.buffer);
+  const geomType = view.getUint32(offset, byteOrder === 1);
+  offset += 4;
+  let srid;
+  if (geomType & 536870912) {
+    srid = view.getUint32(offset, byteOrder === 1);
+    offset += 4;
   }
-  build(table) {
-    return new PgSmallInt(table, this.config);
+  if ((geomType & 65535) === 1) {
+    const x = bytesToFloat64(bytes, offset);
+    offset += 8;
+    const y = bytesToFloat64(bytes, offset);
+    offset += 8;
+    return {
+      srid,
+      point: [x, y]
+    };
   }
+  throw new Error("Unsupported geometry type");
+}
+
+// node_modules/drizzle-orm/codecs.js
+var noopCodecs = {};
+var arrayToItemTypeCodecNameMap = {
+  cast: "cast",
+  castArray: "cast",
+  castInJson: "castInJson",
+  castArrayInJson: "castInJson",
+  castParam: "castParam",
+  castArrayParam: "castParam",
+  normalize: "normalize",
+  normalizeArray: "normalize",
+  normalizeInJson: "normalizeInJson",
+  normalizeArrayInJson: "normalizeInJson",
+  normalizeParam: "normalizeParam",
+  normalizeParamArray: "normalizeParam"
 };
-var PgSmallInt = class extends PgColumn {
-  static [entityKind] = "PgSmallInt";
-  codec = "smallint";
-  getSQLType() {
-    return "smallint";
-  }
+var itemToArrayTypeCodecNameMap = {
+  cast: "castArray",
+  castArray: "castArray",
+  castInJson: "castArrayInJson",
+  castArrayInJson: "castArrayInJson",
+  castParam: "castArrayParam",
+  castArrayParam: "castArrayParam",
+  normalize: "normalizeArray",
+  normalizeArray: "normalizeArray",
+  normalizeInJson: "normalizeArrayInJson",
+  normalizeArrayInJson: "normalizeArrayInJson",
+  normalizeParam: "normalizeParamArray",
+  normalizeParamArray: "normalizeParamArray"
 };
-function smallint(name2) {
-  return new PgSmallIntBuilder(name2 ?? "");
-}
-// node_modules/drizzle-orm/pg-core/columns/text.js
-var PgTextBuilder = class extends PgColumnBuilder {
-  static [entityKind] = "PgTextBuilder";
-  constructor(name2, config) {
-    super(name2, config.enum?.length ? "string enum" : "string", "PgText");
-    this.config.enumValues = config.enum;
-  }
-  build(table) {
-    return new PgText(table, this.config, this.config.enumValues);
+var CodecsCollection = class {
+  static [entityKind] = "CodecsCollection";
+  constructor(resolveTypes, codecs = noopCodecs) {
+    this.resolveTypes = resolveTypes;
+    this.codecs = codecs;
   }
-};
-var PgText = class extends PgColumn {
-  static [entityKind] = "PgText";
-  enumValues;
-  codec = "text";
-  constructor(table, config, enumValues) {
-    super(table, config);
-    this.enumValues = enumValues;
+  get(column, type, override) {
+    const sqlType = override ?? column.codec;
+    if (!sqlType)
+      return;
+    const codecType = column.dimensions ? itemToArrayTypeCodecNameMap[type] : arrayToItemTypeCodecNameMap[type];
+    return this.codecs[sqlType]?.[codecType];
   }
-  getSQLType() {
-    return "text";
+  apply(column, type, value, override) {
+    const sqlType = override ?? column.codec;
+    if (!sqlType)
+      return value;
+    const codecType = column.dimensions ? itemToArrayTypeCodecNameMap[type] : arrayToItemTypeCodecNameMap[type];
+    const codec = this.codecs[sqlType]?.[codecType];
+    if (!codec)
+      return value;
+    if (codecType === "castParam" || codecType === "castArrayParam")
+      return codec(value, column, column.dimensions);
+    return codec(value, column.dimensions);
   }
 };
-function text(a, b = {}) {
-  const { name: name2, config } = getColumnNameAndConfig2(a, b);
-  return new PgTextBuilder(name2, config);
-}
-// node_modules/drizzle-orm/pg-core/columns/date.common.js
-var PgDateColumnBuilder = class extends PgColumnBuilder {
-  static [entityKind] = "PgDateColumnBaseBuilder";
-  defaultNow() {
-    return this.default(sql`now()`);
+function refineCodecs(source, extension = {}) {
+  const keys = new Set([...Object.keys(source), ...Object.keys(extension)]).values();
+  const result = {};
+  for (const k of keys) {
+    if (!(k in extension)) {
+      result[k] = source[k] ? { ...source[k] } : undefined;
+      continue;
+    }
+    if (!(k in source) || extension[k] === undefined) {
+      result[k] = extension[k] ? { ...extension[k] } : undefined;
+      continue;
+    }
+    const innerKeys = new Set([...Object.keys(extension[k]), ...Object.keys(source[k] ?? {})]).values();
+    result[k] = {};
+    for (const ik of innerKeys)
+      result[k][ik] = ik in extension[k] ? extension[k][ik] : source[k]?.[ik];
   }
-};
+  return result;
+}
 
-// node_modules/drizzle-orm/pg-core/columns/timestamp.js
-var PgTimestampBuilder = class extends PgDateColumnBuilder {
-  static [entityKind] = "PgTimestampBuilder";
-  constructor(name2, withTimezone, precision) {
-    super(name2, "object date", "PgTimestamp");
-    this.config.withTimezone = withTimezone;
-    this.config.precision = precision;
-  }
-  build(table) {
-    return new PgTimestamp(table, this.config);
-  }
+// node_modules/drizzle-orm/pg-core/codecs.js
+var PG_ALIAS_TO_TYPE_MAP = {
+  int2: "smallint",
+  integer: "int",
+  int4: "int",
+  int8: "bigint",
+  decimal: "numeric",
+  real: "float4",
+  double: "float8",
+  "double precision": "float8",
+  serial2: "smallserial",
+  serial4: "serial",
+  serial8: "bigserial",
+  character: "char",
+  "character varying": "varchar",
+  "time with time zone": "timetz",
+  "time without time zone": "time",
+  "timestamp with time zone": "timestamptz",
+  "timestamp without time zone": "timestamp",
+  boolean: "bool",
+  "bit varying": "varbit"
 };
-var PgTimestamp = class extends PgColumn {
-  static [entityKind] = "PgTimestamp";
-  codec;
-  withTimezone;
-  precision;
-  constructor(table, config) {
-    super(table, config);
-    this.withTimezone = config.withTimezone;
-    this.precision = config.precision;
-    this.codec = this.withTimezone ? "timestamptz" : "timestamp";
-  }
-  getSQLType() {
-    return `timestamp${this.precision === undefined ? "" : ` (${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
+function resolvePgTypeAlias(type) {
+  return PG_ALIAS_TO_TYPE_MAP[type] ?? type;
+}
+var unionsTypeTable = {
+  smallint: {
+    smallint: "smallint",
+    int: "int",
+    bigint: "bigint:number",
+    "bigint:number": "bigint:number",
+    "bigint:string": "bigint:number",
+    numeric: "numeric:number",
+    "numeric:number": "numeric:number",
+    "numeric:bigint": "numeric:number",
+    float4: "float4",
+    float8: "float8",
+    smallserial: "smallint",
+    serial: "int",
+    bigserial: "bigint:number",
+    "bigserial:number": "bigint:number",
+    oid: "oid",
+    regproc: "regproc",
+    regprocedure: "regprocedure",
+    regoper: "regoper",
+    regoperator: "regoperator",
+    regclass: "regclass",
+    regtype: "regtype",
+    regrole: "regrole",
+    regnamespace: "regnamespace",
+    regconfig: "regconfig",
+    regdictionary: "regdictionary"
+  },
+  int: {
+    smallint: "int",
+    int: "int",
+    bigint: "bigint:number",
+    "bigint:number": "bigint:number",
+    "bigint:string": "bigint:number",
+    numeric: "numeric:number",
+    "numeric:number": "numeric:number",
+    "numeric:bigint": "numeric:number",
+    float4: "float4",
+    float8: "float8",
+    smallserial: "int",
+    serial: "int",
+    bigserial: "bigint:number",
+    "bigserial:number": "bigint:number",
+    oid: "oid",
+    regproc: "regproc",
+    regprocedure: "regprocedure",
+    regoper: "regoper",
+    regoperator: "regoperator",
+    regclass: "regclass",
+    regtype: "regtype",
+    regrole: "regrole",
+    regnamespace: "regnamespace",
+    regconfig: "regconfig",
+    regdictionary: "regdictionary"
+  },
+  bigint: {
+    smallint: "bigint",
+    int: "bigint",
+    bigint: "bigint",
+    "bigint:number": "bigint",
+    "bigint:string": "bigint",
+    numeric: "numeric:bigint",
+    "numeric:number": "numeric:bigint",
+    "numeric:bigint": "numeric:bigint",
+    float4: "float4",
+    float8: "float8",
+    smallserial: "bigint",
+    serial: "bigint",
+    bigserial: "bigint",
+    "bigserial:number": "bigint",
+    oid: "oid",
+    regproc: "regproc",
+    regprocedure: "regprocedure",
+    regoper: "regoper",
+    regoperator: "regoperator",
+    regclass: "regclass",
+    regtype: "regtype",
+    regrole: "regrole",
+    regnamespace: "regnamespace",
+    regconfig: "regconfig",
+    regdictionary: "regdictionary"
+  },
+  "bigint:number": {
+    smallint: "bigint:number",
+    int: "bigint:number",
+    bigint: "bigint:number",
+    "bigint:number": "bigint:number",
+    "bigint:string": "bigint:number",
+    numeric: "numeric:number",
+    "numeric:number": "numeric:number",
+    "numeric:bigint": "numeric:number",
+    float4: "float4",
+    float8: "float8",
+    smallserial: "bigint:number",
+    serial: "bigint:number",
+    bigserial: "bigint:number",
+    "bigserial:number": "bigint:number",
+    oid: "oid",
+    regproc: "regproc",
+    regprocedure: "regprocedure",
+    regoper: "regoper",
+    regoperator: "regoperator",
+    regclass: "regclass",
+    regtype: "regtype",
+    regrole: "regrole",
+    regnamespace: "regnamespace",
+    regconfig: "regconfig",
+    regdictionary: "regdictionary"
+  },
+  "bigint:string": {
+    smallint: "bigint:string",
+    int: "bigint:string",
+    bigint: "bigint:string",
+    "bigint:number": "bigint:string",
+    "bigint:string": "bigint:string",
+    numeric: "numeric",
+    "numeric:number": "numeric",
+    "numeric:bigint": "numeric",
+    float4: "float4",
+    float8: "float8",
+    smallserial: "bigint:string",
+    serial: "bigint:string",
+    bigserial: "bigint:string",
+    "bigserial:number": "bigint:string",
+    oid: "oid",
+    regproc: "regproc",
+    regprocedure: "regprocedure",
+    regoper: "regoper",
+    regoperator: "regoperator",
+    regclass: "regclass",
+    regtype: "regtype",
+    regrole: "regrole",
+    regnamespace: "regnamespace",
+    regconfig: "regconfig",
+    regdictionary: "regdictionary"
+  },
+  numeric: {
+    smallint: "numeric",
+    int: "numeric",
+    bigint: "numeric",
+    "bigint:number": "numeric",
+    "bigint:string": "numeric",
+    numeric: "numeric",
+    "numeric:number": "numeric",
+    "numeric:bigint": "numeric",
+    float4: "float4",
+    float8: "float8",
+    smallserial: "numeric",
+    serial: "numeric",
+    bigserial: "numeric",
+    "bigserial:number": "numeric"
+  },
+  "numeric:number": {
+    smallint: "numeric:number",
+    int: "numeric:number",
+    bigint: "numeric:number",
+    "bigint:number": "numeric:number",
+    "bigint:string": "numeric:number",
+    numeric: "numeric:number",
+    "numeric:number": "numeric:number",
+    "numeric:bigint": "numeric:number",
+    float4: "float4",
+    float8: "float8",
+    smallserial: "numeric:number",
+    serial: "numeric:number",
+    bigserial: "numeric:number",
+    "bigserial:number": "numeric:number"
+  },
+  "numeric:bigint": {
+    smallint: "numeric:bigint",
+    int: "numeric:bigint",
+    bigint: "numeric:bigint",
+    "bigint:number": "numeric:bigint",
+    "bigint:string": "numeric:bigint",
+    numeric: "numeric:bigint",
+    "numeric:number": "numeric:bigint",
+    "numeric:bigint": "numeric:bigint",
+    float4: "float4",
+    float8: "float8",
+    smallserial: "numeric:bigint",
+    serial: "numeric:bigint",
+    bigserial: "numeric:bigint",
+    "bigserial:number": "numeric:bigint"
+  },
+  float4: {
+    smallint: "float4",
+    int: "float4",
+    bigint: "float4",
+    "bigint:number": "float4",
+    "bigint:string": "float4",
+    numeric: "float4",
+    "numeric:number": "float4",
+    "numeric:bigint": "float4",
+    float4: "float4",
+    float8: "float8",
+    smallserial: "float4",
+    serial: "float4",
+    bigserial: "float4",
+    "bigserial:number": "float4"
+  },
+  float8: {
+    smallint: "float8",
+    int: "float8",
+    bigint: "float8",
+    "bigint:number": "float8",
+    "bigint:string": "float8",
+    numeric: "float8",
+    "numeric:number": "float8",
+    "numeric:bigint": "float8",
+    float4: "float8",
+    float8: "float8",
+    smallserial: "float8",
+    serial: "float8",
+    bigserial: "float8",
+    "bigserial:number": "float8"
+  },
+  money: { money: "money" },
+  smallserial: {
+    smallint: "smallint",
+    int: "int",
+    bigint: "bigint:number",
+    "bigint:number": "bigint:number",
+    "bigint:string": "bigint:number",
+    numeric: "numeric:number",
+    "numeric:number": "numeric:number",
+    "numeric:bigint": "numeric:number",
+    float4: "float4",
+    float8: "float8",
+    smallserial: "smallint",
+    serial: "int",
+    bigserial: "bigint:number",
+    "bigserial:number": "bigint:number",
+    oid: "oid",
+    regproc: "regproc",
+    regprocedure: "regprocedure",
+    regoper: "regoper",
+    regoperator: "regoperator",
+    regclass: "regclass",
+    regtype: "regtype",
+    regrole: "regrole",
+    regnamespace: "regnamespace",
+    regconfig: "regconfig",
+    regdictionary: "regdictionary"
+  },
+  serial: {
+    smallint: "int",
+    int: "int",
+    bigint: "bigint:number",
+    "bigint:number": "bigint:number",
+    "bigint:string": "bigint:number",
+    numeric: "numeric:number",
+    "numeric:number": "numeric:number",
+    "numeric:bigint": "numeric:number",
+    float4: "float4",
+    float8: "float8",
+    smallserial: "int",
+    serial: "int",
+    bigserial: "bigint:number",
+    "bigserial:number": "bigint:number",
+    oid: "oid",
+    regproc: "regproc",
+    regprocedure: "regprocedure",
+    regoper: "regoper",
+    regoperator: "regoperator",
+    regclass: "regclass",
+    regtype: "regtype",
+    regrole: "regrole",
+    regnamespace: "regnamespace",
+    regconfig: "regconfig",
+    regdictionary: "regdictionary"
+  },
+  bigserial: {
+    smallint: "bigint",
+    int: "bigint",
+    bigint: "bigint",
+    "bigint:number": "bigint",
+    "bigint:string": "bigint",
+    numeric: "numeric:bigint",
+    "numeric:number": "numeric:bigint",
+    "numeric:bigint": "numeric:bigint",
+    float4: "float4",
+    float8: "float8",
+    smallserial: "bigint",
+    serial: "bigint",
+    bigserial: "bigint",
+    "bigserial:number": "bigint",
+    oid: "oid",
+    regproc: "regproc",
+    regprocedure: "regprocedure",
+    regoper: "regoper",
+    regoperator: "regoperator",
+    regclass: "regclass",
+    regtype: "regtype",
+    regrole: "regrole",
+    regnamespace: "regnamespace",
+    regconfig: "regconfig",
+    regdictionary: "regdictionary"
+  },
+  "bigserial:number": {
+    smallint: "bigint:number",
+    int: "bigint:number",
+    bigint: "bigint:number",
+    "bigint:number": "bigint:number",
+    "bigint:string": "bigint:number",
+    numeric: "numeric:number",
+    "numeric:number": "numeric:number",
+    "numeric:bigint": "numeric:number",
+    float4: "float4",
+    float8: "float8",
+    smallserial: "bigint:number",
+    serial: "bigint:number",
+    bigserial: "bigint:number",
+    "bigserial:number": "bigint:number",
+    oid: "oid",
+    regproc: "regproc",
+    regprocedure: "regprocedure",
+    regoper: "regoper",
+    regoperator: "regoperator",
+    regclass: "regclass",
+    regtype: "regtype",
+    regrole: "regrole",
+    regnamespace: "regnamespace",
+    regconfig: "regconfig",
+    regdictionary: "regdictionary"
+  },
+  char: {
+    char: "char",
+    varchar: "char",
+    text: "char"
+  },
+  varchar: {
+    char: "varchar",
+    varchar: "varchar",
+    text: "varchar"
+  },
+  text: {
+    char: "text",
+    varchar: "text",
+    text: "text"
+  },
+  bytea: { bytea: "bytea" },
+  date: {
+    date: "date",
+    "date:string": "date",
+    timestamp: "timestamp",
+    "timestamp:string": "timestamp",
+    timestamptz: "timestamptz",
+    "timestamptz:string": "timestamptz"
+  },
+  "date:string": {
+    date: "date:string",
+    "date:string": "date:string",
+    timestamp: "timestamp:string",
+    "timestamp:string": "timestamp:string",
+    timestamptz: "timestamptz:string",
+    "timestamptz:string": "timestamptz:string"
+  },
+  time: {
+    time: "time",
+    timetz: "timetz"
+  },
+  timetz: {
+    time: "timetz",
+    timetz: "timetz"
+  },
+  timestamp: {
+    date: "timestamp",
+    "date:string": "timestamp",
+    timestamp: "timestamp",
+    "timestamp:string": "timestamp",
+    timestamptz: "timestamptz",
+    "timestamptz:string": "timestamptz"
+  },
+  "timestamp:string": {
+    date: "timestamp:string",
+    "date:string": "timestamp:string",
+    timestamp: "timestamp:string",
+    "timestamp:string": "timestamp:string",
+    timestamptz: "timestamptz:string",
+    "timestamptz:string": "timestamptz:string"
+  },
+  timestamptz: {
+    date: "timestamptz",
+    "date:string": "timestamptz",
+    timestamp: "timestamptz",
+    "timestamp:string": "timestamptz",
+    timestamptz: "timestamptz",
+    "timestamptz:string": "timestamptz"
+  },
+  "timestamptz:string": {
+    date: "timestamptz:string",
+    "date:string": "timestamptz:string",
+    timestamp: "timestamptz:string",
+    "timestamp:string": "timestamptz:string",
+    timestamptz: "timestamptz:string",
+    "timestamptz:string": "timestamptz:string"
+  },
+  interval: {
+    interval: "interval",
+    "interval:tuple": "interval"
+  },
+  "interval:tuple": {
+    interval: "interval:tuple",
+    "interval:tuple": "interval:tuple"
+  },
+  bool: { bool: "bool" },
+  enum: { enum: "enum" },
+  point: {
+    point: "point",
+    "point:tuple": "point"
+  },
+  "point:tuple": {
+    point: "point:tuple",
+    "point:tuple": "point:tuple"
+  },
+  line: {
+    line: "line",
+    "line:tuple": "line"
+  },
+  "line:tuple": {
+    line: "line:tuple",
+    "line:tuple": "line:tuple"
+  },
+  lseg: { lseg: "lseg" },
+  box: { box: "box" },
+  path: { path: "path" },
+  polygon: { polygon: "polygon" },
+  circle: { circle: "circle" },
+  cidr: {
+    cidr: "cidr",
+    inet: "inet"
+  },
+  inet: {
+    cidr: "inet",
+    inet: "inet"
+  },
+  macaddr: {
+    macaddr: "macaddr",
+    macaddr8: "macaddr"
+  },
+  macaddr8: {
+    macaddr: "macaddr8",
+    macaddr8: "macaddr8"
+  },
+  bit: {
+    bit: "bit",
+    varbit: "bit"
+  },
+  varbit: {
+    bit: "varbit",
+    varbit: "varbit"
+  },
+  tsvector: { tsvector: "tsvector" },
+  tsquery: { tsquery: "tsquery" },
+  uuid: { uuid: "uuid" },
+  xml: { xml: "xml" },
+  json: { json: "json" },
+  jsonb: { jsonb: "jsonb" },
+  int4range: { int4range: "int4range" },
+  int8range: { int8range: "int8range" },
+  numrange: { numrange: "numrange" },
+  tsrange: { tsrange: "tsrange" },
+  tstzrange: { tstzrange: "tstzrange" },
+  daterange: { daterange: "daterange" },
+  int4multirange: { int4multirange: "int4multirange" },
+  int8multirange: { int8multirange: "int8multirange" },
+  nummultirange: { nummultirange: "nummultirange" },
+  tsmultirange: { tsmultirange: "tsmultirange" },
+  tstzmultirange: { tstzmultirange: "tstzmultirange" },
+  datemultirange: { datemultirange: "datemultirange" },
+  oid: {
+    smallint: "oid",
+    int: "oid",
+    bigint: "oid",
+    "bigint:number": "oid",
+    "bigint:string": "oid",
+    smallserial: "oid",
+    serial: "oid",
+    bigserial: "oid",
+    "bigserial:number": "oid",
+    oid: "oid",
+    regproc: "oid",
+    regprocedure: "oid",
+    regoper: "oid",
+    regoperator: "oid",
+    regclass: "oid",
+    regtype: "oid",
+    regrole: "oid",
+    regnamespace: "oid",
+    regconfig: "oid",
+    regdictionary: "oid"
+  },
+  regproc: {
+    smallint: "regproc",
+    int: "regproc",
+    bigint: "regproc",
+    "bigint:number": "regproc",
+    "bigint:string": "regproc",
+    smallserial: "regproc",
+    serial: "regproc",
+    bigserial: "regproc",
+    "bigserial:number": "regproc",
+    oid: "regproc",
+    regproc: "regproc",
+    regprocedure: "regproc"
+  },
+  regprocedure: {
+    smallint: "regprocedure",
+    int: "regprocedure",
+    bigint: "regprocedure",
+    "bigint:number": "regprocedure",
+    "bigint:string": "regprocedure",
+    smallserial: "regprocedure",
+    serial: "regprocedure",
+    bigserial: "regprocedure",
+    "bigserial:number": "regprocedure",
+    oid: "regprocedure",
+    regproc: "regprocedure",
+    regprocedure: "regprocedure"
+  },
+  regoper: {
+    smallint: "regoper",
+    int: "regoper",
+    bigint: "regoper",
+    "bigint:number": "regoper",
+    "bigint:string": "regoper",
+    smallserial: "regoper",
+    serial: "regoper",
+    bigserial: "regoper",
+    "bigserial:number": "regoper",
+    oid: "regoper",
+    regoper: "regoper",
+    regoperator: "regoper"
+  },
+  regoperator: {
+    smallint: "regoperator",
+    int: "regoperator",
+    bigint: "regoperator",
+    "bigint:number": "regoperator",
+    "bigint:string": "regoperator",
+    smallserial: "regoperator",
+    serial: "regoperator",
+    bigserial: "regoperator",
+    "bigserial:number": "regoperator",
+    oid: "regoperator",
+    regoper: "regoperator",
+    regoperator: "regoperator"
+  },
+  regclass: {
+    smallint: "regclass",
+    int: "regclass",
+    bigint: "regclass",
+    "bigint:number": "regclass",
+    "bigint:string": "regclass",
+    smallserial: "regclass",
+    serial: "regclass",
+    bigserial: "regclass",
+    "bigserial:number": "regclass",
+    oid: "regclass",
+    regclass: "regclass"
+  },
+  regtype: {
+    smallint: "regtype",
+    int: "regtype",
+    bigint: "regtype",
+    "bigint:number": "regtype",
+    "bigint:string": "regtype",
+    smallserial: "regtype",
+    serial: "regtype",
+    bigserial: "regtype",
+    "bigserial:number": "regtype",
+    oid: "regtype",
+    regtype: "regtype"
+  },
+  regrole: {
+    smallint: "regrole",
+    int: "regrole",
+    bigint: "regrole",
+    "bigint:number": "regrole",
+    "bigint:string": "regrole",
+    smallserial: "regrole",
+    serial: "regrole",
+    bigserial: "regrole",
+    "bigserial:number": "regrole",
+    oid: "regrole",
+    regrole: "regrole"
+  },
+  regnamespace: {
+    smallint: "regnamespace",
+    int: "regnamespace",
+    bigint: "regnamespace",
+    "bigint:number": "regnamespace",
+    "bigint:string": "regnamespace",
+    smallserial: "regnamespace",
+    serial: "regnamespace",
+    bigserial: "regnamespace",
+    "bigserial:number": "regnamespace",
+    oid: "regnamespace",
+    regnamespace: "regnamespace"
+  },
+  regconfig: {
+    smallint: "regconfig",
+    int: "regconfig",
+    bigint: "regconfig",
+    "bigint:number": "regconfig",
+    "bigint:string": "regconfig",
+    smallserial: "regconfig",
+    serial: "regconfig",
+    bigserial: "regconfig",
+    "bigserial:number": "regconfig",
+    oid: "regconfig",
+    regconfig: "regconfig"
+  },
+  regdictionary: {
+    smallint: "regdictionary",
+    int: "regdictionary",
+    bigint: "regdictionary",
+    "bigint:number": "regdictionary",
+    "bigint:string": "regdictionary",
+    smallserial: "regdictionary",
+    serial: "regdictionary",
+    bigserial: "regdictionary",
+    "bigserial:number": "regdictionary",
+    oid: "regdictionary",
+    regdictionary: "regdictionary"
   }
-  mapToDriverValue = (value) => {
-    if (typeof value === "string")
-      return value;
-    return value.toISOString();
-  };
 };
-var PgTimestampStringBuilder = class extends PgDateColumnBuilder {
-  static [entityKind] = "PgTimestampStringBuilder";
-  constructor(name2, withTimezone, precision) {
-    super(name2, "string timestamp", "PgTimestampString");
-    this.config.withTimezone = withTimezone;
-    this.config.precision = precision;
-  }
-  build(table) {
-    return new PgTimestampString(table, this.config);
-  }
+var castToText = (name2) => sql`${name2}::text`;
+var castToTextArr = (name2, arrayDimensions) => sql`${name2}::text${sql.raw("[]".repeat(arrayDimensions))}`;
+var arrayCompatCast = (cast) => (name2, arrayDimensions) => {
+  if (!arrayDimensions)
+    return cast(name2);
+  const aliases = [];
+  for (let i = 0;i < arrayDimensions; i++)
+    aliases.push(sql.identifier(`s${i}`));
+  let indexed = name2;
+  for (const alias of aliases)
+    indexed = sql`${indexed}[${alias}]`;
+  let expression = sql`array(\
+select ${cast(indexed)} \
+from generate_subscripts(${name2}, ${sql.raw(arrayDimensions.toString())}) ${aliases[arrayDimensions - 1]} \
+order by ${aliases[arrayDimensions - 1]})`;
+  for (let dim = arrayDimensions - 1;dim > 0; dim--)
+    expression = sql`array(\
+select ${expression} \
+from generate_subscripts(${name2}, ${sql.raw(dim.toString())}) ${aliases[dim - 1]} \
+order by ${aliases[dim - 1]})`;
+  return sql`case when ${name2} is null then null else ${expression} end`;
 };
-var PgTimestampString = class extends PgColumn {
-  static [entityKind] = "PgTimestampString";
-  codec;
-  withTimezone;
-  precision;
-  constructor(table, config) {
-    super(table, config);
-    this.withTimezone = config.withTimezone;
-    this.precision = config.precision;
-    this.codec = this.withTimezone ? "timestamptz:string" : "timestamp:string";
-  }
-  getSQLType() {
-    return `timestamp${this.precision === undefined ? "" : `(${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
-  }
-  mapToDriverValue = (value) => {
-    if (typeof value === "string")
-      return value;
-    return value.toISOString();
+var arrayCompatNormalize = (normalize) => {
+  const loop = (value, arrayDimensions) => {
+    const innerDimensions = arrayDimensions - 1;
+    if (arrayDimensions > 1)
+      for (let i = 0;i < value.length; ++i)
+        loop(value[i], innerDimensions);
+    else
+      for (let i = 0;i < value.length; ++i)
+        value[i] = normalize(value[i]);
+    return value;
   };
+  return loop;
 };
-function timestamp(a, b = {}) {
-  const { name: name2, config } = getColumnNameAndConfig2(a, b);
-  if (config?.mode === "string")
-    return new PgTimestampStringBuilder(name2, config.withTimezone ?? false, config.precision);
-  return new PgTimestampBuilder(name2, config?.withTimezone ?? false, config?.precision);
-}
-// node_modules/drizzle-orm/pg-core/columns/varchar.js
-var PgVarcharBuilder = class extends PgColumnBuilder {
-  static [entityKind] = "PgVarcharBuilder";
-  constructor(name2, config) {
-    super(name2, config.enum?.length ? "string enum" : "string", "PgVarchar");
-    this.config.length = config.length;
-    this.config.enumValues = config.enum;
-  }
-  build(table) {
-    return new PgVarchar(table, this.config);
-  }
+var arrayCompatNormalizeInput = (normalize, transformToPgArray = false) => {
+  const loop = (value, arrayDimensions) => {
+    const innerDimensions = arrayDimensions - 1;
+    const out = Array.from({ length: value.length });
+    if (arrayDimensions > 1)
+      for (let i = 0;i < value.length; ++i)
+        out[i] = loop(value[i], innerDimensions);
+    else
+      for (let i = 0;i < value.length; ++i)
+        out[i] = normalize(value[i]);
+    return out;
+  };
+  return transformToPgArray ? (v, d) => makePgArray(loop(v, d)) : loop;
 };
-var PgVarchar = class extends PgColumn {
-  static [entityKind] = "PgVarchar";
-  codec = "varchar";
-  enumValues;
-  constructor(table, config) {
-    super(table, config);
-    this.enumValues = config.enumValues;
-  }
-  getSQLType() {
-    return this.length === undefined ? `varchar` : `varchar(${this.length})`;
-  }
+var parsePgArrayAndNormalize = (normalize) => {
+  const codec = arrayCompatNormalize(normalize);
+  return (value, arrayDimensions) => codec(parsePgArray(value), arrayDimensions);
 };
-function varchar(a, b = {}) {
-  const { name: name2, config } = getColumnNameAndConfig2(a, b);
-  return new PgVarcharBuilder(name2, config);
-}
-// node_modules/drizzle-orm/pg-core/columns/bigserial.js
-var PgBigSerial53Builder = class extends PgColumnBuilder {
-  static [entityKind] = "PgBigSerial53Builder";
-  constructor(name2) {
-    super(name2, "number int53", "PgBigSerial53");
-    this.config.hasDefault = true;
-    this.config.notNull = true;
-  }
-  build(table) {
-    return new PgBigSerial53(table, this.config);
-  }
+var parseLineTuple = (v) => {
+  const [a, b, c] = v.slice(1, -1).split(",");
+  return [
+    Number.parseFloat(a),
+    Number.parseFloat(b),
+    Number.parseFloat(c)
+  ];
 };
-var PgBigSerial53 = class extends PgColumn {
-  static [entityKind] = "PgBigSerial53";
-  codec = "bigserial:number";
-  getSQLType() {
-    return "bigserial";
-  }
+var parseLineABC = (v) => {
+  const [a, b, c] = v.slice(1, -1).split(",");
+  return {
+    a: Number.parseFloat(a),
+    b: Number.parseFloat(b),
+    c: Number.parseFloat(c)
+  };
 };
-var PgBigSerial64Builder = class extends PgColumnBuilder {
-  static [entityKind] = "PgBigSerial64Builder";
-  constructor(name2) {
-    super(name2, "bigint int64", "PgBigSerial64");
-    this.config.hasDefault = true;
-    this.config.notNull = true;
-  }
-  build(table) {
-    return new PgBigSerial64(table, this.config);
-  }
+var parsePointTuple = (v) => {
+  const [x, y] = v.slice(1, -1).split(",");
+  return [Number.parseFloat(x), Number.parseFloat(y)];
 };
-var PgBigSerial64 = class extends PgColumn {
-  static [entityKind] = "PgBigSerial64";
-  codec = "bigserial";
-  getSQLType() {
-    return "bigserial";
+var parsePointXY = (v) => {
+  const [x, y] = v.slice(1, -1).split(",");
+  return {
+    x: Number.parseFloat(x),
+    y: Number.parseFloat(y)
+  };
+};
+var parseGeometryTuple = (v) => parseEWKB(v).point;
+var parseGeometryXY = (v) => {
+  const parsed = parseEWKB(v);
+  return {
+    x: parsed.point[0],
+    y: parsed.point[1]
+  };
+};
+var textToDate = (v) => new Date(v);
+var textToDateWithTz = (v) => /* @__PURE__ */ new Date(v + "+0000");
+var parsePgVector = (v) => {
+  const body = v.slice(1, -1);
+  if (body.length === 0)
+    return [];
+  return body.split(",").map(Number.parseFloat);
+};
+var genericPgCodecs = {
+  bytea: {
+    castInJson: (name2) => sql`encode(${name2}, 'base64')`,
+    castArrayInJson: arrayCompatCast((name2) => sql`encode(${name2}, 'base64')`),
+    normalizeInJson: (v) => Buffer.from(v, "base64"),
+    normalizeArrayInJson: arrayCompatNormalize((v) => Buffer.from(v, "base64"))
+  },
+  bigint: {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    normalizeInJson: BigInt,
+    normalizeArrayInJson: arrayCompatNormalize(BigInt)
+  },
+  "bigint:number": {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    normalize: Number,
+    normalizeArray: arrayCompatNormalize(Number),
+    normalizeInJson: Number,
+    normalizeArrayInJson: arrayCompatNormalize(Number)
+  },
+  "bigint:string": {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr
+  },
+  bigserial: {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    normalizeInJson: BigInt,
+    normalizeArrayInJson: arrayCompatNormalize(BigInt),
+    normalize: BigInt,
+    normalizeArray: arrayCompatNormalize(BigInt)
+  },
+  "bigserial:number": {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    normalize: Number,
+    normalizeArray: arrayCompatNormalize(Number),
+    normalizeInJson: Number,
+    normalizeArrayInJson: arrayCompatNormalize(Number)
+  },
+  date: {
+    normalizeInJson: textToDate,
+    normalizeArrayInJson: arrayCompatNormalize(textToDate)
+  },
+  "date:string": {},
+  enum: {
+    castArray: castToTextArr,
+    normalizeParamArray: makePgArray
+  },
+  "geometry(point)": {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    normalize: parseGeometryXY,
+    normalizeArray: arrayCompatNormalize(parseGeometryXY),
+    normalizeInJson: parseGeometryXY,
+    normalizeArrayInJson: arrayCompatNormalize(parseGeometryXY)
+  },
+  "geometry(point):tuple": {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    normalize: parseGeometryTuple,
+    normalizeArray: arrayCompatNormalize(parseGeometryTuple),
+    normalizeInJson: parseGeometryTuple,
+    normalizeArrayInJson: arrayCompatNormalize(parseGeometryTuple)
+  },
+  interval: { castArrayInJson: castToTextArr },
+  json: { normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true) },
+  jsonb: { normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true) },
+  line: {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    normalize: parseLineABC,
+    normalizeArray: arrayCompatNormalize(parseLineABC),
+    normalizeInJson: parseLineABC,
+    normalizeArrayInJson: arrayCompatNormalize(parseLineABC)
+  },
+  "line:tuple": {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    normalize: parseLineTuple,
+    normalizeArray: arrayCompatNormalize(parseLineTuple),
+    normalizeInJson: parseLineTuple,
+    normalizeArrayInJson: arrayCompatNormalize(parseLineTuple)
+  },
+  numeric: {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    castArray: castToTextArr
+  },
+  "numeric:number": {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    castArray: castToTextArr,
+    normalize: Number,
+    normalizeArray: arrayCompatNormalize(Number),
+    normalizeInJson: Number,
+    normalizeArrayInJson: arrayCompatNormalize(Number)
+  },
+  "numeric:bigint": {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    castArray: castToTextArr,
+    normalize: BigInt,
+    normalizeArray: arrayCompatNormalize(BigInt),
+    normalizeInJson: BigInt,
+    normalizeArrayInJson: arrayCompatNormalize(BigInt)
+  },
+  point: {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    normalize: parsePointXY,
+    normalizeArray: arrayCompatNormalize(parsePointXY),
+    normalizeInJson: parsePointXY,
+    normalizeArrayInJson: arrayCompatNormalize(parsePointXY)
+  },
+  "point:tuple": {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    normalize: parsePointTuple,
+    normalizeArray: arrayCompatNormalize(parsePointTuple),
+    normalizeInJson: parsePointTuple,
+    normalizeArrayInJson: arrayCompatNormalize(parsePointTuple)
+  },
+  timestamp: {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    normalizeInJson: textToDateWithTz,
+    normalizeArrayInJson: arrayCompatNormalize(textToDateWithTz)
+  },
+  timestamptz: {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr,
+    normalizeInJson: textToDate,
+    normalizeArrayInJson: arrayCompatNormalize(textToDate)
+  },
+  "timestamp:string": {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr
+  },
+  "timestamptz:string": {
+    castInJson: castToText,
+    castArrayInJson: castToTextArr
+  },
+  halfvec: {
+    normalize: parsePgVector,
+    normalizeArray: parsePgArrayAndNormalize(parsePgVector),
+    normalizeInJson: parsePgVector,
+    normalizeArrayInJson: arrayCompatNormalize(parsePgVector)
+  },
+  vector: {
+    normalize: parsePgVector,
+    normalizeArray: parsePgArrayAndNormalize(parsePgVector),
+    normalizeInJson: parsePgVector,
+    normalizeArrayInJson: arrayCompatNormalize(parsePgVector)
   }
 };
-function bigserial(a, b) {
-  const { name: name2, config } = getColumnNameAndConfig2(a, b);
-  if (config.mode === "number")
-    return new PgBigSerial53Builder(name2);
-  return new PgBigSerial64Builder(name2);
-}
+var refineGenericPgCodecs = (extension) => refineCodecs(genericPgCodecs, extension);
 
-// node_modules/drizzle-orm/pg-core/columns/char.js
-var PgCharBuilder = class extends PgColumnBuilder {
-  static [entityKind] = "PgCharBuilder";
-  constructor(name2, config) {
-    super(name2, config.enum?.length ? "string enum" : "string", "PgChar");
-    this.config.length = config.length ?? 1;
-    this.config.setLength = config.length !== undefined;
-    this.config.enumValues = config.enum;
+// node_modules/drizzle-orm/pg-core/columns/custom.js
+var PgCustomColumnBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgCustomColumnBuilder";
+  constructor(name2, fieldConfig, customTypeParams) {
+    super(name2, "custom", "PgCustomColumn");
+    this.config.fieldConfig = fieldConfig;
+    this.config.customTypeParams = customTypeParams;
   }
   build(table) {
-    return new PgChar(table, this.config);
+    return new PgCustomColumn(table, this.config);
   }
 };
-var PgChar = class extends PgColumn {
-  static [entityKind] = "PgChar";
-  codec = "char";
-  enumValues;
-  setLength;
+var PgCustomColumn = class extends PgColumn {
+  static [entityKind] = "PgCustomColumn";
+  codec;
+  sqlName;
+  mapFromJsonValue;
+  jsonSelectIdentifier;
   constructor(table, config) {
     super(table, config);
-    this.enumValues = config.enumValues;
-    this.setLength = config.setLength;
+    this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+    this.mapToDriverValue = config.customTypeParams.toDriver ?? this.mapToDriverValue;
+    this.mapFromDriverValue = config.customTypeParams.fromDriver ?? this.mapFromDriverValue;
+    this.mapFromJsonValue = config.customTypeParams.fromJson;
+    this.jsonSelectIdentifier = config.customTypeParams.forJsonSelect;
+    const cfgCodec = typeof config.customTypeParams.codec === "string" || typeof config.customTypeParams.codec === "undefined" ? config.customTypeParams.codec : config.customTypeParams.codec(config.fieldConfig);
+    this.codec = typeof cfgCodec === "string" ? resolvePgTypeAlias(cfgCodec) : undefined;
+    if (this.dimensions && config.customTypeParams.fromJson)
+      this.mapFromJsonValue = (value) => {
+        if (value === null)
+          return value;
+        const arr = typeof value === "string" ? parsePgArray(value) : value;
+        return this.mapJsonArrayElements(arr, config.customTypeParams.fromJson, this.dimensions);
+      };
+  }
+  mapJsonArrayElements(value, mapper, depth) {
+    if (depth > 0 && Array.isArray(value))
+      return value.map((v) => v === null ? null : this.mapJsonArrayElements(v, mapper, depth - 1));
+    return mapper(value);
   }
   getSQLType() {
-    return this.setLength ? `char(${this.length})` : `char`;
+    return this.sqlName;
   }
 };
-function char(a, b = {}) {
-  const { name: name2, config } = getColumnNameAndConfig2(a, b);
-  return new PgCharBuilder(name2, config);
+function customType(customTypeParams) {
+  return (a, b) => {
+    const { name: name2, config } = getColumnNameAndConfig2(a, b);
+    return new PgCustomColumnBuilder(name2, config, customTypeParams);
+  };
 }
-
-// node_modules/drizzle-orm/pg-core/columns/cidr.js
-var PgCidrBuilder = class extends PgColumnBuilder {
-  static [entityKind] = "PgCidrBuilder";
+// node_modules/drizzle-orm/pg-core/columns/double-precision.js
+var PgDoublePrecisionBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgDoublePrecisionBuilder";
   constructor(name2) {
-    super(name2, "string cidr", "PgCidr");
+    super(name2, "number double", "PgDoublePrecision");
   }
   build(table) {
-    return new PgCidr(table, this.config);
+    return new PgDoublePrecision(table, this.config);
   }
 };
-var PgCidr = class extends PgColumn {
-  static [entityKind] = "PgCidr";
-  codec = "cidr";
+var PgDoublePrecision = class extends PgColumn {
+  static [entityKind] = "PgDoublePrecision";
+  codec = "float8";
   getSQLType() {
-    return "cidr";
+    return "double precision";
   }
 };
-function cidr(name2) {
-  return new PgCidrBuilder(name2 ?? "");
+function doublePrecision(name2) {
+  return new PgDoublePrecisionBuilder(name2 ?? "");
 }
-
-// node_modules/drizzle-orm/pg-core/array.js
-function parsePgArrayValue(arrayString, startFrom, inQuotes) {
-  for (let i = startFrom;i < arrayString.length; i++) {
-    const char2 = arrayString[i];
-    if (char2 === "\\") {
-      i++;
-      continue;
-    }
-    if (char2 === '"')
-      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i + 1];
-    if (inQuotes)
-      continue;
-    if (char2 === "," || char2 === "}")
-      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i];
+// node_modules/drizzle-orm/pg-core/columns/integer.js
+var PgIntegerBuilder = class extends PgIntColumnBuilder {
+  static [entityKind] = "PgIntegerBuilder";
+  constructor(name2) {
+    super(name2, "number int32", "PgInteger");
   }
-  return [arrayString.slice(startFrom).replace(/\\/g, ""), arrayString.length];
-}
-function parsePgNestedArray(arrayString, startFrom = 0) {
-  const result = [];
-  let i = startFrom;
-  let lastCharIsComma = false;
-  while (i < arrayString.length) {
-    const char2 = arrayString[i];
-    if (char2 === ",") {
-      if (lastCharIsComma || i === startFrom)
-        result.push("");
-      lastCharIsComma = true;
-      i++;
-      continue;
-    }
-    lastCharIsComma = false;
-    if (char2 === "\\") {
-      i += 2;
-      continue;
-    }
-    if (char2 === '"') {
-      const [value2, startFrom2] = parsePgArrayValue(arrayString, i + 1, true);
-      result.push(value2);
-      i = startFrom2;
-      continue;
-    }
-    if (char2 === "}")
-      return [result, i + 1];
-    if (char2 === "{") {
-      const [value2, startFrom2] = parsePgNestedArray(arrayString, i + 1);
-      result.push(value2);
-      i = startFrom2;
-      continue;
-    }
-    const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);
-    result.push(value);
-    i = newStartFrom;
+  build(table) {
+    return new PgInteger(table, this.config);
   }
-  return [result, i];
-}
-function parsePgArray(arrayString) {
-  const [result] = parsePgNestedArray(arrayString, 1);
-  return result;
-}
-function makePgArray(array) {
-  return `{${array.map((item) => {
-    if (Array.isArray(item))
-      return makePgArray(item);
-    if (typeof item === "string")
-      return `"${item.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
-    return `${item}`;
-  }).join(",")}}`;
-}
-
-// node_modules/drizzle-orm/pg-core/columns/postgis_extension/utils.js
-function hexToBytes(hex) {
-  const bytes = [];
-  for (let c = 0;c < hex.length; c += 2)
-    bytes.push(Number.parseInt(hex.slice(c, c + 2), 16));
-  return new Uint8Array(bytes);
-}
-function bytesToFloat64(bytes, offset) {
-  const buffer = /* @__PURE__ */ new ArrayBuffer(8);
-  const view = new DataView(buffer);
-  for (let i = 0;i < 8; i++)
-    view.setUint8(i, bytes[offset + i]);
-  return view.getFloat64(0, true);
+};
+var PgInteger = class extends PgColumn {
+  static [entityKind] = "PgInteger";
+  codec = "int";
+  getSQLType() {
+    return "integer";
+  }
+};
+function integer(name2) {
+  return new PgIntegerBuilder(name2 ?? "");
 }
-function parseEWKB(hex) {
-  const bytes = hexToBytes(hex);
-  let offset = 0;
-  const byteOrder = bytes[offset];
-  offset += 1;
-  const view = new DataView(bytes.buffer);
-  const geomType = view.getUint32(offset, byteOrder === 1);
-  offset += 4;
-  let srid;
-  if (geomType & 536870912) {
-    srid = view.getUint32(offset, byteOrder === 1);
-    offset += 4;
+// node_modules/drizzle-orm/pg-core/columns/jsonb.js
+var PgJsonbBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgJsonbBuilder";
+  constructor(name2) {
+    super(name2, "object json", "PgJsonb");
   }
-  if ((geomType & 65535) === 1) {
-    const x = bytesToFloat64(bytes, offset);
-    offset += 8;
-    const y = bytesToFloat64(bytes, offset);
-    offset += 8;
-    return {
-      srid,
-      point: [x, y]
-    };
+  build(table) {
+    return new PgJsonb(table, this.config);
   }
-  throw new Error("Unsupported geometry type");
-}
-
-// node_modules/drizzle-orm/codecs.js
-var noopCodecs = {};
-var arrayToItemTypeCodecNameMap = {
-  cast: "cast",
-  castArray: "cast",
-  castInJson: "castInJson",
-  castArrayInJson: "castInJson",
-  castParam: "castParam",
-  castArrayParam: "castParam",
-  normalize: "normalize",
-  normalizeArray: "normalize",
-  normalizeInJson: "normalizeInJson",
-  normalizeArrayInJson: "normalizeInJson",
-  normalizeParam: "normalizeParam",
-  normalizeParamArray: "normalizeParam"
 };
-var itemToArrayTypeCodecNameMap = {
-  cast: "castArray",
-  castArray: "castArray",
-  castInJson: "castArrayInJson",
-  castArrayInJson: "castArrayInJson",
-  castParam: "castArrayParam",
-  castArrayParam: "castArrayParam",
-  normalize: "normalizeArray",
-  normalizeArray: "normalizeArray",
-  normalizeInJson: "normalizeArrayInJson",
-  normalizeArrayInJson: "normalizeArrayInJson",
-  normalizeParam: "normalizeParamArray",
-  normalizeParamArray: "normalizeParamArray"
+var PgJsonb = class extends PgColumn {
+  static [entityKind] = "PgJsonb";
+  codec = "jsonb";
+  constructor(table, config) {
+    super(table, config);
+  }
+  getSQLType() {
+    return "jsonb";
+  }
 };
-var CodecsCollection = class {
-  static [entityKind] = "CodecsCollection";
-  constructor(resolveTypes, codecs = noopCodecs) {
-    this.resolveTypes = resolveTypes;
-    this.codecs = codecs;
+function jsonb(name2) {
+  return new PgJsonbBuilder(name2 ?? "");
+}
+// node_modules/drizzle-orm/pg-core/columns/smallint.js
+var PgSmallIntBuilder = class extends PgIntColumnBuilder {
+  static [entityKind] = "PgSmallIntBuilder";
+  constructor(name2) {
+    super(name2, "number int16", "PgSmallInt");
   }
-  get(column, type) {
-    const sqlType = column.codec;
-    if (!sqlType)
-      return;
-    const codecType = column.dimensions ? itemToArrayTypeCodecNameMap[type] : arrayToItemTypeCodecNameMap[type];
-    return this.codecs[sqlType]?.[codecType];
+  build(table) {
+    return new PgSmallInt(table, this.config);
   }
-  apply(column, type, value) {
-    const sqlType = column.codec;
-    if (!sqlType)
-      return value;
-    const codecType = column.dimensions ? itemToArrayTypeCodecNameMap[type] : arrayToItemTypeCodecNameMap[type];
-    const codec = this.codecs[sqlType]?.[codecType];
-    if (!codec)
-      return value;
-    if (codecType === "castParam" || codecType === "castArrayParam")
-      return codec(value, column, column.dimensions);
-    return codec(value, column.dimensions);
+};
+var PgSmallInt = class extends PgColumn {
+  static [entityKind] = "PgSmallInt";
+  codec = "smallint";
+  getSQLType() {
+    return "smallint";
   }
 };
-function refineCodecs(source, extension = {}) {
-  const keys = new Set([...Object.keys(source), ...Object.keys(extension)]).values();
-  const result = {};
-  for (const k of keys) {
-    if (!(k in extension)) {
-      result[k] = source[k] ? { ...source[k] } : undefined;
-      continue;
-    }
-    if (!(k in source) || extension[k] === undefined) {
-      result[k] = extension[k] ? { ...extension[k] } : undefined;
-      continue;
-    }
-    const innerKeys = new Set([...Object.keys(extension[k]), ...Object.keys(source[k] ?? {})]).values();
-    result[k] = {};
-    for (const ik of innerKeys)
-      result[k][ik] = ik in extension[k] ? extension[k][ik] : source[k]?.[ik];
-  }
-  return result;
-}
-
-// node_modules/drizzle-orm/pg-core/codecs.js
-var PG_ALIAS_TO_TYPE_MAP = {
-  int2: "smallint",
-  integer: "int",
-  int4: "int",
-  int8: "bigint",
-  decimal: "numeric",
-  real: "float4",
-  double: "float8",
-  "double precision": "float8",
-  serial2: "smallserial",
-  serial4: "serial",
-  serial8: "bigserial",
-  character: "char",
-  "character varying": "varchar",
-  "time with time zone": "timetz",
-  "time without time zone": "time",
-  "timestamp with time zone": "timestamptz",
-  "timestamp without time zone": "timestamp",
-  boolean: "bool",
-  "bit varying": "varbit"
-};
-function resolvePgTypeAlias(type) {
-  return PG_ALIAS_TO_TYPE_MAP[type] ?? type;
+function smallint(name2) {
+  return new PgSmallIntBuilder(name2 ?? "");
 }
-var castToText = (name2) => sql`${name2}::text`;
-var castToTextArr = (name2, arrayDimensions) => sql`${name2}::text${sql.raw("[]".repeat(arrayDimensions))}`;
-var arrayCompatCast = (cast) => (name2, arrayDimensions) => {
-  if (!arrayDimensions)
-    return cast(name2);
-  const aliases = [];
-  for (let i = 0;i < arrayDimensions; i++)
-    aliases.push(sql.identifier(`s${i}`));
-  let indexed = name2;
-  for (const alias of aliases)
-    indexed = sql`${indexed}[${alias}]`;
-  let expression = sql`array(\
-select ${cast(indexed)} \
-from generate_subscripts(${name2}, ${sql.raw(arrayDimensions.toString())}) ${aliases[arrayDimensions - 1]} \
-order by ${aliases[arrayDimensions - 1]})`;
-  for (let dim = arrayDimensions - 1;dim > 0; dim--)
-    expression = sql`array(\
-select ${expression} \
-from generate_subscripts(${name2}, ${sql.raw(dim.toString())}) ${aliases[dim - 1]} \
-order by ${aliases[dim - 1]})`;
-  return sql`case when ${name2} is null then null else ${expression} end`;
-};
-var arrayCompatNormalize = (normalize) => {
-  const loop = (value, arrayDimensions) => {
-    const innerDimensions = arrayDimensions - 1;
-    if (arrayDimensions > 1)
-      for (let i = 0;i < value.length; ++i)
-        loop(value[i], innerDimensions);
-    else
-      for (let i = 0;i < value.length; ++i)
-        value[i] = normalize(value[i]);
-    return value;
-  };
-  return loop;
+// node_modules/drizzle-orm/pg-core/columns/text.js
+var PgTextBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgTextBuilder";
+  constructor(name2, config) {
+    super(name2, config.enum?.length ? "string enum" : "string", "PgText");
+    this.config.enumValues = config.enum;
+  }
+  build(table) {
+    return new PgText(table, this.config, this.config.enumValues);
+  }
 };
-var arrayCompatNormalizeInput = (normalize, transformToPgArray = false) => {
-  const loop = (value, arrayDimensions) => {
-    const innerDimensions = arrayDimensions - 1;
-    const out = Array.from({ length: value.length });
-    if (arrayDimensions > 1)
-      for (let i = 0;i < value.length; ++i)
-        out[i] = loop(value[i], innerDimensions);
-    else
-      for (let i = 0;i < value.length; ++i)
-        out[i] = normalize(value[i]);
-    return out;
-  };
-  return transformToPgArray ? (v, d) => makePgArray(loop(v, d)) : loop;
+var PgText = class extends PgColumn {
+  static [entityKind] = "PgText";
+  enumValues;
+  codec = "text";
+  constructor(table, config, enumValues) {
+    super(table, config);
+    this.enumValues = enumValues;
+  }
+  getSQLType() {
+    return "text";
+  }
 };
-var parsePgArrayAndNormalize = (normalize) => {
-  const codec = arrayCompatNormalize(normalize);
-  return (value, arrayDimensions) => codec(parsePgArray(value), arrayDimensions);
+function text(a, b = {}) {
+  const { name: name2, config } = getColumnNameAndConfig2(a, b);
+  return new PgTextBuilder(name2, config);
+}
+// node_modules/drizzle-orm/pg-core/columns/date.common.js
+var PgDateColumnBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgDateColumnBaseBuilder";
+  defaultNow() {
+    return this.default(sql`now()`);
+  }
 };
-var parseLineTuple = (v) => {
-  const [a, b, c] = v.slice(1, -1).split(",");
-  return [
-    Number.parseFloat(a),
-    Number.parseFloat(b),
-    Number.parseFloat(c)
-  ];
+
+// node_modules/drizzle-orm/pg-core/columns/timestamp.js
+var PgTimestampBuilder = class extends PgDateColumnBuilder {
+  static [entityKind] = "PgTimestampBuilder";
+  constructor(name2, withTimezone, precision) {
+    super(name2, "object date", "PgTimestamp");
+    this.config.withTimezone = withTimezone;
+    this.config.precision = precision;
+  }
+  build(table) {
+    return new PgTimestamp(table, this.config);
+  }
 };
-var parseLineABC = (v) => {
-  const [a, b, c] = v.slice(1, -1).split(",");
-  return {
-    a: Number.parseFloat(a),
-    b: Number.parseFloat(b),
-    c: Number.parseFloat(c)
+var PgTimestamp = class extends PgColumn {
+  static [entityKind] = "PgTimestamp";
+  codec;
+  withTimezone;
+  precision;
+  constructor(table, config) {
+    super(table, config);
+    this.withTimezone = config.withTimezone;
+    this.precision = config.precision;
+    this.codec = this.withTimezone ? "timestamptz" : "timestamp";
+  }
+  getSQLType() {
+    return `timestamp${this.precision === undefined ? "" : ` (${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
+  }
+  mapToDriverValue = (value) => {
+    if (typeof value === "string")
+      return value;
+    return value.toISOString();
   };
 };
-var parsePointTuple = (v) => {
-  const [x, y] = v.slice(1, -1).split(",");
-  return [Number.parseFloat(x), Number.parseFloat(y)];
+var PgTimestampStringBuilder = class extends PgDateColumnBuilder {
+  static [entityKind] = "PgTimestampStringBuilder";
+  constructor(name2, withTimezone, precision) {
+    super(name2, "string timestamp", "PgTimestampString");
+    this.config.withTimezone = withTimezone;
+    this.config.precision = precision;
+  }
+  build(table) {
+    return new PgTimestampString(table, this.config);
+  }
 };
-var parsePointXY = (v) => {
-  const [x, y] = v.slice(1, -1).split(",");
-  return {
-    x: Number.parseFloat(x),
-    y: Number.parseFloat(y)
+var PgTimestampString = class extends PgColumn {
+  static [entityKind] = "PgTimestampString";
+  codec;
+  withTimezone;
+  precision;
+  constructor(table, config) {
+    super(table, config);
+    this.withTimezone = config.withTimezone;
+    this.precision = config.precision;
+    this.codec = this.withTimezone ? "timestamptz:string" : "timestamp:string";
+  }
+  getSQLType() {
+    return `timestamp${this.precision === undefined ? "" : `(${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
+  }
+  mapToDriverValue = (value) => {
+    if (typeof value === "string")
+      return value;
+    return value.toISOString();
   };
 };
-var parseGeometryTuple = (v) => parseEWKB(v).point;
-var parseGeometryXY = (v) => {
-  const parsed = parseEWKB(v);
-  return {
-    x: parsed.point[0],
-    y: parsed.point[1]
-  };
+function timestamp(a, b = {}) {
+  const { name: name2, config } = getColumnNameAndConfig2(a, b);
+  if (config?.mode === "string")
+    return new PgTimestampStringBuilder(name2, config.withTimezone ?? false, config.precision);
+  return new PgTimestampBuilder(name2, config?.withTimezone ?? false, config?.precision);
+}
+// node_modules/drizzle-orm/pg-core/columns/varchar.js
+var PgVarcharBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgVarcharBuilder";
+  constructor(name2, config) {
+    super(name2, config.enum?.length ? "string enum" : "string", "PgVarchar");
+    this.config.length = config.length;
+    this.config.enumValues = config.enum;
+  }
+  build(table) {
+    return new PgVarchar(table, this.config);
+  }
 };
-var textToDate = (v) => new Date(v);
-var textToDateWithTz = (v) => /* @__PURE__ */ new Date(v + "+0000");
-var parsePgVector = (v) => {
-  const body = v.slice(1, -1);
-  if (body.length === 0)
-    return [];
-  return body.split(",").map(Number.parseFloat);
+var PgVarchar = class extends PgColumn {
+  static [entityKind] = "PgVarchar";
+  codec = "varchar";
+  enumValues;
+  constructor(table, config) {
+    super(table, config);
+    this.enumValues = config.enumValues;
+  }
+  getSQLType() {
+    return this.length === undefined ? `varchar` : `varchar(${this.length})`;
+  }
 };
-var genericPgCodecs = {
-  bytea: {
-    castInJson: (name2) => sql`encode(${name2}, 'base64')`,
-    castArrayInJson: arrayCompatCast((name2) => sql`encode(${name2}, 'base64')`),
-    normalizeInJson: (v) => Buffer.from(v, "base64"),
-    normalizeArrayInJson: arrayCompatNormalize((v) => Buffer.from(v, "base64"))
-  },
-  bigint: {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    normalizeInJson: BigInt,
-    normalizeArrayInJson: arrayCompatNormalize(BigInt)
-  },
-  "bigint:number": {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    normalize: Number,
-    normalizeArray: arrayCompatNormalize(Number),
-    normalizeInJson: Number,
-    normalizeArrayInJson: arrayCompatNormalize(Number)
-  },
-  "bigint:string": {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr
-  },
-  bigserial: {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    normalizeInJson: BigInt,
-    normalizeArrayInJson: arrayCompatNormalize(BigInt),
-    normalize: BigInt,
-    normalizeArray: arrayCompatNormalize(BigInt)
-  },
-  "bigserial:number": {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    normalize: Number,
-    normalizeArray: arrayCompatNormalize(Number),
-    normalizeInJson: Number,
-    normalizeArrayInJson: arrayCompatNormalize(Number)
-  },
-  date: {
-    normalizeInJson: textToDate,
-    normalizeArrayInJson: arrayCompatNormalize(textToDate)
-  },
-  "date:string": {},
-  enum: {
-    castArray: castToTextArr,
-    normalizeParamArray: makePgArray
-  },
-  "geometry(point)": {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    normalize: parseGeometryXY,
-    normalizeArray: arrayCompatNormalize(parseGeometryXY),
-    normalizeInJson: parseGeometryXY,
-    normalizeArrayInJson: arrayCompatNormalize(parseGeometryXY)
-  },
-  "geometry(point):tuple": {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    normalize: parseGeometryTuple,
-    normalizeArray: arrayCompatNormalize(parseGeometryTuple),
-    normalizeInJson: parseGeometryTuple,
-    normalizeArrayInJson: arrayCompatNormalize(parseGeometryTuple)
-  },
-  interval: { castArrayInJson: castToTextArr },
-  json: { normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true) },
-  jsonb: { normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true) },
-  line: {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    normalize: parseLineABC,
-    normalizeArray: arrayCompatNormalize(parseLineABC),
-    normalizeInJson: parseLineABC,
-    normalizeArrayInJson: arrayCompatNormalize(parseLineABC)
-  },
-  "line:tuple": {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    normalize: parseLineTuple,
-    normalizeArray: arrayCompatNormalize(parseLineTuple),
-    normalizeInJson: parseLineTuple,
-    normalizeArrayInJson: arrayCompatNormalize(parseLineTuple)
-  },
-  numeric: {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    castArray: castToTextArr
-  },
-  "numeric:number": {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    castArray: castToTextArr,
-    normalize: Number,
-    normalizeArray: arrayCompatNormalize(Number),
-    normalizeInJson: Number,
-    normalizeArrayInJson: arrayCompatNormalize(Number)
-  },
-  "numeric:bigint": {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    castArray: castToTextArr,
-    normalize: BigInt,
-    normalizeArray: arrayCompatNormalize(BigInt),
-    normalizeInJson: BigInt,
-    normalizeArrayInJson: arrayCompatNormalize(BigInt)
-  },
-  point: {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    normalize: parsePointXY,
-    normalizeArray: arrayCompatNormalize(parsePointXY),
-    normalizeInJson: parsePointXY,
-    normalizeArrayInJson: arrayCompatNormalize(parsePointXY)
-  },
-  "point:tuple": {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    normalize: parsePointTuple,
-    normalizeArray: arrayCompatNormalize(parsePointTuple),
-    normalizeInJson: parsePointTuple,
-    normalizeArrayInJson: arrayCompatNormalize(parsePointTuple)
-  },
-  timestamp: {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    normalizeInJson: textToDateWithTz,
-    normalizeArrayInJson: arrayCompatNormalize(textToDateWithTz)
-  },
-  timestamptz: {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr,
-    normalizeInJson: textToDate,
-    normalizeArrayInJson: arrayCompatNormalize(textToDate)
-  },
-  "timestamp:string": {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr
-  },
-  "timestamptz:string": {
-    castInJson: castToText,
-    castArrayInJson: castToTextArr
-  },
-  halfvec: {
-    normalize: parsePgVector,
-    normalizeArray: parsePgArrayAndNormalize(parsePgVector),
-    normalizeInJson: parsePgVector,
-    normalizeArrayInJson: arrayCompatNormalize(parsePgVector)
-  },
-  vector: {
-    normalize: parsePgVector,
-    normalizeArray: parsePgArrayAndNormalize(parsePgVector),
-    normalizeInJson: parsePgVector,
-    normalizeArrayInJson: arrayCompatNormalize(parsePgVector)
+function varchar(a, b = {}) {
+  const { name: name2, config } = getColumnNameAndConfig2(a, b);
+  return new PgVarcharBuilder(name2, config);
+}
+// node_modules/drizzle-orm/pg-core/columns/bigserial.js
+var PgBigSerial53Builder = class extends PgColumnBuilder {
+  static [entityKind] = "PgBigSerial53Builder";
+  constructor(name2) {
+    super(name2, "number int53", "PgBigSerial53");
+    this.config.hasDefault = true;
+    this.config.notNull = true;
+  }
+  build(table) {
+    return new PgBigSerial53(table, this.config);
   }
 };
-var refineGenericPgCodecs = (extension) => refineCodecs(genericPgCodecs, extension);
+var PgBigSerial53 = class extends PgColumn {
+  static [entityKind] = "PgBigSerial53";
+  codec = "bigserial:number";
+  getSQLType() {
+    return "bigserial";
+  }
+};
+var PgBigSerial64Builder = class extends PgColumnBuilder {
+  static [entityKind] = "PgBigSerial64Builder";
+  constructor(name2) {
+    super(name2, "bigint int64", "PgBigSerial64");
+    this.config.hasDefault = true;
+    this.config.notNull = true;
+  }
+  build(table) {
+    return new PgBigSerial64(table, this.config);
+  }
+};
+var PgBigSerial64 = class extends PgColumn {
+  static [entityKind] = "PgBigSerial64";
+  codec = "bigserial";
+  getSQLType() {
+    return "bigserial";
+  }
+};
+function bigserial(a, b) {
+  const { name: name2, config } = getColumnNameAndConfig2(a, b);
+  if (config.mode === "number")
+    return new PgBigSerial53Builder(name2);
+  return new PgBigSerial64Builder(name2);
+}
 
-// node_modules/drizzle-orm/pg-core/columns/custom.js
-var PgCustomColumnBuilder = class extends PgColumnBuilder {
-  static [entityKind] = "PgCustomColumnBuilder";
-  constructor(name2, fieldConfig, customTypeParams) {
-    super(name2, "custom", "PgCustomColumn");
-    this.config.fieldConfig = fieldConfig;
-    this.config.customTypeParams = customTypeParams;
+// node_modules/drizzle-orm/pg-core/columns/char.js
+var PgCharBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgCharBuilder";
+  constructor(name2, config) {
+    super(name2, config.enum?.length ? "string enum" : "string", "PgChar");
+    this.config.length = config.length ?? 1;
+    this.config.setLength = config.length !== undefined;
+    this.config.enumValues = config.enum;
   }
   build(table) {
-    return new PgCustomColumn(table, this.config);
+    return new PgChar(table, this.config);
   }
 };
-var PgCustomColumn = class extends PgColumn {
-  static [entityKind] = "PgCustomColumn";
-  codec;
-  sqlName;
-  mapFromJsonValue;
-  jsonSelectIdentifier;
+var PgChar = class extends PgColumn {
+  static [entityKind] = "PgChar";
+  codec = "char";
+  enumValues;
+  setLength;
   constructor(table, config) {
     super(table, config);
-    this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
-    this.mapToDriverValue = config.customTypeParams.toDriver ?? this.mapToDriverValue;
-    this.mapFromDriverValue = config.customTypeParams.fromDriver ?? this.mapFromDriverValue;
-    this.mapFromJsonValue = config.customTypeParams.fromJson;
-    this.jsonSelectIdentifier = config.customTypeParams.forJsonSelect;
-    const cfgCodec = typeof config.customTypeParams.codec === "string" || typeof config.customTypeParams.codec === "undefined" ? config.customTypeParams.codec : config.customTypeParams.codec(config.fieldConfig);
-    this.codec = typeof cfgCodec === "string" ? resolvePgTypeAlias(cfgCodec) : undefined;
-    if (this.dimensions && config.customTypeParams.fromJson)
-      this.mapFromJsonValue = (value) => {
-        if (value === null)
-          return value;
-        const arr = typeof value === "string" ? parsePgArray(value) : value;
-        return this.mapJsonArrayElements(arr, config.customTypeParams.fromJson, this.dimensions);
-      };
+    this.enumValues = config.enumValues;
+    this.setLength = config.setLength;
   }
-  mapJsonArrayElements(value, mapper, depth) {
-    if (depth > 0 && Array.isArray(value))
-      return value.map((v) => v === null ? null : this.mapJsonArrayElements(v, mapper, depth - 1));
-    return mapper(value);
+  getSQLType() {
+    return this.setLength ? `char(${this.length})` : `char`;
+  }
+};
+function char(a, b = {}) {
+  const { name: name2, config } = getColumnNameAndConfig2(a, b);
+  return new PgCharBuilder(name2, config);
+}
+
+// node_modules/drizzle-orm/pg-core/columns/cidr.js
+var PgCidrBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgCidrBuilder";
+  constructor(name2) {
+    super(name2, "string cidr", "PgCidr");
+  }
+  build(table) {
+    return new PgCidr(table, this.config);
   }
+};
+var PgCidr = class extends PgColumn {
+  static [entityKind] = "PgCidr";
+  codec = "cidr";
   getSQLType() {
-    return this.sqlName;
+    return "cidr";
   }
 };
-function customType(customTypeParams) {
-  return (a, b) => {
-    const { name: name2, config } = getColumnNameAndConfig2(a, b);
-    return new PgCustomColumnBuilder(name2, config, customTypeParams);
-  };
+function cidr(name2) {
+  return new PgCidrBuilder(name2 ?? "");
 }
 
 // node_modules/drizzle-orm/pg-core/columns/date.js
@@ -20581,12 +21253,12 @@ async function hashQuery(sql2, params) {
 var PgCountBuilder = class PgCountBuilder2 extends SQL {
   static [entityKind] = "PgCountBuilder";
   dialect;
-  static buildEmbeddedCount(source, filters, parens) {
+  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(PgCountBuilder2.buildEmbeddedCount(countConfig.source, countConfig.filters, true).queryChunks);
+    super(PgCountBuilder2.buildCount(countConfig.source, countConfig.filters, true).queryChunks);
     this.countConfig = countConfig;
     this.dialect = countConfig.dialect;
     this.mapWith((e) => {
@@ -20595,10 +21267,13 @@ var PgCountBuilder = class PgCountBuilder2 extends SQL {
       return Number(e ?? 0);
     });
   }
+  executableSql;
   build() {
-    const { filters, source } = this.countConfig;
-    const query = PgCountBuilder2.buildEmbeddedCount(source, filters);
-    return this.dialect.sqlToQuery(query);
+    if (!this.executableSql) {
+      const { source, filters } = this.countConfig;
+      this.executableSql = PgCountBuilder2.buildCount(source, filters);
+    }
+    return this.dialect.sqlToQuery(this.executableSql);
   }
 };
 
@@ -20850,7 +21525,6 @@ var SelectionProxyHandler = class SelectionProxyHandler2 {
 var PgDeleteBase2 = class {
   static [entityKind] = "PgDelete";
   config;
-  cacheConfig;
   constructor(table, session, dialect, withList) {
     this.session = session;
     this.dialect = dialect;
@@ -20898,7 +21572,7 @@ var PgDeleteBase2 = class {
 var PgAsyncDeleteBase2 = class extends PgDeleteBase2 {
   static [entityKind] = "PgAsyncDelete";
   _prepare(name2, generateName = false) {
-    const { session, config, dialect, cacheConfig } = this;
+    const { session, config, dialect } = this;
     const { returning: fields } = config;
     return tracer.startActiveSpan("drizzle.prepareQuery", () => {
       const query = dialect.sqlToQuery(this.getSQL());
@@ -20906,7 +21580,7 @@ var PgAsyncDeleteBase2 = class extends PgDeleteBase2 {
       return session.prepareQuery(query, fields ? "arrays" : "raw", name2 ?? generateName, mapper, {
         type: "delete",
         tables: [...extractUsedTable(this.config.table)]
-      }, cacheConfig);
+      });
     });
   }
   prepare(name2) {
@@ -20953,7 +21627,6 @@ var PgSelectBuilder2 = class {
     if (config.withList)
       this.withList = config.withList;
     this.distinct = config.distinct;
-    this.tagged = config.tagged;
   }
   from(source) {
     const isPartialSelect = !!this.fields;
@@ -20976,8 +21649,7 @@ var PgSelectBuilder2 = class {
       session: this.session,
       dialect: this.dialect,
       withList: this.withList,
-      distinct: this.distinct,
-      tagged: this.tagged
+      distinct: this.distinct
     });
   }
 };
@@ -21001,8 +21673,7 @@ var PgSelectBase2 = class extends TypedQueryBuilder {
       table: config.table,
       fields: { ...config.fields },
       distinct: config.distinct,
-      setOperators: [],
-      _tagged: config.tagged
+      setOperators: []
     };
     this.isPartialSelect = config.isPartialSelect;
     this._ = {
@@ -21179,6 +21850,7 @@ var PgSelectBase2 = class extends TypedQueryBuilder {
     return this;
   }
   getSQL() {
+    this.config.fieldsFlat = orderSelectedFields2(this.config.fields, undefined, this.dialect.codecs);
     return this.dialect.buildSelectQuery(this.config);
   }
   toSQL() {
@@ -21274,7 +21946,6 @@ params: ${params}`);
       this.cause = cause;
   }
 };
-
 // node_modules/drizzle-orm/relations.js
 var Relation2 = class {
   static [entityKind] = "RelationV2";
@@ -21355,15 +22026,13 @@ var orderByOperators2 = {
   asc,
   desc
 };
-function mapRelationalRow2(rows, isOne, buildQueryResultSelection, mapColumnValue, parseJson = false, parseJsonIfString = false, useJsonMappers = true) {
+function mapRelationalRow2(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)) {
-      if (useJsonMappers && field.mapFromJsonValue)
-        return (v2) => field.mapFromJsonValue(v2);
+    if (is(field, Column))
       decoder = field;
-    } else if (is(field, SQL))
+    else if (is(field, SQL))
       decoder = field.decoder;
     else if (is(field, SQL.Aliased))
       decoder = field.sql.decoder;
@@ -21371,6 +22040,8 @@ function mapRelationalRow2(rows, isOne, buildQueryResultSelection, mapColumnValu
       decoder = noopDecoder;
     else
       decoder = field.getSQL().decoder;
+    if (useJsonMappers && field.mapFromJsonValue)
+      return (v2) => field.mapFromJsonValue(v2);
     return decoder.mapFromDriverValue.isNoop ? codec ? (value) => codec(value, arrayDimensions) : undefined : codec ? (value) => decoder.mapFromDriverValue(codec(value, arrayDimensions)) : (value) => decoder.mapFromDriverValue(value);
   });
   for (let i = 0;i < maxIdx; ++i) {
@@ -21387,14 +22058,12 @@ function mapRelationalRow2(rows, isOne, buildQueryResultSelection, mapColumnValu
         } else if (parseJsonIfString && typeof row[selectionItem.key] === "string")
           row[selectionItem.key] = JSON.parse(row[selectionItem.key]);
         if (selectionItem.isArray) {
-          mapRelationalRow2(row[selectionItem.key], false, selectionItem.selection, mapColumnValue, false, parseJsonIfString);
+          mapRelationalRow2(row[selectionItem.key], false, selectionItem.selection, false, parseJsonIfString);
           continue;
         }
-        mapRelationalRow2(row[selectionItem.key], true, selectionItem.selection, mapColumnValue, false, parseJsonIfString);
+        mapRelationalRow2(row[selectionItem.key], true, selectionItem.selection, false, parseJsonIfString);
         continue;
       }
-      if (mapColumnValue)
-        row[selectionItem.key] = mapColumnValue(row[selectionItem.key]);
       if (row[selectionItem.key] === null)
         continue;
       const decoder = decoders[selectionItemIdx];
@@ -21405,7 +22074,7 @@ function mapRelationalRow2(rows, isOne, buildQueryResultSelection, mapColumnValu
   }
   return rows;
 }
-function mapRelationalRowFromArrays2(rows, isOne, buildQueryResultSelection, mapColumnValue, parseJson = false, parseJsonIfString = false) {
+function mapRelationalRowFromArrays2(rows, isOne, buildQueryResultSelection, parseJson = false, parseJsonIfString = false) {
   const maxIdx = isOne ? 1 : rows.length;
   const decoders = buildQueryResultSelection.map(({ field, codec, arrayDimensions }) => {
     let decoder;
@@ -21442,14 +22111,12 @@ function mapRelationalRowFromArrays2(rows, isOne, buildQueryResultSelection, map
         } else if (parseJsonIfString && typeof value === "string")
           value = JSON.parse(value);
         if (selectionItem.isArray)
-          mapRelationalRow2(value, false, selectionItem.selection, mapColumnValue, false, parseJsonIfString);
+          mapRelationalRow2(value, false, selectionItem.selection, false, parseJsonIfString);
         else
-          mapRelationalRow2(value, true, selectionItem.selection, mapColumnValue, false, parseJsonIfString);
+          mapRelationalRow2(value, true, selectionItem.selection, false, parseJsonIfString);
         result[selectionItem.key] = value;
         continue;
       }
-      if (mapColumnValue)
-        value = mapColumnValue(value);
       if (value === null) {
         result[selectionItem.key] = null;
         continue;
@@ -21461,14 +22128,14 @@ function mapRelationalRowFromArrays2(rows, isOne, buildQueryResultSelection, map
   }
   return isOne ? results[0] : results;
 }
-function makeDefaultRqbMapper2({ selection, isFirst, parseJson, parseJsonIfString, rootJsonMappers, arrayModeRoot }, mapColumnValue) {
+function makeDefaultRqbMapper2({ selection, isFirst, parseJson, parseJsonIfString, rootJsonMappers, arrayModeRoot }) {
   return (rows) => {
     if (isFirst && !rows[0])
       return rows[0];
-    return arrayModeRoot ? mapRelationalRowFromArrays2(isFirst ? rows[0] : rows, isFirst, selection, mapColumnValue, parseJson, parseJsonIfString) : mapRelationalRow2(isFirst ? rows[0] : rows, isFirst, selection, mapColumnValue, parseJson, parseJsonIfString, rootJsonMappers);
+    return arrayModeRoot ? mapRelationalRowFromArrays2(isFirst ? rows[0] : rows, isFirst, selection, parseJson, parseJsonIfString) : mapRelationalRow2(isFirst ? rows[0] : rows, isFirst, selection, parseJson, parseJsonIfString, rootJsonMappers);
   };
 }
-function makeJitRqbMapperInner(selection, rowExpr, selectionVar, mapColumnValue, parseJson, parseJsonIfString, useJsonMappers, preFn, counter, accessByIdx) {
+function makeJitRqbMapperInner(selection, rowExpr, selectionVar, parseJson, parseJsonIfString, useJsonMappers, preFn, counter, accessByIdx) {
   const bodyStmts = [];
   const literalEntries = [];
   let hasWork = false;
@@ -21492,7 +22159,7 @@ function makeJitRqbMapperInner(selection, rowExpr, selectionVar, mapColumnValue,
       preFn.push(`const { selection: ${nestedSelVar} } = ${sel};`);
       if (isArray) {
         const j = `j${counter.n++}`;
-        const inner = makeJitRqbMapperInner(innerSelection, `${slot}[${j}]`, nestedSelVar, mapColumnValue, false, parseJsonIfString, true, preFn, counter, false);
+        const inner = makeJitRqbMapperInner(innerSelection, `${slot}[${j}]`, nestedSelVar, false, parseJsonIfString, true, preFn, counter, false);
         if (inner.hasWork) {
           hasWork = true;
           bodyStmts.push(`if (${slot} !== null) {`);
@@ -21505,7 +22172,7 @@ function makeJitRqbMapperInner(selection, rowExpr, selectionVar, mapColumnValue,
         } else
           preFn.splice(savedPreFnLen, 1);
       } else {
-        const inner = makeJitRqbMapperInner(innerSelection, slot, nestedSelVar, mapColumnValue, false, parseJsonIfString, true, preFn, counter, false);
+        const inner = makeJitRqbMapperInner(innerSelection, slot, nestedSelVar, false, parseJsonIfString, true, preFn, counter, false);
         if (inner.hasWork) {
           hasWork = true;
           bodyStmts.push(`if (${slot} !== null) {`);
@@ -21534,21 +22201,39 @@ function makeJitRqbMapperInner(selection, rowExpr, selectionVar, mapColumnValue,
         decoderExpr = `dec${id}.mapFromDriverValue`;
       }
     } else if (is(field, SQL)) {
-      if (!field.decoder.mapFromDriverValue.isNoop) {
+      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 (!field.sql.decoder.mapFromDriverValue.isNoop) {
+      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 if (!field.getSQL().decoder.mapFromDriverValue.isNoop) {
-      const id = counter.n++;
-      preFn.push(`const dec${id} = ${sel}.field.getSQL().decoder;`);
-      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)
@@ -21561,19 +22246,7 @@ function makeJitRqbMapperInner(selection, rowExpr, selectionVar, mapColumnValue,
         parts.push(`codec: ${codecVar}`);
       preFn.push(`const { ${parts.join(", ")} } = ${sel};`);
     }
-    if (mapColumnValue) {
-      hasWork = true;
-      bodyStmts.push(`${slot} = mapColumnValue(${slot});`);
-      if (decoderExpr || codecVar) {
-        let decoded = slot;
-        if (codecVar)
-          decoded = `${codecVar}(${decoded}, ${arrayDimensions})`;
-        if (decoderExpr)
-          decoded = `${decoderExpr}(${decoded})`;
-        bodyStmts.push(`if (${slot} !== null) ${slot} = ${decoded};`);
-      }
-      literalEntries.push(`${keyStr}: ${slot}`);
-    } else if (decoderExpr || codecVar) {
+    if (decoderExpr || codecVar) {
       hasWork = true;
       let decoded = slot;
       if (codecVar)
@@ -21590,12 +22263,12 @@ function makeJitRqbMapperInner(selection, rowExpr, selectionVar, mapColumnValue,
     hasWork
   };
 }
-function makeJitRqbMapper2({ selection, isFirst, parseJson, parseJsonIfString, rootJsonMappers, arrayModeRoot }, mapColumnValue) {
+function makeJitRqbMapper2({ selection, isFirst, parseJson, parseJsonIfString, rootJsonMappers, arrayModeRoot }) {
   const preFn = [];
-  const inner = makeJitRqbMapperInner(selection, "row", "selection", mapColumnValue, parseJson, parseJsonIfString, arrayModeRoot ? false : rootJsonMappers, preFn, { n: 0 }, !!arrayModeRoot);
+  const inner = makeJitRqbMapperInner(selection, "row", "selection", parseJson, parseJsonIfString, arrayModeRoot ? false : rootJsonMappers, preFn, { n: 0 }, !!arrayModeRoot);
   const lines = [];
   lines.push(`	"use strict";
-	const { selection${mapColumnValue ? `, mapColumnValue` : ""} } = this;`);
+	const { selection } = this;`);
   for (const p2 of preFn)
     lines.push(`	${p2}`);
   if (arrayModeRoot)
@@ -21637,10 +22310,7 @@ function makeJitRqbMapper2({ selection, isFirst, parseJson, parseJsonIfString, r
   lines.push("\t//# sourceURL=drizzle:jit-relational-query-mapper");
   const compiled = lines.join(`
 `);
-  return Object.assign(new FnConstructor2("rows", compiled).bind({
-    selection,
-    mapColumnValue
-  }), { body: `function jitRqbMapper (rows) {
+  return Object.assign(new FnConstructor2("rows", compiled).bind({ selection }), { body: `function jitRqbMapper (rows) {
 ${compiled}
 }` });
 }
@@ -21763,17 +22433,23 @@ function relationsOrderToSQL2(table, orders) {
     return;
   return sql.join(entries.map(([target, value]) => (value === "asc" ? asc : desc)(fieldSelectionToSQL2(table, target))), sql`, `);
 }
-function relationExtrasToSQL2(table, extras) {
+function relationExtrasToSQL2(table, extras, codecs, inJson) {
   const subqueries = [];
   const selection = [];
   for (const [key, field] of Object.entries(extras)) {
     if (!field)
       continue;
-    const extra = typeof field === "function" ? field(table, { sql: operators2.sql }) : field;
-    const query = sql`(${extra.getSQL()}) as ${sql.identifier(key)}`;
-    query.decoder = extra.getSQL().decoder;
+    const subq = (typeof field === "function" ? field(table, { sql: operators2.sql }) : field).getSQL();
+    const column = codecs ? getColumnFromDecoder2(subq) : undefined;
+    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({
+    selection.push(column && (!inJson || !column.mapFromJsonValue) ? {
+      key,
+      field: query,
+      codec: codecs.get(column, inJson ? "normalizeInJson" : "normalize"),
+      arrayDimensions: column.dimensions
+    } : {
       key,
       field: query
     });
@@ -21882,43 +22558,58 @@ var PgDialect2 = class {
   }
   buildSelection(fields, { isSingleTable = false, ignoreCastCodecs = false } = {}) {
     const columnsLen = fields.length;
-    const chunks = fields.flatMap(({ field }, i) => {
+    const chunks = fields.flatMap(({ field, codecOverride, column }, i) => {
       const chunk = [];
-      if (is(field, SQL.Aliased) && field.isSelectionField) {
-        if (!isSingleTable && field.origin !== undefined)
-          chunk.push(sql.identifier(field.origin), sql.raw("."));
-        chunk.push(sql.identifier(field.fieldAlias));
-      } else if (is(field, SQL.Aliased) || is(field, SQL)) {
-        const query = is(field, SQL.Aliased) ? field.sql : field;
+      const override = codecOverride;
+      if (is(field, SQL.Aliased))
+        if (field.isSelectionField) {
+          const query = !isSingleTable && field.origin !== undefined ? sql`${sql.identifier(field.origin)}.${sql.identifier(field.fieldAlias)}` : sql.identifier(field.fieldAlias);
+          if (column && !ignoreCastCodecs)
+            chunk.push(this.codecs.apply(column, "cast", query, override));
+          else
+            chunk.push(query);
+        } else {
+          const query = field.sql;
+          if (isSingleTable) {
+            const newSql = new SQL(query.queryChunks.map((c) => {
+              if (is(c, PgColumn))
+                return sql.identifier(c.name);
+              return c;
+            }));
+            if (query.shouldInlineParams)
+              newSql.inlineParams();
+            chunk.push(column && !ignoreCastCodecs ? this.codecs.apply(column, "cast", newSql, override) : newSql);
+          } else
+            chunk.push(column && !ignoreCastCodecs ? this.codecs.apply(column, "cast", query, override) : 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, PgColumn))
               return sql.identifier(c.name);
             return c;
           }));
-          chunk.push(query.shouldInlineParams ? newSql.inlineParams() : newSql);
+          if (query.shouldInlineParams)
+            newSql.inlineParams();
+          chunk.push(column && !ignoreCastCodecs ? this.codecs.apply(column, "cast", newSql, override) : newSql);
         } else
-          chunk.push(query);
-        if (is(field, SQL.Aliased))
-          chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
+          chunk.push(column && !ignoreCastCodecs ? this.codecs.apply(column, "cast", query, override) : query);
       } else if (is(field, Column)) {
         let name2;
         if (isSingleTable)
           name2 = field.isAlias ? sql.identifier(getOriginalColumnFromAlias2(field).name) : sql.identifier(field.name);
         else
           name2 = field.isAlias ? getOriginalColumnFromAlias2(field) : field;
-        const casted = ignoreCastCodecs ? name2 : this.codecs.apply(field, "cast", name2);
+        const casted = ignoreCastCodecs ? name2 : this.codecs.apply(field, "cast", name2, override);
         chunk.push(field.isAlias ? sql`${casted} as ${field}` : casted);
-      } else if (is(field, Subquery)) {
-        const entries = Object.entries(field._.selectedFields);
-        if (entries.length === 1) {
-          const entry = entries[0][1];
-          const fieldDecoder = is(entry, SQL) ? entry.decoder : is(entry, Column) ? { mapFromDriverValue: (v2) => entry.mapFromDriverValue(v2) } : entry.sql.decoder;
-          if (fieldDecoder)
-            field._.sql.decoder = fieldDecoder;
-        }
-        chunk.push(field);
-      }
+      } else if (is(field, Subquery))
+        if (column && !ignoreCastCodecs && !field._.isWith) {
+          const innerCasted = this.codecs.apply(column, "cast", sql`(${field._.sql})`, override);
+          chunk.push(sql`${innerCasted} ${sql.identifier(field._.alias)}`);
+        } else
+          chunk.push(column ? this.codecs.apply(column, "cast", field) : field, override);
       if (i < columnsLen - 1)
         chunk.push(sql`, `);
       return chunk;
@@ -21969,8 +22660,10 @@ var PgDialect2 = class {
     }
     return table;
   }
-  buildSelectQuery({ withList, fields, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, lockingClause, distinct, setOperators, comment, ignoreSelectionCastCodecs }) {
-    const fieldsList = fieldsFlat ?? orderSelectedFields2(fields, undefined, this.codecs);
+  buildSelectQuery({ withList, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, lockingClause, distinct, setOperators, comment, ignoreSelectionCastCodecs }) {
+    if (!fieldsFlat)
+      throw new Error("Select query builder must be provided with `fieldsFlat` on `buildSelectQuery` invocation");
+    const fieldsList = fieldsFlat;
     for (const f of fieldsList)
       if (is(f.field, Column) && getTableName(f.field.table) !== (is(table, Subquery) ? table._.alias : is(table, PgViewBase) ? table[ViewBaseConfig].name : is(table, SQL) ? undefined : getTableName(table)) && !((table2) => joins?.some(({ alias: alias2 }) => alias2 === (table2[Table.Symbol.IsAlias] ? getTableName(table2) : table2[Table.Symbol.BaseName])))(f.field.table)) {
         const tableName = getTableName(f.field.table);
@@ -21983,7 +22676,7 @@ var PgDialect2 = class {
       distinctSql = distinct === true ? sql` distinct` : sql` distinct on (${sql.join(distinct.on, sql`, `)})`;
     const selection = this.buildSelection(fieldsList, {
       isSingleTable,
-      ignoreCastCodecs: ignoreSelectionCastCodecs
+      ignoreCastCodecs: ignoreSelectionCastCodecs || setOperators.length > 0
     });
     const tableSql = this.buildFromTable(table);
     const joinsSql = this.buildJoins(joins);
@@ -22010,26 +22703,67 @@ var PgDialect2 = class {
     }
     const finalQuery = sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClauseSql}${comment !== undefined ? sql` ${comment}` : undefined}`;
     if (setOperators.length > 0)
-      return this.buildSetOperations(finalQuery, setOperators);
+      return this.buildSetOperations(finalQuery, fieldsList, ignoreSelectionCastCodecs, 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({
+  buildSetOperations(leftSelect, leftSelection, ignoreSelectionCastCodecs, setOperators) {
+    const outputSelection = leftSelection;
+    for (let i = 0;i < setOperators.length; ++i) {
+      const setOperator = setOperators[i];
+      if (!setOperator)
+        throw new Error("Cannot pass undefined values to any set operator");
+      leftSelect = this.buildSetOperationQuery({
         leftSelect,
         setOperator
       });
-    return this.buildSetOperations(this.buildSetOperationQuery({
-      leftSelect,
-      setOperator
-    }), rest);
+      const rightSelection = orderSelectedFields2(setOperator.rightSelect.getSelectedFields());
+      for (let j = 0;j < outputSelection.length; ++j) {
+        const l = outputSelection[j];
+        const lPath = l.path.join(".");
+        const r = rightSelection.find((e) => e.path.join(".") === lPath);
+        const lc = l.codecOverride ?? l.column?.codec;
+        const rc = r.codecOverride ?? r.column?.codec;
+        outputSelection[j].codecOverride = lc && rc ? unionsTypeTable[lc]?.[rc] : lc;
+      }
+    }
+    for (let i = 0;i < outputSelection.length; ++i) {
+      const out = outputSelection[i];
+      out.codec = out.codecOverride ? this.codecs.get(out.column, "normalize", out.codecOverride) : out.codec;
+    }
+    return ignoreSelectionCastCodecs ? leftSelect : sql`select ${this.buildSelection(outputSelection.map((field) => {
+      if (is(field.field, SQL.Aliased)) {
+        const ref = field.field.clone();
+        ref.isSelectionField = true;
+        return {
+          ...field,
+          field: ref
+        };
+      }
+      if (is(field.field, Column) && field.field.isAlias) {
+        const ref = new SQL.Aliased(sql`${sql.identifier(field.field.name)}`, field.field.name);
+        ref.isSelectionField = true;
+        return {
+          ...field,
+          field: ref
+        };
+      }
+      if (is(field.field, Subquery)) {
+        const ref = new SQL.Aliased(sql`${field.field.getSQL()}`, field.field._.alias);
+        ref.isSelectionField = true;
+        return {
+          ...field,
+          field: ref
+        };
+      }
+      return field;
+    }), {
+      isSingleTable: true,
+      ignoreCastCodecs: ignoreSelectionCastCodecs
+    })} from (${leftSelect}) ${sql.identifier("drizzle_union")}`;
   }
   buildSetOperationQuery({ leftSelect, setOperator: { type, isAll, rightSelect, limit, orderBy, offset } }) {
     const leftChunk = sql`(${leftSelect.getSQL()}) `;
-    const rightChunk = sql`(${rightSelect.getSQL()})`;
+    const rightChunk = sql`(${rightSelect.withoutSelectionCastCodecs().getSQL()})`;
     let orderBySql;
     if (orderBy && orderBy.length > 0) {
       const orderByValues = [];
@@ -22055,8 +22789,9 @@ var PgDialect2 = class {
   buildInsertQuery({ table, values: valuesOrSelect, onConflict, returning, withList, select, overridingSystemValue_, comment, ignoreSelectionCastCodecs }) {
     const valuesSqlList = [];
     const columns = table[Table.Symbol.Columns];
-    const colEntries = Object.entries(columns).filter(([_, col]) => !col.shouldDisableInsert());
-    const insertOrder = colEntries.map(([, column]) => sql.identifier(column.name));
+    const colEntries = Object.entries(columns);
+    const colFilteredEntries = select && !is(valuesOrSelect, SQL) ? Object.keys(valuesOrSelect.getSelectedFields()).map((key) => [key, columns[key]]) : overridingSystemValue_ ? colEntries : colEntries.filter(([_, col]) => !col.shouldDisableInsert());
+    const insertOrder = colFilteredEntries.map(([, column]) => sql.identifier(column.name));
     if (select) {
       const select2 = valuesOrSelect;
       if (is(select2, SQL))
@@ -22068,7 +22803,7 @@ var PgDialect2 = class {
       valuesSqlList.push(sql.raw("values "));
       for (const [valueIndex, value] of values.entries()) {
         const valueList = [];
-        for (const [fieldName, col] of colEntries) {
+        for (const [fieldName, col] of colFilteredEntries) {
           const colValue = value[fieldName];
           if (colValue === undefined || is(colValue, Param) && colValue.value === undefined)
             if (col.defaultFn !== undefined) {
@@ -22119,31 +22854,48 @@ var PgDialect2 = class {
       tagged: true
     });
   }
-  nestedSelectionerror() {
+  buildRqbColumn(table, field, key, inJson) {
+    if (is(field, Column)) {
+      const name2 = sql`${table}.${sql.identifier(field.name)}`;
+      return sql`${inJson && field.jsonSelectIdentifier ? field.jsonSelectIdentifier(name2, sql, field.dimensions) : this.codecs.apply(field, inJson ? "castInJson" : "cast", name2)} as ${sql.identifier(key)}`;
+    }
+    if (is(field, SQL.Aliased)) {
+      const column = getColumnFromDecoder2(field);
+      const q = sql`${table}.${sql.identifier(field.fieldAlias)}`;
+      return sql`${column ? this.codecs.apply(column, inJson ? "castInJson" : "cast", q) : q} as ${sql.identifier(key)}`;
+    }
+    if (isSQLWrapper(field)) {
+      const column = getColumnFromDecoder2(field);
+      const q = sql`${table}.${sql.identifier(key)}`;
+      return sql`${column ? this.codecs.apply(column, inJson ? "castInJson" : "cast", q) : q} as ${sql.identifier(key)}`;
+    }
     throw new DrizzleError2({ 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)}`;
-      return sql`${inJson && column.jsonSelectIdentifier ? column.jsonSelectIdentifier(name2, sql, column.dimensions) : this.codecs.apply(column, inJson ? "castInJson" : "cast", 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)}`;
+  resolveSelection(field, key, inJson) {
+    if (is(field, Column))
+      return {
+        key,
+        field,
+        codec: this.codecs.get(field, inJson ? "normalizeInJson" : "normalize"),
+        arrayDimensions: field.dimensions
+      };
+    const decoderColumn = getColumnFromDecoder2(field);
+    return decoderColumn ? {
+      key,
+      field,
+      codec: decoderColumn && (!inJson || !decoderColumn.mapFromJsonValue) ? this.codecs.get(decoderColumn, inJson ? "normalizeInJson" : "normalize") : undefined,
+      arrayDimensions: decoderColumn.dimensions
+    } : {
+      key,
+      field
+    };
   }
-  unwrapAllColumns = (table, selection, inJson) => {
-    return sql.join(Object.entries(table[TableColumns]).map(([k, v2]) => {
-      selection.push(is(v2, Column) ? {
-        key: k,
-        codec: this.codecs.get(v2, inJson ? "normalizeInJson" : "normalize"),
-        arrayDimensions: v2.dimensions,
-        field: v2
-      } : {
-        key: k,
-        field: v2
-      });
-      return this.buildRqbColumn(table, v2, k, inJson);
-    }), sql`, `);
-  };
-  buildColumns = (table, selection, inJson, config) => config?.columns ? (() => {
+  buildColumns = (table, selection, inJson, config) => {
+    if (!config?.columns)
+      return sql.join(Object.entries(table[TableColumns]).map(([k, v2]) => {
+        selection.push(this.resolveSelection(v2, k, inJson));
+        return this.buildRqbColumn(table, v2, k, inJson);
+      }), sql`, `);
     const entries = Object.entries(config.columns);
     const columnContainer = table[TableColumns];
     const columnIdentifiers = [];
@@ -22155,15 +22907,7 @@ var PgDialect2 = class {
       if (v2) {
         const column = columnContainer[k];
         columnIdentifiers.push(this.buildRqbColumn(table, column, k, inJson));
-        selection.push(is(column, Column) ? {
-          key: k,
-          codec: this.codecs.get(column, inJson ? "normalizeInJson" : "normalize"),
-          arrayDimensions: column.dimensions,
-          field: column
-        } : {
-          key: k,
-          field: column
-        });
+        selection.push(this.resolveSelection(column, k, inJson));
       }
     }
     if (colSelectionMode === false)
@@ -22171,18 +22915,10 @@ var PgDialect2 = class {
         if (config.columns[k] === false)
           continue;
         columnIdentifiers.push(this.buildRqbColumn(table, v2, k, inJson));
-        selection.push(is(v2, Column) ? {
-          key: k,
-          codec: this.codecs.get(v2, inJson ? "normalizeInJson" : "normalize"),
-          arrayDimensions: v2.dimensions,
-          field: v2
-        } : {
-          key: k,
-          field: v2
-        });
+        selection.push(this.resolveSelection(v2, k, inJson));
       }
     return columnIdentifiers.length ? sql.join(columnIdentifiers, sql`, `) : undefined;
-  })() : this.unwrapAllColumns(table, selection, inJson);
+  };
   buildRelationalQuery({ schema, table, tableConfig, queryConfig: config, relationWhere, mode, errorPath, depth, throughJoin, nested }) {
     const selection = [];
     const isSingle = mode === "first";
@@ -22196,7 +22932,7 @@ var PgDialect2 = class {
     const where = params?.where && relationWhere ? and(relationsFilterToSQL2(table, params.where, tableConfig.relations, schema), relationWhere) : params?.where ? relationsFilterToSQL2(table, params.where, tableConfig.relations, schema) : relationWhere;
     const order = params?.orderBy ? relationsOrderToSQL2(table, params.orderBy) : undefined;
     const columns = this.buildColumns(table, selection, !!nested, params);
-    const extras = params?.extras ? relationExtrasToSQL2(table, params.extras) : undefined;
+    const extras = params?.extras ? relationExtrasToSQL2(table, params.extras, this.codecs, nested) : undefined;
     if (extras)
       selection.push(...extras.selection);
     const selectionArr = columns ? [columns] : [];
@@ -22346,11 +23082,6 @@ var PgInsertBuilder2 = class {
     this.overridingSystemValue_ = overridingSystemValue_;
     this.builder = builder;
   }
-  authToken;
-  setToken(token) {
-    this.authToken = token;
-    return this;
-  }
   overridingSystemValue() {
     this.overridingSystemValue_ = true;
     return this;
@@ -22368,27 +23099,25 @@ var PgInsertBuilder2 = class {
       }
       return result;
     });
-    const builder = new this.builder(this.table, mappedValues, this.session, this.dialect, this.withList, false, this.overridingSystemValue_);
-    if ("setToken" in builder)
-      builder.setToken(this.authToken);
-    return builder;
+    return new this.builder(this.table, mappedValues, this.session, this.dialect, this.withList, false, this.overridingSystemValue_);
   }
   select(selectQuery) {
     const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder2) : selectQuery;
     if ("withoutSelectionCastCodecs" in select)
       select.withoutSelectionCastCodecs();
-    if (!is(select, SQL) && !haveSameKeys2(this.table[TableColumns], select._.selectedFields))
-      throw new Error("Insert select error: selected fields are not the same or are in a different order compared to the table definition");
-    const builder = new this.builder(this.table, select, this.session, this.dialect, this.withList, true);
-    if ("setToken" in builder)
-      builder.setToken(this.authToken);
-    return builder;
+    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, this.overridingSystemValue_);
   }
 };
 var PgInsertBase2 = class {
   static [entityKind] = "PgInsert";
   config;
-  cacheConfig;
   constructor(table, values, session, dialect, withList, select, overridingSystemValue_) {
     this.session = session;
     this.dialect = dialect;
@@ -22458,7 +23187,7 @@ var PgInsertBase2 = class {
 var PgAsyncInsertBase2 = class extends PgInsertBase2 {
   static [entityKind] = "PgAsyncInsert";
   _prepare(name2, generateName = false) {
-    const { session, config, dialect, cacheConfig } = this;
+    const { session, config, dialect } = this;
     const { returning: fields } = config;
     return tracer.startActiveSpan("drizzle.prepareQuery", () => {
       const query = dialect.sqlToQuery(this.getSQL());
@@ -22466,7 +23195,7 @@ var PgAsyncInsertBase2 = class extends PgInsertBase2 {
       return session.prepareQuery(query, fields ? "arrays" : "raw", name2 ?? generateName, mapper, {
         type: "insert",
         tables: [...extractUsedTable(this.config.table)]
-      }, cacheConfig);
+      });
     });
   }
   prepare(name2) {
@@ -22511,10 +23240,10 @@ applyMixins2(PgAsyncRelationalQuery2, [QueryPromise2]);
 // node_modules/drizzle-orm/pg-core/query-builders/raw.js
 var PgRaw = class {
   static [entityKind] = "PgRaw";
-  constructor(sql2, query, mapBatchResult) {
+  constructor(prepared, sql2, query) {
+    this.prepared = prepared;
     this.sql = sql2;
     this.query = query;
-    this.mapBatchResult = mapBatchResult;
   }
   getSQL() {
     return this.sql;
@@ -22522,20 +23251,22 @@ var PgRaw = class {
   getQuery() {
     return this.query;
   }
-  mapResult(result, isFromBatch) {
-    return isFromBatch ? this.mapBatchResult(result) : result;
+  _prepare() {
+    return this.prepared;
   }
 };
 
 // node_modules/drizzle-orm/pg-core/async/raw.js
 var PgAsyncRaw2 = class extends PgRaw {
   static [entityKind] = "PgAsyncRaw";
-  constructor(execute, sql2, query, mapBatchResult) {
-    super(sql2, query, mapBatchResult);
-    this.execute = execute;
+  constructor(prepared, sql2, query) {
+    super(prepared, sql2, query);
+  }
+  execute(placeholderValues) {
+    return this.prepared.execute(placeholderValues);
   }
   _prepare() {
-    return this;
+    return this.prepared;
   }
 };
 applyMixins2(PgAsyncRaw2, [QueryPromise2]);
@@ -22593,12 +23324,11 @@ applyMixins2(PgAsyncRefreshMaterializedView2, [QueryPromise2]);
 var PgAsyncSelectBase2 = class extends PgSelectBase2 {
   static [entityKind] = "PgAsyncSelectQueryBuilder";
   _prepare(name2, generateName = false) {
-    const { session, config, dialect, joinsNotNullableMap, cacheConfig, usedTables } = this;
-    const { fields } = config;
+    const { session, dialect, cacheConfig, usedTables } = this;
     return tracer.startActiveSpan("drizzle.prepareQuery", () => {
-      const query = this.config._tagged ? dialect._sqlToQuery(this.getSQL()) : dialect.sqlToQuery(this.getSQL());
-      const fieldsList = orderSelectedFields2(fields, undefined, this.dialect.codecs);
-      const mapper = this.dialect.mapperGenerators.rows(fieldsList, joinsNotNullableMap);
+      const query = this.config.tagged ? dialect._sqlToQuery(this.getSQL()) : dialect.sqlToQuery(this.getSQL());
+      const fieldsList = this.config.fieldsFlat;
+      const mapper = this.dialect.mapperGenerators.rows(fieldsList, this.joinsNotNullableMap);
       return session.prepareQuery(query, "arrays", name2 ?? generateName, mapper, {
         type: "select",
         tables: [...usedTables]
@@ -22626,16 +23356,8 @@ var PgUpdateBuilder2 = class {
     this.withList = withList;
     this.builder = builder;
   }
-  authToken;
-  setToken(token) {
-    this.authToken = token;
-    return this;
-  }
   set(values) {
-    const builder = new this.builder(this.table, mapUpdateSet2(this.table, values), this.session, this.dialect, this.withList);
-    if ("setToken" in builder)
-      builder.setToken(this.authToken);
-    return builder;
+    return new this.builder(this.table, mapUpdateSet2(this.table, values), this.session, this.dialect, this.withList);
   }
 };
 var PgUpdateBase2 = class {
@@ -22643,7 +23365,6 @@ var PgUpdateBase2 = class {
   config;
   tableName;
   joinsNotNullableMap;
-  cacheConfig;
   constructor(table, set, session, dialect, withList) {
     this.session = session;
     this.dialect = dialect;
@@ -22772,7 +23493,7 @@ var PgUpdateBase2 = class {
 var PgAsyncUpdateBase2 = class extends PgUpdateBase2 {
   static [entityKind] = "PgAsyncUpdate";
   _prepare(name2, generateName = false) {
-    const { session, config, dialect, joinsNotNullableMap, cacheConfig } = this;
+    const { session, config, dialect, joinsNotNullableMap } = this;
     const { returning: fields } = config;
     return tracer.startActiveSpan("drizzle.prepareQuery", () => {
       const query = dialect.sqlToQuery(this.getSQL());
@@ -22780,7 +23501,7 @@ var PgAsyncUpdateBase2 = class extends PgUpdateBase2 {
       return session.prepareQuery(query, fields ? "arrays" : "raw", name2 ?? generateName, mapper, {
         type: "update",
         tables: [...extractUsedTable(this.config.table)]
-      }, cacheConfig);
+      });
     });
   }
   prepare(name2) {
@@ -22920,8 +23641,7 @@ var PgAsyncDatabase2 = class {
   execute(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);
-    return new PgAsyncRaw2(() => prepared.execute(), sequel, builtQuery, (result) => prepared.mapResult(result, true));
+    return new PgAsyncRaw2(this.session.prepareQuery(builtQuery, "raw", false), sequel, builtQuery);
   }
   transaction(transaction, config) {
     return this.session.transaction(transaction, config);
@@ -22934,9 +23654,6 @@ var PgBasePreparedQuery2 = class {
   constructor(query) {
     this.query = query;
   }
-  mapResult(_, __) {
-    throw new Error("Method not implemented.");
-  }
   getQuery() {
     return this.query;
   }
@@ -26463,23 +27180,28 @@ var createInMemoryAgentRegistrationStore = () => {
 var ID_LENGTH7 = 255;
 var NAME_LENGTH = 255;
 var STATUS_LENGTH2 = 16;
+var portableJsonb = customType({
+  dataType: () => "jsonb",
+  fromDriver: (value) => typeof value === "string" ? JSON.parse(value) : value,
+  toDriver: (value) => JSON.stringify(value)
+});
 var agentDelegationsTable = pgTable("auth_agent_delegations", {
   agent_id: varchar("agent_id", { length: ID_LENGTH7 }).notNull(),
-  authorization_details: jsonb("authorization_details").$type(),
+  authorization_details: portableJsonb("authorization_details").$type(),
   created_at_ms: bigint("created_at_ms", { mode: "number" }).notNull(),
   delegation_id: varchar("delegation_id", {
     length: ID_LENGTH7
   }).primaryKey(),
   expires_at_ms: bigint("expires_at_ms", { mode: "number" }),
   organization_id: varchar("organization_id", { length: ID_LENGTH7 }),
-  scopes: jsonb("scopes").$type().notNull().default([]),
+  scopes: portableJsonb("scopes").$type().notNull().default([]),
   status: varchar("status", { length: STATUS_LENGTH2 }).$type().notNull(),
   updated_at_ms: bigint("updated_at_ms", { mode: "number" }).notNull(),
   user_id: varchar("user_id", { length: ID_LENGTH7 }).notNull()
 });
 var agentIdentityRegistrationsTable = pgTable("auth_agent_identity_registrations", {
   agent_id: varchar("agent_id", { length: ID_LENGTH7 }).notNull().unique(),
-  claim_attempt: jsonb("claim_attempt").$type(),
+  claim_attempt: portableJsonb("claim_attempt").$type(),
   claim_attempt_token_hash: varchar("claim_attempt_token_hash", {
     length: ID_LENGTH7
   }).unique(),
@@ -26511,10 +27233,10 @@ var agentIdentityRegistrationsTable = pgTable("auth_agent_identity_registrations
 ]);
 var agentRegistrationsTable = pgTable("auth_agent_registrations", {
   agent_id: varchar("agent_id", { length: ID_LENGTH7 }).primaryKey(),
-  allowed_scopes: jsonb("allowed_scopes").$type().notNull().default([]),
+  allowed_scopes: portableJsonb("allowed_scopes").$type().notNull().default([]),
   client_id: varchar("client_id", { length: ID_LENGTH7 }).unique(),
   created_at_ms: bigint("created_at_ms", { mode: "number" }).notNull(),
-  metadata: jsonb("metadata").$type(),
+  metadata: portableJsonb("metadata").$type(),
   name: varchar("name", { length: NAME_LENGTH }).notNull(),
   status: varchar("status", { length: STATUS_LENGTH2 }).$type().notNull(),
   updated_at_ms: bigint("updated_at_ms", { mode: "number" }).notNull()
@@ -26986,6 +27708,16 @@ var createInMemoryAuthorizationCodeStore = () => {
       codes.delete(codeHash);
       return record;
     },
+    deleteForClient: async (clientId) => {
+      let deleted = 0;
+      for (const [hash, code] of codes) {
+        if (code.clientId !== clientId)
+          continue;
+        codes.delete(hash);
+        deleted += 1;
+      }
+      return deleted;
+    },
     deleteForUserClient: async (userId, clientId) => {
       let deleted = 0;
       for (const [hash, code] of codes) {
@@ -27051,6 +27783,16 @@ var createInMemoryClientRegistrationTokenStore = () => {
           byHash.delete(hash);
       }
     },
+    deleteForClient: async (clientId) => {
+      let deleted = 0;
+      for (const [hash, token] of byHash) {
+        if (token.clientId !== clientId)
+          continue;
+        byHash.delete(hash);
+        deleted += 1;
+      }
+      return deleted;
+    },
     findByTokenHash: async (tokenHash) => byHash.get(tokenHash),
     saveToken: async (token) => {
       for (const [hash, existing] of byHash) {
@@ -27067,6 +27809,16 @@ var createInMemoryDeviceAuthorizationStore = () => {
     deleteByDeviceCodeHash: async (deviceCodeHash) => {
       byDeviceCode.delete(deviceCodeHash);
     },
+    deleteForClient: async (clientId) => {
+      let deleted = 0;
+      for (const [hash, authorization] of byDeviceCode) {
+        if (authorization.clientId !== clientId)
+          continue;
+        byDeviceCode.delete(hash);
+        deleted += 1;
+      }
+      return deleted;
+    },
     deleteForUserClient: async (userId, clientId) => {
       let deleted = 0;
       for (const [hash, authorization] of byDeviceCode) {
@@ -27148,6 +27900,16 @@ var createInMemoryOidcRefreshTokenStore = () => {
       tokens.delete(tokenHash);
       return record;
     },
+    deleteForClient: async (clientId) => {
+      let deleted = 0;
+      for (const [hash, token] of tokens) {
+        if (token.clientId !== clientId)
+          continue;
+        tokens.delete(hash);
+        deleted += 1;
+      }
+      return deleted;
+    },
     deleteForUser: async (userId) => {
       for (const [hash, token] of tokens) {
         if (token.userId === userId)
@@ -27442,6 +28204,10 @@ var createPostgresAuthorizationCodeStore = (db) => ({
     const [row] = await db.delete(oauthCodesTable).where(eq(oauthCodesTable.code_hash, codeHash)).returning();
     return row ? toCode(row) : undefined;
   },
+  deleteForClient: async (clientId) => {
+    const deleted = await db.delete(oauthCodesTable).where(eq(oauthCodesTable.client_id, clientId)).returning({ codeHash: oauthCodesTable.code_hash });
+    return deleted.length;
+  },
   deleteForUserClient: async (userId, clientId) => {
     const deleted = await db.delete(oauthCodesTable).where(and(eq(oauthCodesTable.user_id, userId), eq(oauthCodesTable.client_id, clientId))).returning({ codeHash: oauthCodesTable.code_hash });
     return deleted.length;
@@ -27471,6 +28237,12 @@ var createPostgresClientRegistrationTokenStore = (db) => ({
   deleteByClientId: async (clientId) => {
     await db.delete(oauthClientRegistrationTokensTable).where(eq(oauthClientRegistrationTokensTable.client_id, clientId));
   },
+  deleteForClient: async (clientId) => {
+    const deleted = await db.delete(oauthClientRegistrationTokensTable).where(eq(oauthClientRegistrationTokensTable.client_id, clientId)).returning({
+      tokenHash: oauthClientRegistrationTokensTable.token_hash
+    });
+    return deleted.length;
+  },
   findByTokenHash: async (tokenHash) => {
     const [row] = await db.select().from(oauthClientRegistrationTokensTable).where(eq(oauthClientRegistrationTokensTable.token_hash, tokenHash)).limit(1);
     if (!row)
@@ -27495,6 +28267,12 @@ var createPostgresDeviceAuthorizationStore = (db) => ({
   deleteByDeviceCodeHash: async (deviceCodeHash) => {
     await db.delete(oauthDeviceAuthorizationsTable).where(eq(oauthDeviceAuthorizationsTable.device_code_hash, deviceCodeHash));
   },
+  deleteForClient: async (clientId) => {
+    const deleted = await db.delete(oauthDeviceAuthorizationsTable).where(eq(oauthDeviceAuthorizationsTable.client_id, clientId)).returning({
+      deviceCodeHash: oauthDeviceAuthorizationsTable.device_code_hash
+    });
+    return deleted.length;
+  },
   deleteForUserClient: async (userId, clientId) => {
     const deleted = await db.delete(oauthDeviceAuthorizationsTable).where(and(eq(oauthDeviceAuthorizationsTable.user_sub, userId), eq(oauthDeviceAuthorizationsTable.client_id, clientId))).returning({
       deviceCodeHash: oauthDeviceAuthorizationsTable.device_code_hash
@@ -27589,6 +28367,10 @@ var createPostgresOidcRefreshTokenStore = (db) => ({
     const [row] = await db.delete(oauthRefreshTokensTable).where(eq(oauthRefreshTokensTable.token_hash, tokenHash)).returning();
     return row ? toRefresh(row) : undefined;
   },
+  deleteForClient: async (clientId) => {
+    const deleted = await db.delete(oauthRefreshTokensTable).where(eq(oauthRefreshTokensTable.client_id, clientId)).returning({ tokenHash: oauthRefreshTokensTable.token_hash });
+    return deleted.length;
+  },
   deleteForUser: async (userId) => {
     await db.delete(oauthRefreshTokensTable).where(eq(oauthRefreshTokensTable.user_id, userId));
   },
@@ -29804,5 +30586,5 @@ export {
   auth2 as auth
 };
 
-//# debugId=059E7E401823BC2864756E2164756E21
+//# debugId=286B6E54F8CE0D4D64756E2164756E21
 //# sourceMappingURL=server.js.map