@absolutejs/auth 0.76.0 → 0.76.1

package/dist/server.js

@@ -19,12 +19,14 @@ var __toESM = (mod, isNodeMode, target) => {
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -58,20 +60,20 @@ var init_constants = __esm(() => {
 // src/crypto.ts
 var exports_crypto = {};
 __export(exports_crypto, {
-  verifyTotp: () => verifyTotp,
-  verifyPassword: () => verifyPassword,
-  hashToken: () => hashToken,
-  hashPassword: () => hashPassword,
-  generateTotpSecret: () => generateTotpSecret,
-  generateTotp: () => generateTotp,
-  generateSecureToken: () => generateSecureToken,
-  generateEncryptionKey: () => generateEncryptionKey,
-  encryptSecret: () => encryptSecret,
-  decryptSecret: () => decryptSecret,
-  createTotpKeyUri: () => createTotpKeyUri,
-  constantTimeEqual: () => constantTimeEqual,
+  base32Decode: () => base32Decode,
   base32Encode: () => base32Encode,
-  base32Decode: () => base32Decode
+  constantTimeEqual: () => constantTimeEqual,
+  createTotpKeyUri: () => createTotpKeyUri,
+  decryptSecret: () => decryptSecret,
+  encryptSecret: () => encryptSecret,
+  generateEncryptionKey: () => generateEncryptionKey,
+  generateSecureToken: () => generateSecureToken,
+  generateTotp: () => generateTotp,
+  generateTotpSecret: () => generateTotpSecret,
+  hashPassword: () => hashPassword,
+  hashToken: () => hashToken,
+  verifyPassword: () => verifyPassword,
+  verifyTotp: () => verifyTotp
 });
 var DEFAULT_TOKEN_BYTES = 32, AES_KEY_BYTES = 32, AES_IV_BYTES = 12, HOTP_COUNTER_BYTES = 8, TOTP_SECRET_BYTES = 20, TOTP_DIGITS = 6, TOTP_PERIOD_SECONDS = 30, DEFAULT_TOTP_WINDOW = 1, DECIMAL_RADIX = 10, LAST_NIBBLE_MASK = 15, SIGN_BIT_MASK = 2147483647, BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", BASE32_GROUP_BITS = 5, BASE32_MASK = 31, BYTE_BITS = 8, textEncoder, textDecoder, base64UrlEncode = (bytes) => Buffer.from(bytes).toString("base64url"), base64UrlDecode = (encoded) => new Uint8Array(Buffer.from(encoded, "base64url")), sha256 = async (input) => {
   const digest = await crypto.subtle.digest("SHA-256", textEncoder.encode(input));
@@ -182,7 +184,7 @@ var init_crypto = __esm(() => {
 });
 
 // node_modules/reflect-metadata/Reflect.js
-var require_Reflect = __commonJS(() => {
+var require_Reflect = __commonJS(function() {
   /*! *****************************************************************************
   Copyright (C) Microsoft. All rights reserved.
   Licensed under the Apache License, Version 2.0 (the "License"); you may not use
@@ -14984,6 +14986,9 @@ var tracer = { startActiveSpan(name, fn) {
 var ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
 
 // node_modules/drizzle-orm/sql/sql.js
+var FakePrimitiveParam = class {
+  static [entityKind] = "FakePrimitiveParam";
+};
 function isSQLWrapper(value) {
   return value !== null && value !== undefined && typeof value.getSQL === "function";
 }
@@ -18661,6 +18666,16 @@ var UniqueConstraintBuilder = class {
     return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);
   }
 };
+var UniqueOnConstraintBuilder = class {
+  static [entityKind] = "PgUniqueOnConstraintBuilder";
+  name;
+  constructor(name2) {
+    this.name = name2;
+  }
+  on(...columns) {
+    return new UniqueConstraintBuilder(columns, this.name);
+  }
+};
 var UniqueConstraint = class {
   static [entityKind] = "PgUniqueConstraint";
   columns;
@@ -23936,6 +23951,17 @@ var ColumnAliasProxyHandler2 = class {
     return target[prop];
   }
 };
+var RelationTableAliasProxyHandler2 = class {
+  static [entityKind] = "RelationTableAliasProxyHandler";
+  constructor(alias2) {
+    this.alias = alias2;
+  }
+  get(target, prop) {
+    if (prop === "sourceTable")
+      return aliasedTable2(target.sourceTable, this.alias);
+    return target[prop];
+  }
+};
 function aliasedTable2(table, tableAlias) {
   return new Proxy(table, new TableAliasProxyHandler2(tableAlias, false, false));
 }
@@ -24419,6 +24445,13 @@ params: ${params}`);
       this.cause = cause;
   }
 };
+var TransactionRollbackError2 = class extends DrizzleError2 {
+  static [entityKind] = "TransactionRollbackError";
+  constructor() {
+    super({ message: "Rollback" });
+    this.name = "TransactionRollbackError";
+  }
+};
 // node_modules/drizzle-orm/relations.js
 var Relation2 = class {
   static [entityKind] = "RelationV2";
@@ -24467,6 +24500,53 @@ var One2 = class extends Relation2 {
     this.optional = config?.optional ?? true;
   }
 };
+var Many2 = class extends Relation2 {
+  static [entityKind] = "ManyV2";
+  relationType = "many";
+  constructor(tables, targetTable, targetTableName, config) {
+    super(targetTable, targetTableName);
+    this.config = config;
+    this.alias = config?.alias;
+    this.where = config?.where;
+    if (config?.from)
+      this.sourceColumns = (Array.isArray(config.from) ? config.from : [config.from]).map((it2) => {
+        this.throughTable ??= it2._.through ? tables[it2._.through._.tableName] : undefined;
+        this.sourceColumnTableNames.push(it2._.tableName);
+        return it2._.column;
+      });
+    if (config?.to)
+      this.targetColumns = (Array.isArray(config.to) ? config.to : [config.to]).map((it2) => {
+        this.throughTable ??= it2._.through ? tables[it2._.through._.tableName] : undefined;
+        this.targetColumnTableNames.push(it2._.tableName);
+        return it2._.column;
+      });
+    if (this.throughTable)
+      this.through = {
+        source: (Array.isArray(config?.from) ? config.from : (config?.from) ? [config.from] : []).map((c) => c._.through),
+        target: (Array.isArray(config?.to) ? config.to : (config?.to) ? [config.to] : []).map((c) => c._.through)
+      };
+  }
+};
+var AggregatedField2 = class {
+  static [entityKind] = "AggregatedField";
+  table;
+  onTable(table) {
+    this.table = table;
+    return this;
+  }
+};
+var Count2 = class extends AggregatedField2 {
+  static [entityKind] = "AggregatedFieldCount";
+  query;
+  getSQL() {
+    if (!this.query) {
+      if (!this.table)
+        throw new Error("Table must be set before building aggregate field");
+      this.query = sql`select count(*) as ${sql.identifier("r")} from ${getTableAsAliasSQL2(this.table)}`.mapWith(Number);
+    }
+    return this.query;
+  }
+};
 var operators2 = {
   and,
   between,
@@ -24787,6 +24867,66 @@ function makeJitRqbMapper2({ selection, isFirst, parseJson, parseJsonIfString, r
 ${compiled}
 }` });
 }
+var RelationsBuilderTable2 = class {
+  static [entityKind] = "RelationsBuilderTable";
+  _;
+  constructor(table, name2) {
+    this._ = {
+      name: name2,
+      table
+    };
+  }
+};
+var RelationsBuilderColumn2 = class {
+  static [entityKind] = "RelationsBuilderColumn";
+  _;
+  constructor(column, tableName, key) {
+    this._ = {
+      tableName,
+      column,
+      key
+    };
+  }
+  through(column) {
+    return new RelationsBuilderJunctionColumn2(this._.column, this._.tableName, this._.key, column);
+  }
+};
+var RelationsBuilderJunctionColumn2 = class {
+  static [entityKind] = "RelationsBuilderColumn";
+  _;
+  constructor(column, tableName, key, through) {
+    this._ = {
+      tableName,
+      column,
+      through,
+      key
+    };
+  }
+};
+var RelationsHelperStatic2 = class {
+  static [entityKind] = "RelationsHelperStatic";
+  _;
+  constructor(tables) {
+    this._ = { tables };
+    const one = {};
+    const many = {};
+    for (const [tableName, table] of Object.entries(tables)) {
+      one[tableName] = (config) => {
+        return new One2(tables, table, tableName, config);
+      };
+      many[tableName] = (config) => {
+        return new Many2(tables, table, tableName, config);
+      };
+    }
+    this.one = one;
+    this.many = many;
+  }
+  one;
+  many;
+  aggs = { count() {
+    return new Count2;
+  } };
+};
 function fieldSelectionToSQL2(table, target) {
   const field = table[TableColumns][target];
   return field ? is(field, Column) ? field : is(field, SQL.Aliased) ? sql`${table}.${sql.identifier(field.fieldAlias)}` : sql`${table}.${sql.identifier(target)}` : sql`${table}.${sql.identifier(target)}`;
@@ -26245,6 +26385,29 @@ var PgAsyncSession2 = class extends PgSession2 {
     });
   }
 };
+var PgAsyncTransaction2 = class extends PgAsyncDatabase2 {
+  static [entityKind] = "PgAsyncTransaction";
+  constructor(dialect, session, relations, nestedIndex = 0, parseRqbJson) {
+    super(dialect, session, relations, parseRqbJson);
+    this.nestedIndex = nestedIndex;
+  }
+  rollback() {
+    throw new TransactionRollbackError2;
+  }
+  getTransactionConfigSQL(config) {
+    const chunks = [];
+    if (config.isolationLevel)
+      chunks.push(`isolation level ${config.isolationLevel}`);
+    if (config.accessMode)
+      chunks.push(config.accessMode);
+    if (typeof config.deferrable === "boolean")
+      chunks.push(config.deferrable ? "deferrable" : "not deferrable");
+    return sql.raw(chunks.join(" "));
+  }
+  setTransaction(config) {
+    return this.session.execute(sql`set transaction ${this.getTransactionConfigSQL(config)}`);
+  }
+};
 
 // node_modules/drizzle-orm/neon-http/session.js
 var NeonHttpSession = class extends PgAsyncSession2 {
@@ -26704,12 +26867,12 @@ var providersFromEnv = (selection, env = process.env) => {
 // node_modules/typebox/build/system/memory/memory.mjs
 var exports_memory = {};
 __export(exports_memory, {
-  Update: () => Update,
-  Metrics: () => Metrics,
-  Discard: () => Discard,
-  Create: () => Create,
+  Assign: () => Assign,
   Clone: () => Clone,
-  Assign: () => Assign
+  Create: () => Create,
+  Discard: () => Discard,
+  Metrics: () => Metrics,
+  Update: () => Update
 });
 
 // node_modules/typebox/build/system/memory/metrics.mjs
@@ -26729,44 +26892,44 @@ function Assign(left, right) {
 // node_modules/typebox/build/guard/guard.mjs
 var exports_guard = {};
 __export(exports_guard, {
-  Values: () => Values,
-  Symbols: () => Symbols,
-  SomeAll: () => SomeAll,
-  Some: () => Some,
-  ShiftLeft: () => ShiftLeft,
-  Keys: () => Keys,
-  IsValueLike: () => IsValueLike,
-  IsUnsafePropertyKey: () => IsUnsafePropertyKey,
-  IsUndefined: () => IsUndefined,
-  IsSymbol: () => IsSymbol,
-  IsString: () => IsString,
-  IsObjectNotArray: () => IsObjectNotArray,
-  IsObject: () => IsObject,
-  IsNumber: () => IsNumber,
-  IsNull: () => IsNull,
-  IsMultipleOf: () => IsMultipleOf,
-  IsMinLength: () => IsMinLength2,
-  IsMaxLength: () => IsMaxLength2,
-  IsLessThan: () => IsLessThan,
-  IsLessEqualThan: () => IsLessEqualThan,
-  IsInteger: () => IsInteger,
-  IsGreaterThan: () => IsGreaterThan,
-  IsGreaterEqualThan: () => IsGreaterEqualThan,
-  IsFunction: () => IsFunction,
-  IsEqual: () => IsEqual,
-  IsDeepEqual: () => IsDeepEqual,
-  IsConstructor: () => IsConstructor,
-  IsClassInstance: () => IsClassInstance,
-  IsBoolean: () => IsBoolean,
-  IsBigInt: () => IsBigInt,
-  IsArray: () => IsArray,
-  HasPropertyKey: () => HasPropertyKey,
-  GraphemeCount: () => GraphemeCount2,
-  EveryAll: () => EveryAll,
-  Every: () => Every,
-  EntriesRegExp: () => EntriesRegExp,
+  Counted: () => Counted,
   Entries: () => Entries,
-  Counted: () => Counted
+  EntriesRegExp: () => EntriesRegExp,
+  Every: () => Every,
+  EveryAll: () => EveryAll,
+  GraphemeCount: () => GraphemeCount2,
+  HasPropertyKey: () => HasPropertyKey,
+  IsArray: () => IsArray,
+  IsBigInt: () => IsBigInt,
+  IsBoolean: () => IsBoolean,
+  IsClassInstance: () => IsClassInstance,
+  IsConstructor: () => IsConstructor,
+  IsDeepEqual: () => IsDeepEqual,
+  IsEqual: () => IsEqual,
+  IsFunction: () => IsFunction,
+  IsGreaterEqualThan: () => IsGreaterEqualThan,
+  IsGreaterThan: () => IsGreaterThan,
+  IsInteger: () => IsInteger,
+  IsLessEqualThan: () => IsLessEqualThan,
+  IsLessThan: () => IsLessThan,
+  IsMaxLength: () => IsMaxLength2,
+  IsMinLength: () => IsMinLength2,
+  IsMultipleOf: () => IsMultipleOf,
+  IsNull: () => IsNull,
+  IsNumber: () => IsNumber,
+  IsObject: () => IsObject,
+  IsObjectNotArray: () => IsObjectNotArray,
+  IsString: () => IsString,
+  IsSymbol: () => IsSymbol,
+  IsUndefined: () => IsUndefined,
+  IsUnsafePropertyKey: () => IsUnsafePropertyKey,
+  IsValueLike: () => IsValueLike,
+  Keys: () => Keys,
+  ShiftLeft: () => ShiftLeft,
+  Some: () => Some,
+  SomeAll: () => SomeAll,
+  Symbols: () => Symbols,
+  Values: () => Values
 });
 
 // node_modules/typebox/build/guard/string.mjs
@@ -27045,25 +27208,25 @@ function IsDeepEqual(left, right) {
 // node_modules/typebox/build/guard/globals.mjs
 var exports_globals = {};
 __export(exports_globals, {
-  IsUint8ClampedArray: () => IsUint8ClampedArray,
-  IsUint8Array: () => IsUint8Array,
-  IsUint32Array: () => IsUint32Array,
-  IsUint16Array: () => IsUint16Array,
-  IsTypeArray: () => IsTypeArray,
-  IsString: () => IsString2,
-  IsSet: () => IsSet,
-  IsRegExp: () => IsRegExp,
-  IsNumber: () => IsNumber2,
-  IsMap: () => IsMap,
-  IsInt8Array: () => IsInt8Array,
-  IsInt32Array: () => IsInt32Array,
-  IsInt16Array: () => IsInt16Array,
-  IsFloat64Array: () => IsFloat64Array,
-  IsFloat32Array: () => IsFloat32Array,
-  IsDate: () => IsDate,
-  IsBoolean: () => IsBoolean2,
+  IsBigInt64Array: () => IsBigInt64Array,
   IsBigUint64Array: () => IsBigUint64Array,
-  IsBigInt64Array: () => IsBigInt64Array
+  IsBoolean: () => IsBoolean2,
+  IsDate: () => IsDate,
+  IsFloat32Array: () => IsFloat32Array,
+  IsFloat64Array: () => IsFloat64Array,
+  IsInt16Array: () => IsInt16Array,
+  IsInt32Array: () => IsInt32Array,
+  IsInt8Array: () => IsInt8Array,
+  IsMap: () => IsMap,
+  IsNumber: () => IsNumber2,
+  IsRegExp: () => IsRegExp,
+  IsSet: () => IsSet,
+  IsString: () => IsString2,
+  IsTypeArray: () => IsTypeArray,
+  IsUint16Array: () => IsUint16Array,
+  IsUint32Array: () => IsUint32Array,
+  IsUint8Array: () => IsUint8Array,
+  IsUint8ClampedArray: () => IsUint8ClampedArray
 });
 function IsBoolean2(value) {
   return value instanceof Boolean;
@@ -27187,9 +27350,9 @@ function Clone(value) {
 // node_modules/typebox/build/system/settings/settings.mjs
 var exports_settings = {};
 __export(exports_settings, {
-  Set: () => Set2,
+  Get: () => Get,
   Reset: () => Reset,
-  Get: () => Get
+  Set: () => Set2
 });
 var settings = {
   immutableTypes: false,
@@ -27522,8 +27685,8 @@ function IntersectOptions(type) {
 // node_modules/typebox/build/system/hashing/hash.mjs
 var exports_hash = {};
 __export(exports_hash, {
-  HashCode: () => HashCode,
-  Hash: () => Hash
+  Hash: () => Hash,
+  HashCode: () => HashCode
 });
 
 // node_modules/typebox/build/system/unreachable/unreachable.mjs
@@ -28867,8 +29030,8 @@ function Optional2(value, input) {
 function IsDiscard(discard2, input) {
   return discard2.includes(input);
 }
-function Many2(allowed, discard2, input, result = "") {
-  return Match2(Take(allowed, input), (Char, Rest2) => IsDiscard(discard2, Char) ? Many2(allowed, discard2, Rest2, result) : Many2(allowed, discard2, Rest2, `${result}${Char}`), () => [result, input]);
+function Many3(allowed, discard2, input, result = "") {
+  return Match2(Take(allowed, input), (Char, Rest2) => IsDiscard(discard2, Char) ? Many3(allowed, discard2, Rest2, result) : Many3(allowed, discard2, Rest2, `${result}${Char}`), () => [result, input]);
 }
 
 // node_modules/typebox/build/type/script/token/unsigned_integer.mjs
@@ -28877,7 +29040,7 @@ function TakeNonZero(input) {
 }
 var AllowedDigits = [...Digit, UnderScore];
 function TakeDigits(input) {
-  return Many2(AllowedDigits, [UnderScore], input);
+  return Many3(AllowedDigits, [UnderScore], input);
 }
 function TakeUnsignedInteger(input) {
   return Match2(Take([Zero], input), (Zero2, ZeroRest) => [Zero2, ZeroRest], () => Match2(TakeNonZero(input), (NonZero2, NonZeroRest) => Match2(TakeDigits(NonZeroRest), (Digits, DigitsRest) => [`${NonZero2}${Digits}`, DigitsRest], () => []), () => []));
@@ -28932,7 +29095,7 @@ function IsLeadingDot(input) {
   return IsMatch(Take([Dot], input));
 }
 function TakeFractional(input) {
-  return Match2(Many2(AllowedDigits2, [UnderScore], input), (Digits, DigitsRest) => IsEqual(Digits, "") ? [] : [Digits, DigitsRest], () => []);
+  return Match2(Many3(AllowedDigits2, [UnderScore], input), (Digits, DigitsRest) => IsEqual(Digits, "") ? [] : [Digits, DigitsRest], () => []);
 }
 function LeadingDot(input) {
   return Match2(Take([Dot], input), (Dot2, DotRest) => Match2(TakeFractional(DotRest), (Fractional, FractionalRest) => [`0${Dot2}${Fractional}`, FractionalRest], () => []), () => []);
@@ -29230,14 +29393,14 @@ function IsTemplateLiteral(value) {
 // node_modules/typebox/build/type/extends/result.mjs
 var exports_result = {};
 __export(exports_result, {
-  Match: () => Match3,
-  IsExtendsUnion: () => IsExtendsUnion,
-  IsExtendsTrueLike: () => IsExtendsTrueLike,
-  IsExtendsTrue: () => IsExtendsTrue,
-  IsExtendsFalse: () => IsExtendsFalse,
-  ExtendsUnion: () => ExtendsUnion,
+  ExtendsFalse: () => ExtendsFalse,
   ExtendsTrue: () => ExtendsTrue,
-  ExtendsFalse: () => ExtendsFalse
+  ExtendsUnion: () => ExtendsUnion,
+  IsExtendsFalse: () => IsExtendsFalse,
+  IsExtendsTrue: () => IsExtendsTrue,
+  IsExtendsTrueLike: () => IsExtendsTrueLike,
+  IsExtendsUnion: () => IsExtendsUnion,
+  Match: () => Match3
 });
 function ExtendsUnion(inferred) {
   return exports_memory.Create({ ["~kind"]: "ExtendsUnion" }, { inferred });
@@ -31048,123 +31211,123 @@ function Script2(...args) {
 // node_modules/typebox/build/typebox.mjs
 var exports_typebox = {};
 __export(exports_typebox, {
-  With: () => With2,
-  Void: () => Void,
-  Uppercase: () => Uppercase,
-  Unsafe: () => Unsafe,
-  Unknown: () => Unknown,
-  Union: () => Union,
-  Undefined: () => Undefined,
-  Uncapitalize: () => Uncapitalize,
-  Tuple: () => Tuple,
-  This: () => This,
-  TemplateLiteral: () => TemplateLiteral2,
-  Symbol: () => Symbol2,
-  String: () => String2,
-  Script: () => Script2,
-  ReturnType: () => ReturnType,
-  Rest: () => Rest,
-  Required: () => Required,
-  Refine: () => Refine,
-  Ref: () => Ref,
-  RecordValue: () => RecordValue,
-  RecordPattern: () => RecordPattern,
-  RecordKey: () => RecordKey,
-  Record: () => Record,
-  ReadonlyType: () => ReadonlyType,
-  ReadonlyObject: () => ReadonlyObject,
-  Readonly: () => Readonly,
-  Pick: () => Pick,
-  Partial: () => Partial,
-  Parameters: () => Parameters,
-  Parameter: () => Parameter,
-  Optional: () => Optional,
-  Omit: () => Omit,
-  Object: () => _Object_,
-  Number: () => Number2,
-  Null: () => Null,
-  NonNullable: () => NonNullable,
-  Never: () => Never,
-  Module: () => Module2,
-  Mapped: () => Mapped,
-  Lowercase: () => Lowercase,
-  Literal: () => Literal,
-  KeyOf: () => KeyOf2,
-  IsVoid: () => IsVoid,
-  IsUnsafe: () => IsUnsafe,
-  IsUnknown: () => IsUnknown,
-  IsUnion: () => IsUnion,
-  IsUndefined: () => IsUndefined2,
-  IsTuple: () => IsTuple,
-  IsThis: () => IsThis,
-  IsTemplateLiteral: () => IsTemplateLiteral,
-  IsSymbol: () => IsSymbol2,
-  IsString: () => IsString3,
-  IsSchema: () => IsSchema,
-  IsRest: () => IsRest,
-  IsRefine: () => IsRefine,
-  IsRef: () => IsRef,
-  IsRecord: () => IsRecord,
-  IsReadonly: () => IsReadonly,
-  IsParameter: () => IsParameter,
-  IsOptional: () => IsOptional,
-  IsObject: () => IsObject2,
-  IsNumber: () => IsNumber3,
-  IsNull: () => IsNull2,
-  IsNever: () => IsNever,
-  IsLiteral: () => IsLiteral,
-  IsKind: () => IsKind,
-  IsIntersect: () => IsIntersect,
-  IsInteger: () => IsInteger2,
-  IsInfer: () => IsInfer,
-  IsImmutable: () => IsImmutable,
-  IsIdentifier: () => IsIdentifier,
-  IsGeneric: () => IsGeneric,
-  IsFunction: () => IsFunction2,
-  IsEnumValue: () => IsEnumValue,
-  IsEnum: () => IsEnum,
-  IsDependent: () => IsDependent,
-  IsCyclic: () => IsCyclic,
-  IsConstructor: () => IsConstructor2,
-  IsCodec: () => IsCodec,
-  IsCall: () => IsCall,
-  IsBoolean: () => IsBoolean3,
-  IsBigInt: () => IsBigInt2,
-  IsArray: () => IsArray2,
-  IsAny: () => IsAny,
-  Intersect: () => Intersect,
-  Interface: () => Interface,
-  Integer: () => Integer,
-  Instantiate: () => Instantiate,
-  InstanceType: () => InstanceType,
-  Infer: () => Infer,
-  Index: () => Index2,
-  Immutable: () => Immutable,
-  Identifier: () => Identifier,
-  Generic: () => Generic,
-  Function: () => _Function_,
-  Extract: () => Extract,
-  ExtendsResult: () => exports_result,
-  Extends: () => Extends,
-  Exclude: () => Exclude,
-  Evaluate: () => Evaluate,
-  Enum: () => Enum,
-  EncodeBuilder: () => EncodeBuilder,
-  Encode: () => Encode,
-  Dependent: () => Dependent,
-  DecodeBuilder: () => DecodeBuilder,
-  Decode: () => Decode,
-  Cyclic: () => Cyclic,
-  ConstructorParameters: () => ConstructorParameters,
-  Constructor: () => Constructor,
-  Conditional: () => Conditional,
-  Codec: () => Codec,
-  Capitalize: () => Capitalize,
-  Call: () => Call,
-  Boolean: () => Boolean2,
-  BigInt: () => BigInt2,
+  Any: () => Any,
   Array: () => _Array_,
-  Any: () => Any
+  BigInt: () => BigInt2,
+  Boolean: () => Boolean2,
+  Call: () => Call,
+  Capitalize: () => Capitalize,
+  Codec: () => Codec,
+  Conditional: () => Conditional,
+  Constructor: () => Constructor,
+  ConstructorParameters: () => ConstructorParameters,
+  Cyclic: () => Cyclic,
+  Decode: () => Decode,
+  DecodeBuilder: () => DecodeBuilder,
+  Dependent: () => Dependent,
+  Encode: () => Encode,
+  EncodeBuilder: () => EncodeBuilder,
+  Enum: () => Enum,
+  Evaluate: () => Evaluate,
+  Exclude: () => Exclude,
+  Extends: () => Extends,
+  ExtendsResult: () => exports_result,
+  Extract: () => Extract,
+  Function: () => _Function_,
+  Generic: () => Generic,
+  Identifier: () => Identifier,
+  Immutable: () => Immutable,
+  Index: () => Index2,
+  Infer: () => Infer,
+  InstanceType: () => InstanceType,
+  Instantiate: () => Instantiate,
+  Integer: () => Integer,
+  Interface: () => Interface,
+  Intersect: () => Intersect,
+  IsAny: () => IsAny,
+  IsArray: () => IsArray2,
+  IsBigInt: () => IsBigInt2,
+  IsBoolean: () => IsBoolean3,
+  IsCall: () => IsCall,
+  IsCodec: () => IsCodec,
+  IsConstructor: () => IsConstructor2,
+  IsCyclic: () => IsCyclic,
+  IsDependent: () => IsDependent,
+  IsEnum: () => IsEnum,
+  IsEnumValue: () => IsEnumValue,
+  IsFunction: () => IsFunction2,
+  IsGeneric: () => IsGeneric,
+  IsIdentifier: () => IsIdentifier,
+  IsImmutable: () => IsImmutable,
+  IsInfer: () => IsInfer,
+  IsInteger: () => IsInteger2,
+  IsIntersect: () => IsIntersect,
+  IsKind: () => IsKind,
+  IsLiteral: () => IsLiteral,
+  IsNever: () => IsNever,
+  IsNull: () => IsNull2,
+  IsNumber: () => IsNumber3,
+  IsObject: () => IsObject2,
+  IsOptional: () => IsOptional,
+  IsParameter: () => IsParameter,
+  IsReadonly: () => IsReadonly,
+  IsRecord: () => IsRecord,
+  IsRef: () => IsRef,
+  IsRefine: () => IsRefine,
+  IsRest: () => IsRest,
+  IsSchema: () => IsSchema,
+  IsString: () => IsString3,
+  IsSymbol: () => IsSymbol2,
+  IsTemplateLiteral: () => IsTemplateLiteral,
+  IsThis: () => IsThis,
+  IsTuple: () => IsTuple,
+  IsUndefined: () => IsUndefined2,
+  IsUnion: () => IsUnion,
+  IsUnknown: () => IsUnknown,
+  IsUnsafe: () => IsUnsafe,
+  IsVoid: () => IsVoid,
+  KeyOf: () => KeyOf2,
+  Literal: () => Literal,
+  Lowercase: () => Lowercase,
+  Mapped: () => Mapped,
+  Module: () => Module2,
+  Never: () => Never,
+  NonNullable: () => NonNullable,
+  Null: () => Null,
+  Number: () => Number2,
+  Object: () => _Object_,
+  Omit: () => Omit,
+  Optional: () => Optional,
+  Parameter: () => Parameter,
+  Parameters: () => Parameters,
+  Partial: () => Partial,
+  Pick: () => Pick,
+  Readonly: () => Readonly,
+  ReadonlyObject: () => ReadonlyObject,
+  ReadonlyType: () => ReadonlyType,
+  Record: () => Record,
+  RecordKey: () => RecordKey,
+  RecordPattern: () => RecordPattern,
+  RecordValue: () => RecordValue,
+  Ref: () => Ref,
+  Refine: () => Refine,
+  Required: () => Required,
+  Rest: () => Rest,
+  ReturnType: () => ReturnType,
+  Script: () => Script2,
+  String: () => String2,
+  Symbol: () => Symbol2,
+  TemplateLiteral: () => TemplateLiteral2,
+  This: () => This,
+  Tuple: () => Tuple,
+  Uncapitalize: () => Uncapitalize,
+  Undefined: () => Undefined,
+  Union: () => Union,
+  Unknown: () => Unknown,
+  Unsafe: () => Unsafe,
+  Uppercase: () => Uppercase,
+  Void: () => Void,
+  With: () => With2
 });
 // node_modules/typebox/build/schema/types/_refine.mjs
 function IsRefine2(value) {
@@ -31741,34 +31904,34 @@ function ErrorExclusiveMinimum(stack, context, schemaPath, instancePath, schema3
 // node_modules/typebox/build/format/format.mjs
 var exports_format = {};
 __export(exports_format, {
-  Test: () => Test,
-  Set: () => Set3,
-  Reset: () => Reset2,
-  IsUuid: () => IsUuid,
-  IsUrl: () => IsUrl,
-  IsUriTemplate: () => IsUriTemplate,
-  IsUriReference: () => IsUriReference,
-  IsUri: () => IsUri,
-  IsTime: () => IsTime,
-  IsRelativeJsonPointer: () => IsRelativeJsonPointer,
-  IsRegex: () => IsRegex,
-  IsJsonPointerUriFragment: () => IsJsonPointerUriFragment,
-  IsJsonPointer: () => IsJsonPointer,
-  IsIriReference: () => IsIriReference,
-  IsIri: () => IsIri,
-  IsIdnHostname: () => IsIdnHostname2,
-  IsIdnEmail: () => IsIdnEmail,
-  IsIPv6: () => IsIPv6,
-  IsIPv4: () => IsIPv4,
-  IsHostname: () => IsHostname2,
-  IsEmail: () => IsEmail,
-  IsDuration: () => IsDuration,
-  IsDateTime: () => IsDateTime,
-  IsDate: () => IsDate2,
-  Has: () => Has,
-  Get: () => Get3,
+  Clear: () => Clear,
   Entries: () => Entries2,
-  Clear: () => Clear
+  Get: () => Get3,
+  Has: () => Has,
+  IsDate: () => IsDate2,
+  IsDateTime: () => IsDateTime,
+  IsDuration: () => IsDuration,
+  IsEmail: () => IsEmail,
+  IsHostname: () => IsHostname2,
+  IsIPv4: () => IsIPv4,
+  IsIPv6: () => IsIPv6,
+  IsIdnEmail: () => IsIdnEmail,
+  IsIdnHostname: () => IsIdnHostname2,
+  IsIri: () => IsIri,
+  IsIriReference: () => IsIriReference,
+  IsJsonPointer: () => IsJsonPointer,
+  IsJsonPointerUriFragment: () => IsJsonPointerUriFragment,
+  IsRegex: () => IsRegex,
+  IsRelativeJsonPointer: () => IsRelativeJsonPointer,
+  IsTime: () => IsTime,
+  IsUri: () => IsUri,
+  IsUriReference: () => IsUriReference,
+  IsUriTemplate: () => IsUriTemplate,
+  IsUrl: () => IsUrl,
+  IsUuid: () => IsUuid,
+  Reset: () => Reset2,
+  Set: () => Set3,
+  Test: () => Test
 });
 
 // node_modules/typebox/build/format/date.mjs
@@ -32861,18 +33024,18 @@ var funcs = new Map;
 // node_modules/typebox/build/schema/resolve/resolve.mjs
 var exports_resolve = {};
 __export(exports_resolve, {
-  Ref: () => Ref2,
+  DefaultBase: () => DefaultBase,
   DynamicRef: () => DynamicRef,
-  DefaultBase: () => DefaultBase
+  Ref: () => Ref2
 });
 // node_modules/typebox/build/schema/pointer/pointer.mjs
 var exports_pointer = {};
 __export(exports_pointer, {
-  Set: () => Set4,
-  Indices: () => Indices,
-  Has: () => Has2,
+  Delete: () => Delete,
   Get: () => Get4,
-  Delete: () => Delete
+  Has: () => Has2,
+  Indices: () => Indices,
+  Set: () => Set4
 });
 function AssertNotRoot(indices) {
   if (indices.length === 0)
@@ -33371,16 +33534,16 @@ function Clean(...args) {
 // node_modules/typebox/build/value/convert/try/try.mjs
 var exports_try = {};
 __export(exports_try, {
-  TryUndefined: () => TryUndefined,
-  TryString: () => TryString,
-  TryNumber: () => TryNumber,
-  TryNull: () => TryNull,
-  TryBoolean: () => TryBoolean,
-  TryBigInt: () => TryBigInt,
-  TryArray: () => TryArray,
-  Ok: () => Ok,
+  Fail: () => Fail,
   IsOk: () => IsOk,
-  Fail: () => Fail
+  Ok: () => Ok,
+  TryArray: () => TryArray,
+  TryBigInt: () => TryBigInt,
+  TryBoolean: () => TryBoolean,
+  TryNull: () => TryNull,
+  TryNumber: () => TryNumber,
+  TryString: () => TryString,
+  TryUndefined: () => TryUndefined
 });
 
 // node_modules/typebox/build/value/convert/try/try_result.mjs
@@ -34655,24 +34818,24 @@ function Repair(...args) {
 // node_modules/typebox/build/value/value.mjs
 var exports_value = {};
 __export(exports_value, {
-  Repair: () => Repair,
-  Pointer: () => exports_pointer,
-  Patch: () => Patch,
-  Parse: () => Parse,
-  Hash: () => Hash2,
-  HasCodec: () => HasCodec,
-  Errors: () => Errors2,
-  Equal: () => Equal,
-  Encode: () => Encode10,
-  Diff: () => Diff,
-  Default: () => Default,
-  Decode: () => Decode10,
-  Create: () => Create2,
-  Convert: () => Convert,
-  Clone: () => Clone2,
-  Clean: () => Clean,
+  Assert: () => Assert,
   Check: () => Check4,
-  Assert: () => Assert
+  Clean: () => Clean,
+  Clone: () => Clone2,
+  Convert: () => Convert,
+  Create: () => Create2,
+  Decode: () => Decode10,
+  Default: () => Default,
+  Diff: () => Diff,
+  Encode: () => Encode10,
+  Equal: () => Equal,
+  Errors: () => Errors2,
+  HasCodec: () => HasCodec,
+  Hash: () => Hash2,
+  Parse: () => Parse,
+  Patch: () => Patch,
+  Pointer: () => exports_pointer,
+  Repair: () => Repair
 });
 // src/session/redisStore.ts
 var SESSION_SEGMENT = "sess:";
@@ -39360,7 +39523,7 @@ var createPostgresOidcRefreshTokenStore = (db) => ({
       dpop_jkt: sql`CASE WHEN ${active} THEN ${replacement.dpopJkt ?? null} ELSE ${oauthRefreshTokensTable.dpop_jkt} END`,
       expires_at_ms: sql`CASE WHEN ${active} THEN ${replacement.expiresAt} ELSE ${oauthRefreshTokensTable.expires_at_ms} END`,
       revoked_at_ms: sql`CASE WHEN ${consumed} THEN ${Date.now()} ELSE ${oauthRefreshTokensTable.revoked_at_ms} END`,
-      scopes: sql`CASE WHEN ${active} THEN ${replacement.scopes} ELSE ${oauthRefreshTokensTable.scopes} END`,
+      scopes: sql`CASE WHEN ${active} THEN ${sql.param(replacement.scopes, oauthRefreshTokensTable.scopes)} ELSE ${oauthRefreshTokensTable.scopes} END`,
       token_hash: sql`CASE WHEN ${active} THEN ${replacement.tokenHash} ELSE ${oauthRefreshTokensTable.token_hash} END`,
       user_id: sql`CASE WHEN ${active} THEN ${replacement.userId} ELSE ${oauthRefreshTokensTable.user_id} END`
     }).where(or(active, consumed)).returning({
@@ -41882,26 +42045,26 @@ var createNodeSamlAdapter = async (options = {}) => {
 // src/server.ts
 var auth2 = auth;
 export {
-  userSessionIdTypebox,
-  requireAuthPlugin,
-  readSessionCookie,
-  providers,
-  protectRoutePlugin,
-  isValidProviderOption,
-  isUserSessionId,
-  instantiateUserSession,
-  extractPropFromIdentity,
-  deriveAuthSyncNamespace,
-  createSetupSession,
-  createPostgresSsoConnectionStore,
-  createPostgresSetupSessionStore,
-  createPostgresScimTokenStore,
-  createNodeSamlAdapter,
-  createAuthContext,
-  createAbsoluteAuthSyncBridge,
+  VerificationProviderError,
   auth2 as auth,
-  VerificationProviderError
+  createAbsoluteAuthSyncBridge,
+  createAuthContext,
+  createNodeSamlAdapter,
+  createPostgresScimTokenStore,
+  createPostgresSetupSessionStore,
+  createPostgresSsoConnectionStore,
+  createSetupSession,
+  deriveAuthSyncNamespace,
+  extractPropFromIdentity,
+  instantiateUserSession,
+  isUserSessionId,
+  isValidProviderOption,
+  protectRoutePlugin,
+  providers,
+  readSessionCookie,
+  requireAuthPlugin,
+  userSessionIdTypebox
 };
 
-//# debugId=5FE7751779ECD0D364756E2164756E21
+//# debugId=EBB1CE453260D04564756E2164756E21
 //# sourceMappingURL=server.js.map