opencode-auth-load-balancer 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,506 +1,510 @@
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
-  xid: () => xid2,
-  void: () => _void2,
-  uuidv7: () => uuidv7,
-  uuidv6: () => uuidv6,
-  uuidv4: () => uuidv4,
-  uuid: () => uuid2,
-  util: () => exports_util,
-  url: () => url,
-  uppercase: () => _uppercase,
-  unknown: () => unknown,
-  union: () => union,
-  undefined: () => _undefined3,
-  ulid: () => ulid2,
-  uint64: () => uint64,
-  uint32: () => uint32,
-  tuple: () => tuple,
-  trim: () => _trim,
-  treeifyError: () => treeifyError,
-  transform: () => transform,
-  toUpperCase: () => _toUpperCase,
-  toLowerCase: () => _toLowerCase,
-  toJSONSchema: () => toJSONSchema,
-  templateLiteral: () => templateLiteral,
-  symbol: () => symbol,
-  superRefine: () => superRefine,
-  success: () => success,
-  stringbool: () => stringbool,
-  stringFormat: () => stringFormat,
-  string: () => string2,
-  strictObject: () => strictObject,
-  startsWith: () => _startsWith,
-  size: () => _size,
-  setErrorMap: () => setErrorMap,
-  set: () => set,
-  safeParseAsync: () => safeParseAsync2,
-  safeParse: () => safeParse2,
-  safeEncodeAsync: () => safeEncodeAsync2,
-  safeEncode: () => safeEncode2,
-  safeDecodeAsync: () => safeDecodeAsync2,
-  safeDecode: () => safeDecode2,
-  registry: () => registry,
-  regexes: () => exports_regexes,
-  regex: () => _regex,
-  refine: () => refine,
-  record: () => record,
-  readonly: () => readonly,
-  property: () => _property,
-  promise: () => promise,
-  prettifyError: () => prettifyError,
-  preprocess: () => preprocess,
-  prefault: () => prefault,
-  positive: () => _positive,
-  pipe: () => pipe,
-  partialRecord: () => partialRecord,
-  parseAsync: () => parseAsync2,
-  parse: () => parse3,
-  overwrite: () => _overwrite,
-  optional: () => optional,
-  object: () => object,
-  number: () => number2,
-  nullish: () => nullish2,
-  nullable: () => nullable,
-  null: () => _null3,
-  normalize: () => _normalize,
-  nonpositive: () => _nonpositive,
-  nonoptional: () => nonoptional,
-  nonnegative: () => _nonnegative,
-  never: () => never,
-  negative: () => _negative,
-  nativeEnum: () => nativeEnum,
-  nanoid: () => nanoid2,
-  nan: () => nan,
-  multipleOf: () => _multipleOf,
-  minSize: () => _minSize,
-  minLength: () => _minLength,
-  mime: () => _mime,
-  maxSize: () => _maxSize,
-  maxLength: () => _maxLength,
-  map: () => map,
-  lte: () => _lte,
-  lt: () => _lt,
-  lowercase: () => _lowercase,
-  looseObject: () => looseObject,
-  locales: () => exports_locales,
-  literal: () => literal,
-  length: () => _length,
-  lazy: () => lazy,
-  ksuid: () => ksuid2,
-  keyof: () => keyof,
-  jwt: () => jwt,
-  json: () => json,
-  iso: () => exports_iso,
-  ipv6: () => ipv62,
-  ipv4: () => ipv42,
-  intersection: () => intersection,
-  int64: () => int64,
-  int32: () => int32,
-  int: () => int,
-  instanceof: () => _instanceof,
-  includes: () => _includes,
-  httpUrl: () => httpUrl,
-  hostname: () => hostname2,
-  hex: () => hex2,
-  hash: () => hash,
-  guid: () => guid2,
-  gte: () => _gte,
-  gt: () => _gt,
-  globalRegistry: () => globalRegistry,
-  getErrorMap: () => getErrorMap,
-  function: () => _function,
-  formatError: () => formatError,
-  float64: () => float64,
-  float32: () => float32,
-  flattenError: () => flattenError,
-  file: () => file,
-  enum: () => _enum2,
-  endsWith: () => _endsWith,
-  encodeAsync: () => encodeAsync2,
-  encode: () => encode2,
-  emoji: () => emoji2,
-  email: () => email2,
-  e164: () => e1642,
-  discriminatedUnion: () => discriminatedUnion,
-  decodeAsync: () => decodeAsync2,
-  decode: () => decode2,
-  date: () => date3,
-  custom: () => custom,
-  cuid2: () => cuid22,
-  cuid: () => cuid3,
-  core: () => exports_core2,
-  config: () => config,
-  coerce: () => exports_coerce,
-  codec: () => codec,
-  clone: () => clone,
-  cidrv6: () => cidrv62,
-  cidrv4: () => cidrv42,
-  check: () => check,
-  catch: () => _catch2,
-  boolean: () => boolean2,
-  bigint: () => bigint2,
-  base64url: () => base64url2,
-  base64: () => base642,
-  array: () => array,
-  any: () => any,
-  _function: () => _function,
-  _default: () => _default2,
-  _ZodString: () => _ZodString,
-  ZodXID: () => ZodXID,
-  ZodVoid: () => ZodVoid,
-  ZodUnknown: () => ZodUnknown,
-  ZodUnion: () => ZodUnion,
-  ZodUndefined: () => ZodUndefined,
-  ZodUUID: () => ZodUUID,
-  ZodURL: () => ZodURL,
-  ZodULID: () => ZodULID,
-  ZodType: () => ZodType,
-  ZodTuple: () => ZodTuple,
-  ZodTransform: () => ZodTransform,
-  ZodTemplateLiteral: () => ZodTemplateLiteral,
-  ZodSymbol: () => ZodSymbol,
-  ZodSuccess: () => ZodSuccess,
-  ZodStringFormat: () => ZodStringFormat,
-  ZodString: () => ZodString,
-  ZodSet: () => ZodSet,
-  ZodRecord: () => ZodRecord,
-  ZodRealError: () => ZodRealError,
-  ZodReadonly: () => ZodReadonly,
-  ZodPromise: () => ZodPromise,
-  ZodPrefault: () => ZodPrefault,
-  ZodPipe: () => ZodPipe,
-  ZodOptional: () => ZodOptional,
-  ZodObject: () => ZodObject,
-  ZodNumberFormat: () => ZodNumberFormat,
-  ZodNumber: () => ZodNumber,
-  ZodNullable: () => ZodNullable,
-  ZodNull: () => ZodNull,
-  ZodNonOptional: () => ZodNonOptional,
-  ZodNever: () => ZodNever,
-  ZodNanoID: () => ZodNanoID,
-  ZodNaN: () => ZodNaN,
-  ZodMap: () => ZodMap,
-  ZodLiteral: () => ZodLiteral,
-  ZodLazy: () => ZodLazy,
-  ZodKSUID: () => ZodKSUID,
-  ZodJWT: () => ZodJWT,
-  ZodIssueCode: () => ZodIssueCode,
-  ZodIntersection: () => ZodIntersection,
-  ZodISOTime: () => ZodISOTime,
-  ZodISODuration: () => ZodISODuration,
-  ZodISODateTime: () => ZodISODateTime,
-  ZodISODate: () => ZodISODate,
-  ZodIPv6: () => ZodIPv6,
-  ZodIPv4: () => ZodIPv4,
-  ZodGUID: () => ZodGUID,
-  ZodFunction: () => ZodFunction,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-  ZodFile: () => ZodFile,
-  ZodError: () => ZodError,
-  ZodEnum: () => ZodEnum,
-  ZodEmoji: () => ZodEmoji,
-  ZodEmail: () => ZodEmail,
-  ZodE164: () => ZodE164,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodDefault: () => ZodDefault,
-  ZodDate: () => ZodDate,
-  ZodCustomStringFormat: () => ZodCustomStringFormat,
-  ZodCustom: () => ZodCustom,
-  ZodCodec: () => ZodCodec,
-  ZodCatch: () => ZodCatch,
-  ZodCUID2: () => ZodCUID2,
-  ZodCUID: () => ZodCUID,
-  ZodCIDRv6: () => ZodCIDRv6,
-  ZodCIDRv4: () => ZodCIDRv4,
-  ZodBoolean: () => ZodBoolean,
-  ZodBigIntFormat: () => ZodBigIntFormat,
-  ZodBigInt: () => ZodBigInt,
-  ZodBase64URL: () => ZodBase64URL,
-  ZodBase64: () => ZodBase64,
-  ZodArray: () => ZodArray,
-  ZodAny: () => ZodAny,
-  TimePrecision: () => TimePrecision,
-  NEVER: () => NEVER,
-  $output: () => $output,
+  $brand: () => $brand,
   $input: () => $input,
-  $brand: () => $brand
-});
-
-// node_modules/zod/v4/core/index.js
-var exports_core2 = {};
-__export(exports_core2, {
-  version: () => version,
-  util: () => exports_util,
-  treeifyError: () => treeifyError,
-  toJSONSchema: () => toJSONSchema,
-  toDotPath: () => toDotPath,
-  safeParseAsync: () => safeParseAsync,
-  safeParse: () => safeParse,
-  safeEncodeAsync: () => safeEncodeAsync,
-  safeEncode: () => safeEncode,
-  safeDecodeAsync: () => safeDecodeAsync,
-  safeDecode: () => safeDecode,
-  registry: () => registry,
-  regexes: () => exports_regexes,
-  prettifyError: () => prettifyError,
-  parseAsync: () => parseAsync,
-  parse: () => parse,
-  locales: () => exports_locales,
-  isValidJWT: () => isValidJWT,
-  isValidBase64URL: () => isValidBase64URL,
-  isValidBase64: () => isValidBase64,
-  globalRegistry: () => globalRegistry,
-  globalConfig: () => globalConfig,
-  formatError: () => formatError,
-  flattenError: () => flattenError,
-  encodeAsync: () => encodeAsync,
-  encode: () => encode,
-  decodeAsync: () => decodeAsync,
-  decode: () => decode,
-  config: () => config,
-  clone: () => clone,
-  _xid: () => _xid,
-  _void: () => _void,
-  _uuidv7: () => _uuidv7,
-  _uuidv6: () => _uuidv6,
-  _uuidv4: () => _uuidv4,
-  _uuid: () => _uuid,
-  _url: () => _url,
-  _uppercase: () => _uppercase,
-  _unknown: () => _unknown,
-  _union: () => _union,
-  _undefined: () => _undefined2,
-  _ulid: () => _ulid,
-  _uint64: () => _uint64,
-  _uint32: () => _uint32,
-  _tuple: () => _tuple,
-  _trim: () => _trim,
-  _transform: () => _transform,
-  _toUpperCase: () => _toUpperCase,
-  _toLowerCase: () => _toLowerCase,
-  _templateLiteral: () => _templateLiteral,
-  _symbol: () => _symbol,
-  _superRefine: () => _superRefine,
-  _success: () => _success,
-  _stringbool: () => _stringbool,
-  _stringFormat: () => _stringFormat,
-  _string: () => _string,
-  _startsWith: () => _startsWith,
-  _size: () => _size,
-  _set: () => _set,
-  _safeParseAsync: () => _safeParseAsync,
-  _safeParse: () => _safeParse,
-  _safeEncodeAsync: () => _safeEncodeAsync,
-  _safeEncode: () => _safeEncode,
-  _safeDecodeAsync: () => _safeDecodeAsync,
-  _safeDecode: () => _safeDecode,
-  _regex: () => _regex,
-  _refine: () => _refine,
-  _record: () => _record,
-  _readonly: () => _readonly,
-  _property: () => _property,
-  _promise: () => _promise,
-  _positive: () => _positive,
-  _pipe: () => _pipe,
-  _parseAsync: () => _parseAsync,
-  _parse: () => _parse,
-  _overwrite: () => _overwrite,
-  _optional: () => _optional,
-  _number: () => _number,
-  _nullable: () => _nullable,
-  _null: () => _null2,
-  _normalize: () => _normalize,
-  _nonpositive: () => _nonpositive,
-  _nonoptional: () => _nonoptional,
-  _nonnegative: () => _nonnegative,
-  _never: () => _never,
-  _negative: () => _negative,
-  _nativeEnum: () => _nativeEnum,
-  _nanoid: () => _nanoid,
-  _nan: () => _nan,
-  _multipleOf: () => _multipleOf,
-  _minSize: () => _minSize,
-  _minLength: () => _minLength,
-  _min: () => _gte,
-  _mime: () => _mime,
-  _maxSize: () => _maxSize,
-  _maxLength: () => _maxLength,
-  _max: () => _lte,
-  _map: () => _map,
-  _lte: () => _lte,
-  _lt: () => _lt,
-  _lowercase: () => _lowercase,
-  _literal: () => _literal,
-  _length: () => _length,
-  _lazy: () => _lazy,
-  _ksuid: () => _ksuid,
-  _jwt: () => _jwt,
-  _isoTime: () => _isoTime,
-  _isoDuration: () => _isoDuration,
-  _isoDateTime: () => _isoDateTime,
-  _isoDate: () => _isoDate,
-  _ipv6: () => _ipv6,
-  _ipv4: () => _ipv4,
-  _intersection: () => _intersection,
-  _int64: () => _int64,
-  _int32: () => _int32,
-  _int: () => _int,
-  _includes: () => _includes,
-  _guid: () => _guid,
-  _gte: () => _gte,
-  _gt: () => _gt,
-  _float64: () => _float64,
-  _float32: () => _float32,
-  _file: () => _file,
-  _enum: () => _enum,
-  _endsWith: () => _endsWith,
-  _encodeAsync: () => _encodeAsync,
-  _encode: () => _encode,
-  _emoji: () => _emoji2,
-  _email: () => _email,
-  _e164: () => _e164,
-  _discriminatedUnion: () => _discriminatedUnion,
-  _default: () => _default,
-  _decodeAsync: () => _decodeAsync,
-  _decode: () => _decode,
-  _date: () => _date,
-  _custom: () => _custom,
-  _cuid2: () => _cuid2,
-  _cuid: () => _cuid,
-  _coercedString: () => _coercedString,
-  _coercedNumber: () => _coercedNumber,
-  _coercedDate: () => _coercedDate,
-  _coercedBoolean: () => _coercedBoolean,
-  _coercedBigint: () => _coercedBigint,
-  _cidrv6: () => _cidrv6,
-  _cidrv4: () => _cidrv4,
-  _check: () => _check,
-  _catch: () => _catch,
-  _boolean: () => _boolean,
-  _bigint: () => _bigint,
-  _base64url: () => _base64url,
-  _base64: () => _base64,
-  _array: () => _array,
-  _any: () => _any,
-  TimePrecision: () => TimePrecision,
-  NEVER: () => NEVER,
-  JSONSchemaGenerator: () => JSONSchemaGenerator,
-  JSONSchema: () => exports_json_schema,
-  Doc: () => Doc,
   $output: () => $output,
-  $input: () => $input,
-  $constructor: () => $constructor,
-  $brand: () => $brand,
-  $ZodXID: () => $ZodXID,
-  $ZodVoid: () => $ZodVoid,
-  $ZodUnknown: () => $ZodUnknown,
-  $ZodUnion: () => $ZodUnion,
-  $ZodUndefined: () => $ZodUndefined,
-  $ZodUUID: () => $ZodUUID,
-  $ZodURL: () => $ZodURL,
-  $ZodULID: () => $ZodULID,
-  $ZodType: () => $ZodType,
-  $ZodTuple: () => $ZodTuple,
-  $ZodTransform: () => $ZodTransform,
-  $ZodTemplateLiteral: () => $ZodTemplateLiteral,
-  $ZodSymbol: () => $ZodSymbol,
-  $ZodSuccess: () => $ZodSuccess,
-  $ZodStringFormat: () => $ZodStringFormat,
-  $ZodString: () => $ZodString,
-  $ZodSet: () => $ZodSet,
-  $ZodRegistry: () => $ZodRegistry,
-  $ZodRecord: () => $ZodRecord,
-  $ZodRealError: () => $ZodRealError,
-  $ZodReadonly: () => $ZodReadonly,
-  $ZodPromise: () => $ZodPromise,
-  $ZodPrefault: () => $ZodPrefault,
-  $ZodPipe: () => $ZodPipe,
-  $ZodOptional: () => $ZodOptional,
-  $ZodObjectJIT: () => $ZodObjectJIT,
-  $ZodObject: () => $ZodObject,
-  $ZodNumberFormat: () => $ZodNumberFormat,
-  $ZodNumber: () => $ZodNumber,
-  $ZodNullable: () => $ZodNullable,
-  $ZodNull: () => $ZodNull,
-  $ZodNonOptional: () => $ZodNonOptional,
-  $ZodNever: () => $ZodNever,
-  $ZodNanoID: () => $ZodNanoID,
-  $ZodNaN: () => $ZodNaN,
-  $ZodMap: () => $ZodMap,
-  $ZodLiteral: () => $ZodLiteral,
-  $ZodLazy: () => $ZodLazy,
-  $ZodKSUID: () => $ZodKSUID,
-  $ZodJWT: () => $ZodJWT,
-  $ZodIntersection: () => $ZodIntersection,
-  $ZodISOTime: () => $ZodISOTime,
-  $ZodISODuration: () => $ZodISODuration,
-  $ZodISODateTime: () => $ZodISODateTime,
-  $ZodISODate: () => $ZodISODate,
-  $ZodIPv6: () => $ZodIPv6,
-  $ZodIPv4: () => $ZodIPv4,
-  $ZodGUID: () => $ZodGUID,
-  $ZodFunction: () => $ZodFunction,
-  $ZodFile: () => $ZodFile,
-  $ZodError: () => $ZodError,
-  $ZodEnum: () => $ZodEnum,
-  $ZodEncodeError: () => $ZodEncodeError,
-  $ZodEmoji: () => $ZodEmoji,
-  $ZodEmail: () => $ZodEmail,
-  $ZodE164: () => $ZodE164,
-  $ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,
-  $ZodDefault: () => $ZodDefault,
-  $ZodDate: () => $ZodDate,
-  $ZodCustomStringFormat: () => $ZodCustomStringFormat,
-  $ZodCustom: () => $ZodCustom,
-  $ZodCodec: () => $ZodCodec,
-  $ZodCheckUpperCase: () => $ZodCheckUpperCase,
-  $ZodCheckStringFormat: () => $ZodCheckStringFormat,
-  $ZodCheckStartsWith: () => $ZodCheckStartsWith,
-  $ZodCheckSizeEquals: () => $ZodCheckSizeEquals,
-  $ZodCheckRegex: () => $ZodCheckRegex,
-  $ZodCheckProperty: () => $ZodCheckProperty,
-  $ZodCheckOverwrite: () => $ZodCheckOverwrite,
-  $ZodCheckNumberFormat: () => $ZodCheckNumberFormat,
-  $ZodCheckMultipleOf: () => $ZodCheckMultipleOf,
-  $ZodCheckMinSize: () => $ZodCheckMinSize,
-  $ZodCheckMinLength: () => $ZodCheckMinLength,
-  $ZodCheckMimeType: () => $ZodCheckMimeType,
-  $ZodCheckMaxSize: () => $ZodCheckMaxSize,
-  $ZodCheckMaxLength: () => $ZodCheckMaxLength,
-  $ZodCheckLowerCase: () => $ZodCheckLowerCase,
-  $ZodCheckLessThan: () => $ZodCheckLessThan,
-  $ZodCheckLengthEquals: () => $ZodCheckLengthEquals,
-  $ZodCheckIncludes: () => $ZodCheckIncludes,
-  $ZodCheckGreaterThan: () => $ZodCheckGreaterThan,
-  $ZodCheckEndsWith: () => $ZodCheckEndsWith,
-  $ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,
-  $ZodCheck: () => $ZodCheck,
-  $ZodCatch: () => $ZodCatch,
-  $ZodCUID2: () => $ZodCUID2,
-  $ZodCUID: () => $ZodCUID,
-  $ZodCIDRv6: () => $ZodCIDRv6,
-  $ZodCIDRv4: () => $ZodCIDRv4,
-  $ZodBoolean: () => $ZodBoolean,
-  $ZodBigIntFormat: () => $ZodBigIntFormat,
-  $ZodBigInt: () => $ZodBigInt,
-  $ZodBase64URL: () => $ZodBase64URL,
-  $ZodBase64: () => $ZodBase64,
-  $ZodAsyncError: () => $ZodAsyncError,
+  NEVER: () => NEVER,
+  TimePrecision: () => TimePrecision,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBase64: () => ZodBase64,
+  ZodBase64URL: () => ZodBase64URL,
+  ZodBigInt: () => ZodBigInt,
+  ZodBigIntFormat: () => ZodBigIntFormat,
+  ZodBoolean: () => ZodBoolean,
+  ZodCIDRv4: () => ZodCIDRv4,
+  ZodCIDRv6: () => ZodCIDRv6,
+  ZodCUID: () => ZodCUID,
+  ZodCUID2: () => ZodCUID2,
+  ZodCatch: () => ZodCatch,
+  ZodCodec: () => ZodCodec,
+  ZodCustom: () => ZodCustom,
+  ZodCustomStringFormat: () => ZodCustomStringFormat,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodE164: () => ZodE164,
+  ZodEmail: () => ZodEmail,
+  ZodEmoji: () => ZodEmoji,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodFile: () => ZodFile,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodGUID: () => ZodGUID,
+  ZodIPv4: () => ZodIPv4,
+  ZodIPv6: () => ZodIPv6,
+  ZodISODate: () => ZodISODate,
+  ZodISODateTime: () => ZodISODateTime,
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodJWT: () => ZodJWT,
+  ZodKSUID: () => ZodKSUID,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNanoID: () => ZodNanoID,
+  ZodNever: () => ZodNever,
+  ZodNonOptional: () => ZodNonOptional,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodNumberFormat: () => ZodNumberFormat,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodPipe: () => ZodPipe,
+  ZodPrefault: () => ZodPrefault,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRealError: () => ZodRealError,
+  ZodRecord: () => ZodRecord,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodStringFormat: () => ZodStringFormat,
+  ZodSuccess: () => ZodSuccess,
+  ZodSymbol: () => ZodSymbol,
+  ZodTemplateLiteral: () => ZodTemplateLiteral,
+  ZodTransform: () => ZodTransform,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodULID: () => ZodULID,
+  ZodURL: () => ZodURL,
+  ZodUUID: () => ZodUUID,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  ZodXID: () => ZodXID,
+  _ZodString: () => _ZodString,
+  _default: () => _default2,
+  _function: () => _function,
+  any: () => any,
+  array: () => array,
+  base64: () => base642,
+  base64url: () => base64url2,
+  bigint: () => bigint2,
+  boolean: () => boolean2,
+  catch: () => _catch2,
+  check: () => check,
+  cidrv4: () => cidrv42,
+  cidrv6: () => cidrv62,
+  clone: () => clone,
+  codec: () => codec,
+  coerce: () => exports_coerce,
+  config: () => config,
+  core: () => exports_core2,
+  cuid: () => cuid3,
+  cuid2: () => cuid22,
+  custom: () => custom,
+  date: () => date3,
+  decode: () => decode2,
+  decodeAsync: () => decodeAsync2,
+  discriminatedUnion: () => discriminatedUnion,
+  e164: () => e1642,
+  email: () => email2,
+  emoji: () => emoji2,
+  encode: () => encode2,
+  encodeAsync: () => encodeAsync2,
+  endsWith: () => _endsWith,
+  enum: () => _enum2,
+  file: () => file,
+  flattenError: () => flattenError,
+  float32: () => float32,
+  float64: () => float64,
+  formatError: () => formatError,
+  function: () => _function,
+  getErrorMap: () => getErrorMap,
+  globalRegistry: () => globalRegistry,
+  gt: () => _gt,
+  gte: () => _gte,
+  guid: () => guid2,
+  hash: () => hash,
+  hex: () => hex2,
+  hostname: () => hostname2,
+  httpUrl: () => httpUrl,
+  includes: () => _includes,
+  instanceof: () => _instanceof,
+  int: () => int,
+  int32: () => int32,
+  int64: () => int64,
+  intersection: () => intersection,
+  ipv4: () => ipv42,
+  ipv6: () => ipv62,
+  iso: () => exports_iso,
+  json: () => json,
+  jwt: () => jwt,
+  keyof: () => keyof,
+  ksuid: () => ksuid2,
+  lazy: () => lazy,
+  length: () => _length,
+  literal: () => literal,
+  locales: () => exports_locales,
+  looseObject: () => looseObject,
+  lowercase: () => _lowercase,
+  lt: () => _lt,
+  lte: () => _lte,
+  map: () => map,
+  maxLength: () => _maxLength,
+  maxSize: () => _maxSize,
+  mime: () => _mime,
+  minLength: () => _minLength,
+  minSize: () => _minSize,
+  multipleOf: () => _multipleOf,
+  nan: () => nan,
+  nanoid: () => nanoid2,
+  nativeEnum: () => nativeEnum,
+  negative: () => _negative,
+  never: () => never,
+  nonnegative: () => _nonnegative,
+  nonoptional: () => nonoptional,
+  nonpositive: () => _nonpositive,
+  normalize: () => _normalize,
+  null: () => _null3,
+  nullable: () => nullable,
+  nullish: () => nullish2,
+  number: () => number2,
+  object: () => object,
+  optional: () => optional,
+  overwrite: () => _overwrite,
+  parse: () => parse3,
+  parseAsync: () => parseAsync2,
+  partialRecord: () => partialRecord,
+  pipe: () => pipe,
+  positive: () => _positive,
+  prefault: () => prefault,
+  preprocess: () => preprocess,
+  prettifyError: () => prettifyError,
+  promise: () => promise,
+  property: () => _property,
+  readonly: () => readonly,
+  record: () => record,
+  refine: () => refine,
+  regex: () => _regex,
+  regexes: () => exports_regexes,
+  registry: () => registry,
+  safeDecode: () => safeDecode2,
+  safeDecodeAsync: () => safeDecodeAsync2,
+  safeEncode: () => safeEncode2,
+  safeEncodeAsync: () => safeEncodeAsync2,
+  safeParse: () => safeParse2,
+  safeParseAsync: () => safeParseAsync2,
+  set: () => set,
+  setErrorMap: () => setErrorMap,
+  size: () => _size,
+  startsWith: () => _startsWith,
+  strictObject: () => strictObject,
+  string: () => string2,
+  stringFormat: () => stringFormat,
+  stringbool: () => stringbool,
+  success: () => success,
+  superRefine: () => superRefine,
+  symbol: () => symbol,
+  templateLiteral: () => templateLiteral,
+  toJSONSchema: () => toJSONSchema,
+  toLowerCase: () => _toLowerCase,
+  toUpperCase: () => _toUpperCase,
+  transform: () => transform,
+  treeifyError: () => treeifyError,
+  trim: () => _trim,
+  tuple: () => tuple,
+  uint32: () => uint32,
+  uint64: () => uint64,
+  ulid: () => ulid2,
+  undefined: () => _undefined3,
+  union: () => union,
+  unknown: () => unknown,
+  uppercase: () => _uppercase,
+  url: () => url,
+  util: () => exports_util,
+  uuid: () => uuid2,
+  uuidv4: () => uuidv4,
+  uuidv6: () => uuidv6,
+  uuidv7: () => uuidv7,
+  void: () => _void2,
+  xid: () => xid2
+});
+
+// node_modules/zod/v4/core/index.js
+var exports_core2 = {};
+__export(exports_core2, {
+  $ZodAny: () => $ZodAny,
   $ZodArray: () => $ZodArray,
-  $ZodAny: () => $ZodAny
+  $ZodAsyncError: () => $ZodAsyncError,
+  $ZodBase64: () => $ZodBase64,
+  $ZodBase64URL: () => $ZodBase64URL,
+  $ZodBigInt: () => $ZodBigInt,
+  $ZodBigIntFormat: () => $ZodBigIntFormat,
+  $ZodBoolean: () => $ZodBoolean,
+  $ZodCIDRv4: () => $ZodCIDRv4,
+  $ZodCIDRv6: () => $ZodCIDRv6,
+  $ZodCUID: () => $ZodCUID,
+  $ZodCUID2: () => $ZodCUID2,
+  $ZodCatch: () => $ZodCatch,
+  $ZodCheck: () => $ZodCheck,
+  $ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,
+  $ZodCheckEndsWith: () => $ZodCheckEndsWith,
+  $ZodCheckGreaterThan: () => $ZodCheckGreaterThan,
+  $ZodCheckIncludes: () => $ZodCheckIncludes,
+  $ZodCheckLengthEquals: () => $ZodCheckLengthEquals,
+  $ZodCheckLessThan: () => $ZodCheckLessThan,
+  $ZodCheckLowerCase: () => $ZodCheckLowerCase,
+  $ZodCheckMaxLength: () => $ZodCheckMaxLength,
+  $ZodCheckMaxSize: () => $ZodCheckMaxSize,
+  $ZodCheckMimeType: () => $ZodCheckMimeType,
+  $ZodCheckMinLength: () => $ZodCheckMinLength,
+  $ZodCheckMinSize: () => $ZodCheckMinSize,
+  $ZodCheckMultipleOf: () => $ZodCheckMultipleOf,
+  $ZodCheckNumberFormat: () => $ZodCheckNumberFormat,
+  $ZodCheckOverwrite: () => $ZodCheckOverwrite,
+  $ZodCheckProperty: () => $ZodCheckProperty,
+  $ZodCheckRegex: () => $ZodCheckRegex,
+  $ZodCheckSizeEquals: () => $ZodCheckSizeEquals,
+  $ZodCheckStartsWith: () => $ZodCheckStartsWith,
+  $ZodCheckStringFormat: () => $ZodCheckStringFormat,
+  $ZodCheckUpperCase: () => $ZodCheckUpperCase,
+  $ZodCodec: () => $ZodCodec,
+  $ZodCustom: () => $ZodCustom,
+  $ZodCustomStringFormat: () => $ZodCustomStringFormat,
+  $ZodDate: () => $ZodDate,
+  $ZodDefault: () => $ZodDefault,
+  $ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,
+  $ZodE164: () => $ZodE164,
+  $ZodEmail: () => $ZodEmail,
+  $ZodEmoji: () => $ZodEmoji,
+  $ZodEncodeError: () => $ZodEncodeError,
+  $ZodEnum: () => $ZodEnum,
+  $ZodError: () => $ZodError,
+  $ZodFile: () => $ZodFile,
+  $ZodFunction: () => $ZodFunction,
+  $ZodGUID: () => $ZodGUID,
+  $ZodIPv4: () => $ZodIPv4,
+  $ZodIPv6: () => $ZodIPv6,
+  $ZodISODate: () => $ZodISODate,
+  $ZodISODateTime: () => $ZodISODateTime,
+  $ZodISODuration: () => $ZodISODuration,
+  $ZodISOTime: () => $ZodISOTime,
+  $ZodIntersection: () => $ZodIntersection,
+  $ZodJWT: () => $ZodJWT,
+  $ZodKSUID: () => $ZodKSUID,
+  $ZodLazy: () => $ZodLazy,
+  $ZodLiteral: () => $ZodLiteral,
+  $ZodMap: () => $ZodMap,
+  $ZodNaN: () => $ZodNaN,
+  $ZodNanoID: () => $ZodNanoID,
+  $ZodNever: () => $ZodNever,
+  $ZodNonOptional: () => $ZodNonOptional,
+  $ZodNull: () => $ZodNull,
+  $ZodNullable: () => $ZodNullable,
+  $ZodNumber: () => $ZodNumber,
+  $ZodNumberFormat: () => $ZodNumberFormat,
+  $ZodObject: () => $ZodObject,
+  $ZodObjectJIT: () => $ZodObjectJIT,
+  $ZodOptional: () => $ZodOptional,
+  $ZodPipe: () => $ZodPipe,
+  $ZodPrefault: () => $ZodPrefault,
+  $ZodPromise: () => $ZodPromise,
+  $ZodReadonly: () => $ZodReadonly,
+  $ZodRealError: () => $ZodRealError,
+  $ZodRecord: () => $ZodRecord,
+  $ZodRegistry: () => $ZodRegistry,
+  $ZodSet: () => $ZodSet,
+  $ZodString: () => $ZodString,
+  $ZodStringFormat: () => $ZodStringFormat,
+  $ZodSuccess: () => $ZodSuccess,
+  $ZodSymbol: () => $ZodSymbol,
+  $ZodTemplateLiteral: () => $ZodTemplateLiteral,
+  $ZodTransform: () => $ZodTransform,
+  $ZodTuple: () => $ZodTuple,
+  $ZodType: () => $ZodType,
+  $ZodULID: () => $ZodULID,
+  $ZodURL: () => $ZodURL,
+  $ZodUUID: () => $ZodUUID,
+  $ZodUndefined: () => $ZodUndefined,
+  $ZodUnion: () => $ZodUnion,
+  $ZodUnknown: () => $ZodUnknown,
+  $ZodVoid: () => $ZodVoid,
+  $ZodXID: () => $ZodXID,
+  $brand: () => $brand,
+  $constructor: () => $constructor,
+  $input: () => $input,
+  $output: () => $output,
+  Doc: () => Doc,
+  JSONSchema: () => exports_json_schema,
+  JSONSchemaGenerator: () => JSONSchemaGenerator,
+  NEVER: () => NEVER,
+  TimePrecision: () => TimePrecision,
+  _any: () => _any,
+  _array: () => _array,
+  _base64: () => _base64,
+  _base64url: () => _base64url,
+  _bigint: () => _bigint,
+  _boolean: () => _boolean,
+  _catch: () => _catch,
+  _check: () => _check,
+  _cidrv4: () => _cidrv4,
+  _cidrv6: () => _cidrv6,
+  _coercedBigint: () => _coercedBigint,
+  _coercedBoolean: () => _coercedBoolean,
+  _coercedDate: () => _coercedDate,
+  _coercedNumber: () => _coercedNumber,
+  _coercedString: () => _coercedString,
+  _cuid: () => _cuid,
+  _cuid2: () => _cuid2,
+  _custom: () => _custom,
+  _date: () => _date,
+  _decode: () => _decode,
+  _decodeAsync: () => _decodeAsync,
+  _default: () => _default,
+  _discriminatedUnion: () => _discriminatedUnion,
+  _e164: () => _e164,
+  _email: () => _email,
+  _emoji: () => _emoji2,
+  _encode: () => _encode,
+  _encodeAsync: () => _encodeAsync,
+  _endsWith: () => _endsWith,
+  _enum: () => _enum,
+  _file: () => _file,
+  _float32: () => _float32,
+  _float64: () => _float64,
+  _gt: () => _gt,
+  _gte: () => _gte,
+  _guid: () => _guid,
+  _includes: () => _includes,
+  _int: () => _int,
+  _int32: () => _int32,
+  _int64: () => _int64,
+  _intersection: () => _intersection,
+  _ipv4: () => _ipv4,
+  _ipv6: () => _ipv6,
+  _isoDate: () => _isoDate,
+  _isoDateTime: () => _isoDateTime,
+  _isoDuration: () => _isoDuration,
+  _isoTime: () => _isoTime,
+  _jwt: () => _jwt,
+  _ksuid: () => _ksuid,
+  _lazy: () => _lazy,
+  _length: () => _length,
+  _literal: () => _literal,
+  _lowercase: () => _lowercase,
+  _lt: () => _lt,
+  _lte: () => _lte,
+  _map: () => _map,
+  _max: () => _lte,
+  _maxLength: () => _maxLength,
+  _maxSize: () => _maxSize,
+  _mime: () => _mime,
+  _min: () => _gte,
+  _minLength: () => _minLength,
+  _minSize: () => _minSize,
+  _multipleOf: () => _multipleOf,
+  _nan: () => _nan,
+  _nanoid: () => _nanoid,
+  _nativeEnum: () => _nativeEnum,
+  _negative: () => _negative,
+  _never: () => _never,
+  _nonnegative: () => _nonnegative,
+  _nonoptional: () => _nonoptional,
+  _nonpositive: () => _nonpositive,
+  _normalize: () => _normalize,
+  _null: () => _null2,
+  _nullable: () => _nullable,
+  _number: () => _number,
+  _optional: () => _optional,
+  _overwrite: () => _overwrite,
+  _parse: () => _parse,
+  _parseAsync: () => _parseAsync,
+  _pipe: () => _pipe,
+  _positive: () => _positive,
+  _promise: () => _promise,
+  _property: () => _property,
+  _readonly: () => _readonly,
+  _record: () => _record,
+  _refine: () => _refine,
+  _regex: () => _regex,
+  _safeDecode: () => _safeDecode,
+  _safeDecodeAsync: () => _safeDecodeAsync,
+  _safeEncode: () => _safeEncode,
+  _safeEncodeAsync: () => _safeEncodeAsync,
+  _safeParse: () => _safeParse,
+  _safeParseAsync: () => _safeParseAsync,
+  _set: () => _set,
+  _size: () => _size,
+  _startsWith: () => _startsWith,
+  _string: () => _string,
+  _stringFormat: () => _stringFormat,
+  _stringbool: () => _stringbool,
+  _success: () => _success,
+  _superRefine: () => _superRefine,
+  _symbol: () => _symbol,
+  _templateLiteral: () => _templateLiteral,
+  _toLowerCase: () => _toLowerCase,
+  _toUpperCase: () => _toUpperCase,
+  _transform: () => _transform,
+  _trim: () => _trim,
+  _tuple: () => _tuple,
+  _uint32: () => _uint32,
+  _uint64: () => _uint64,
+  _ulid: () => _ulid,
+  _undefined: () => _undefined2,
+  _union: () => _union,
+  _unknown: () => _unknown,
+  _uppercase: () => _uppercase,
+  _url: () => _url,
+  _uuid: () => _uuid,
+  _uuidv4: () => _uuidv4,
+  _uuidv6: () => _uuidv6,
+  _uuidv7: () => _uuidv7,
+  _void: () => _void,
+  _xid: () => _xid,
+  clone: () => clone,
+  config: () => config,
+  decode: () => decode,
+  decodeAsync: () => decodeAsync,
+  encode: () => encode,
+  encodeAsync: () => encodeAsync,
+  flattenError: () => flattenError,
+  formatError: () => formatError,
+  globalConfig: () => globalConfig,
+  globalRegistry: () => globalRegistry,
+  isValidBase64: () => isValidBase64,
+  isValidBase64URL: () => isValidBase64URL,
+  isValidJWT: () => isValidJWT,
+  locales: () => exports_locales,
+  parse: () => parse,
+  parseAsync: () => parseAsync,
+  prettifyError: () => prettifyError,
+  regexes: () => exports_regexes,
+  registry: () => registry,
+  safeDecode: () => safeDecode,
+  safeDecodeAsync: () => safeDecodeAsync,
+  safeEncode: () => safeEncode,
+  safeEncodeAsync: () => safeEncodeAsync,
+  safeParse: () => safeParse,
+  safeParseAsync: () => safeParseAsync,
+  toDotPath: () => toDotPath,
+  toJSONSchema: () => toJSONSchema,
+  treeifyError: () => treeifyError,
+  util: () => exports_util,
+  version: () => version
 });
 
 // node_modules/zod/v4/core/core.js
@@ -554,85 +558,85 @@ var $brand = Symbol("zod_brand");
 
 class $ZodAsyncError extends Error {
   constructor() {
-    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
-  }
-}
-
-class $ZodEncodeError extends Error {
-  constructor(name) {
-    super(`Encountered unidirectional transform during encode: ${name}`);
-    this.name = "ZodEncodeError";
-  }
-}
-var globalConfig = {};
-function config(newConfig) {
-  if (newConfig)
-    Object.assign(globalConfig, newConfig);
-  return globalConfig;
-}
-// node_modules/zod/v4/core/util.js
-var exports_util = {};
-__export(exports_util, {
-  unwrapMessage: () => unwrapMessage,
-  uint8ArrayToHex: () => uint8ArrayToHex,
-  uint8ArrayToBase64url: () => uint8ArrayToBase64url,
-  uint8ArrayToBase64: () => uint8ArrayToBase64,
-  stringifyPrimitive: () => stringifyPrimitive,
-  shallowClone: () => shallowClone,
-  safeExtend: () => safeExtend,
-  required: () => required,
-  randomString: () => randomString,
-  propertyKeyTypes: () => propertyKeyTypes,
-  promiseAllObject: () => promiseAllObject,
-  primitiveTypes: () => primitiveTypes,
-  prefixIssues: () => prefixIssues,
-  pick: () => pick,
-  partial: () => partial,
-  optionalKeys: () => optionalKeys,
-  omit: () => omit,
-  objectClone: () => objectClone,
-  numKeys: () => numKeys,
-  nullish: () => nullish,
-  normalizeParams: () => normalizeParams,
-  mergeDefs: () => mergeDefs,
-  merge: () => merge,
-  jsonStringifyReplacer: () => jsonStringifyReplacer,
-  joinValues: () => joinValues,
-  issue: () => issue,
-  isPlainObject: () => isPlainObject,
-  isObject: () => isObject,
-  hexToUint8Array: () => hexToUint8Array,
-  getSizableOrigin: () => getSizableOrigin,
-  getParsedType: () => getParsedType,
-  getLengthableOrigin: () => getLengthableOrigin,
-  getEnumValues: () => getEnumValues,
-  getElementAtPath: () => getElementAtPath,
-  floatSafeRemainder: () => floatSafeRemainder,
-  finalizeIssue: () => finalizeIssue,
-  extend: () => extend,
-  escapeRegex: () => escapeRegex,
-  esc: () => esc,
-  defineLazy: () => defineLazy,
-  createTransparentProxy: () => createTransparentProxy,
-  cloneDef: () => cloneDef,
-  clone: () => clone,
-  cleanRegex: () => cleanRegex,
-  cleanEnum: () => cleanEnum,
-  captureStackTrace: () => captureStackTrace,
-  cached: () => cached,
-  base64urlToUint8Array: () => base64urlToUint8Array,
-  base64ToUint8Array: () => base64ToUint8Array,
-  assignProp: () => assignProp,
-  assertNotEqual: () => assertNotEqual,
-  assertNever: () => assertNever,
-  assertIs: () => assertIs,
-  assertEqual: () => assertEqual,
-  assert: () => assert,
-  allowsEval: () => allowsEval,
-  aborted: () => aborted,
-  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
+    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+  }
+}
+
+class $ZodEncodeError extends Error {
+  constructor(name) {
+    super(`Encountered unidirectional transform during encode: ${name}`);
+    this.name = "ZodEncodeError";
+  }
+}
+var globalConfig = {};
+function config(newConfig) {
+  if (newConfig)
+    Object.assign(globalConfig, newConfig);
+  return globalConfig;
+}
+// node_modules/zod/v4/core/util.js
+var exports_util = {};
+__export(exports_util, {
+  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
   Class: () => Class,
-  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES
+  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
+  aborted: () => aborted,
+  allowsEval: () => allowsEval,
+  assert: () => assert,
+  assertEqual: () => assertEqual,
+  assertIs: () => assertIs,
+  assertNever: () => assertNever,
+  assertNotEqual: () => assertNotEqual,
+  assignProp: () => assignProp,
+  base64ToUint8Array: () => base64ToUint8Array,
+  base64urlToUint8Array: () => base64urlToUint8Array,
+  cached: () => cached,
+  captureStackTrace: () => captureStackTrace,
+  cleanEnum: () => cleanEnum,
+  cleanRegex: () => cleanRegex,
+  clone: () => clone,
+  cloneDef: () => cloneDef,
+  createTransparentProxy: () => createTransparentProxy,
+  defineLazy: () => defineLazy,
+  esc: () => esc,
+  escapeRegex: () => escapeRegex,
+  extend: () => extend,
+  finalizeIssue: () => finalizeIssue,
+  floatSafeRemainder: () => floatSafeRemainder,
+  getElementAtPath: () => getElementAtPath,
+  getEnumValues: () => getEnumValues,
+  getLengthableOrigin: () => getLengthableOrigin,
+  getParsedType: () => getParsedType,
+  getSizableOrigin: () => getSizableOrigin,
+  hexToUint8Array: () => hexToUint8Array,
+  isObject: () => isObject,
+  isPlainObject: () => isPlainObject,
+  issue: () => issue,
+  joinValues: () => joinValues,
+  jsonStringifyReplacer: () => jsonStringifyReplacer,
+  merge: () => merge,
+  mergeDefs: () => mergeDefs,
+  normalizeParams: () => normalizeParams,
+  nullish: () => nullish,
+  numKeys: () => numKeys,
+  objectClone: () => objectClone,
+  omit: () => omit,
+  optionalKeys: () => optionalKeys,
+  partial: () => partial,
+  pick: () => pick,
+  prefixIssues: () => prefixIssues,
+  primitiveTypes: () => primitiveTypes,
+  promiseAllObject: () => promiseAllObject,
+  propertyKeyTypes: () => propertyKeyTypes,
+  randomString: () => randomString,
+  required: () => required,
+  safeExtend: () => safeExtend,
+  shallowClone: () => shallowClone,
+  stringifyPrimitive: () => stringifyPrimitive,
+  uint8ArrayToBase64: () => uint8ArrayToBase64,
+  uint8ArrayToBase64url: () => uint8ArrayToBase64url,
+  uint8ArrayToHex: () => uint8ArrayToHex,
+  unwrapMessage: () => unwrapMessage
 });
 function assertEqual(val) {
   return val;
@@ -1432,63 +1436,63 @@ var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
 // node_modules/zod/v4/core/regexes.js
 var exports_regexes = {};
 __export(exports_regexes, {
-  xid: () => xid,
-  uuid7: () => uuid7,
-  uuid6: () => uuid6,
-  uuid4: () => uuid4,
-  uuid: () => uuid,
-  uppercase: () => uppercase,
-  unicodeEmail: () => unicodeEmail,
-  undefined: () => _undefined,
-  ulid: () => ulid,
-  time: () => time,
-  string: () => string,
-  sha512_hex: () => sha512_hex,
-  sha512_base64url: () => sha512_base64url,
-  sha512_base64: () => sha512_base64,
-  sha384_hex: () => sha384_hex,
-  sha384_base64url: () => sha384_base64url,
-  sha384_base64: () => sha384_base64,
-  sha256_hex: () => sha256_hex,
-  sha256_base64url: () => sha256_base64url,
-  sha256_base64: () => sha256_base64,
-  sha1_hex: () => sha1_hex,
-  sha1_base64url: () => sha1_base64url,
-  sha1_base64: () => sha1_base64,
-  rfc5322Email: () => rfc5322Email,
-  number: () => number,
-  null: () => _null,
-  nanoid: () => nanoid,
-  md5_hex: () => md5_hex,
-  md5_base64url: () => md5_base64url,
-  md5_base64: () => md5_base64,
-  lowercase: () => lowercase,
-  ksuid: () => ksuid,
-  ipv6: () => ipv6,
-  ipv4: () => ipv4,
-  integer: () => integer,
-  idnEmail: () => idnEmail,
-  html5Email: () => html5Email,
-  hostname: () => hostname,
-  hex: () => hex,
-  guid: () => guid,
-  extendedDuration: () => extendedDuration,
-  emoji: () => emoji,
-  email: () => email,
-  e164: () => e164,
-  duration: () => duration,
-  domain: () => domain,
-  datetime: () => datetime,
-  date: () => date,
-  cuid2: () => cuid2,
-  cuid: () => cuid,
-  cidrv6: () => cidrv6,
-  cidrv4: () => cidrv4,
-  browserEmail: () => browserEmail,
-  boolean: () => boolean,
-  bigint: () => bigint,
+  base64: () => base64,
   base64url: () => base64url,
-  base64: () => base64
+  bigint: () => bigint,
+  boolean: () => boolean,
+  browserEmail: () => browserEmail,
+  cidrv4: () => cidrv4,
+  cidrv6: () => cidrv6,
+  cuid: () => cuid,
+  cuid2: () => cuid2,
+  date: () => date,
+  datetime: () => datetime,
+  domain: () => domain,
+  duration: () => duration,
+  e164: () => e164,
+  email: () => email,
+  emoji: () => emoji,
+  extendedDuration: () => extendedDuration,
+  guid: () => guid,
+  hex: () => hex,
+  hostname: () => hostname,
+  html5Email: () => html5Email,
+  idnEmail: () => idnEmail,
+  integer: () => integer,
+  ipv4: () => ipv4,
+  ipv6: () => ipv6,
+  ksuid: () => ksuid,
+  lowercase: () => lowercase,
+  md5_base64: () => md5_base64,
+  md5_base64url: () => md5_base64url,
+  md5_hex: () => md5_hex,
+  nanoid: () => nanoid,
+  null: () => _null,
+  number: () => number,
+  rfc5322Email: () => rfc5322Email,
+  sha1_base64: () => sha1_base64,
+  sha1_base64url: () => sha1_base64url,
+  sha1_hex: () => sha1_hex,
+  sha256_base64: () => sha256_base64,
+  sha256_base64url: () => sha256_base64url,
+  sha256_hex: () => sha256_hex,
+  sha384_base64: () => sha384_base64,
+  sha384_base64url: () => sha384_base64url,
+  sha384_hex: () => sha384_hex,
+  sha512_base64: () => sha512_base64,
+  sha512_base64url: () => sha512_base64url,
+  sha512_hex: () => sha512_hex,
+  string: () => string,
+  time: () => time,
+  ulid: () => ulid,
+  undefined: () => _undefined,
+  unicodeEmail: () => unicodeEmail,
+  uppercase: () => uppercase,
+  uuid: () => uuid,
+  uuid4: () => uuid4,
+  uuid6: () => uuid6,
+  uuid7: () => uuid7,
+  xid: () => xid
 });
 var cuid = /^[cC][^\s-]{8,}$/;
 var cuid2 = /^[0-9a-z]+$/;
@@ -3993,52 +3997,52 @@ function handleRefineResult(result, payload, input, inst) {
 // node_modules/zod/v4/locales/index.js
 var exports_locales = {};
 __export(exports_locales, {
-  zhTW: () => zh_TW_default,
-  zhCN: () => zh_CN_default,
-  yo: () => yo_default,
-  vi: () => vi_default,
-  ur: () => ur_default,
-  uk: () => uk_default,
-  ua: () => ua_default,
-  tr: () => tr_default,
-  th: () => th_default,
-  ta: () => ta_default,
-  sv: () => sv_default,
-  sl: () => sl_default,
-  ru: () => ru_default,
-  pt: () => pt_default,
-  ps: () => ps_default,
-  pl: () => pl_default,
-  ota: () => ota_default,
-  no: () => no_default,
-  nl: () => nl_default,
-  ms: () => ms_default,
-  mk: () => mk_default,
-  lt: () => lt_default,
-  ko: () => ko_default,
-  km: () => km_default,
-  kh: () => kh_default,
-  ka: () => ka_default,
-  ja: () => ja_default,
-  it: () => it_default,
-  is: () => is_default,
-  id: () => id_default,
-  hu: () => hu_default,
-  he: () => he_default,
-  frCA: () => fr_CA_default,
-  fr: () => fr_default,
-  fi: () => fi_default,
-  fa: () => fa_default,
-  es: () => es_default,
-  eo: () => eo_default,
-  en: () => en_default,
-  de: () => de_default,
-  da: () => da_default,
-  cs: () => cs_default,
-  ca: () => ca_default,
-  be: () => be_default,
+  ar: () => ar_default,
   az: () => az_default,
-  ar: () => ar_default
+  be: () => be_default,
+  ca: () => ca_default,
+  cs: () => cs_default,
+  da: () => da_default,
+  de: () => de_default,
+  en: () => en_default,
+  eo: () => eo_default,
+  es: () => es_default,
+  fa: () => fa_default,
+  fi: () => fi_default,
+  fr: () => fr_default,
+  frCA: () => fr_CA_default,
+  he: () => he_default,
+  hu: () => hu_default,
+  id: () => id_default,
+  is: () => is_default,
+  it: () => it_default,
+  ja: () => ja_default,
+  ka: () => ka_default,
+  kh: () => kh_default,
+  km: () => km_default,
+  ko: () => ko_default,
+  lt: () => lt_default,
+  mk: () => mk_default,
+  ms: () => ms_default,
+  nl: () => nl_default,
+  no: () => no_default,
+  ota: () => ota_default,
+  pl: () => pl_default,
+  ps: () => ps_default,
+  pt: () => pt_default,
+  ru: () => ru_default,
+  sl: () => sl_default,
+  sv: () => sv_default,
+  ta: () => ta_default,
+  th: () => th_default,
+  tr: () => tr_default,
+  ua: () => ua_default,
+  uk: () => uk_default,
+  ur: () => ur_default,
+  vi: () => vi_default,
+  yo: () => yo_default,
+  zhCN: () => zh_CN_default,
+  zhTW: () => zh_TW_default
 });
 
 // node_modules/zod/v4/locales/ar.js
@@ -10740,7 +10744,7 @@ class JSONSchemaGenerator {
               if (val === undefined) {
                 if (this.unrepresentable === "throw") {
                   throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-                } else {}
+                }
               } else if (typeof val === "bigint") {
                 if (this.unrepresentable === "throw") {
                   throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -11211,14 +11215,14 @@ var exports_json_schema = {};
 // node_modules/zod/v4/classic/iso.js
 var exports_iso = {};
 __export(exports_iso, {
-  time: () => time2,
-  duration: () => duration2,
-  datetime: () => datetime2,
-  date: () => date2,
-  ZodISOTime: () => ZodISOTime,
-  ZodISODuration: () => ZodISODuration,
+  ZodISODate: () => ZodISODate,
   ZodISODateTime: () => ZodISODateTime,
-  ZodISODate: () => ZodISODate
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  date: () => date2,
+  datetime: () => datetime2,
+  duration: () => duration2,
+  time: () => time2
 });
 var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
   $ZodISODateTime.init(inst, def);
@@ -12300,11 +12304,11 @@ var ZodFirstPartyTypeKind;
 // node_modules/zod/v4/classic/coerce.js
 var exports_coerce = {};
 __export(exports_coerce, {
-  string: () => string3,
-  number: () => number3,
-  date: () => date4,
+  bigint: () => bigint3,
   boolean: () => boolean3,
-  bigint: () => bigint3
+  date: () => date4,
+  number: () => number3,
+  string: () => string3
 });
 function string3(params) {
   return _coercedString(ZodString, params);
@@ -12548,6 +12552,8 @@ function resolveDataDir(env, home) {
   return join2(home, ".local", "share", "opencode");
 }
 var cachedPool = null;
+var cachedPending = null;
+var cachedVersion = null;
 function poolFilePath() {
   const override = process.env.OPENCODE_AUTH_LB_DIR;
   const xdg = process.env.XDG_DATA_HOME;
@@ -12558,6 +12564,24 @@ function poolFilePath() {
   cachedPool = { override, xdg, path };
   return path;
 }
+function pendingFilePath() {
+  const override = process.env.OPENCODE_AUTH_LB_DIR;
+  const xdg = process.env.XDG_DATA_HOME;
+  if (cachedPending && cachedPending.override === override && cachedPending.xdg === xdg)
+    return cachedPending.path;
+  const path = join2(resolveDataDir({ override, xdgDataHome: xdg }, homedir()), "auth-load-balancer-pending.json");
+  cachedPending = { override, xdg, path };
+  return path;
+}
+function versionCacheFilePath() {
+  const override = process.env.OPENCODE_AUTH_LB_DIR;
+  const xdg = process.env.XDG_DATA_HOME;
+  if (cachedVersion && cachedVersion.override === override && cachedVersion.xdg === xdg)
+    return cachedVersion.path;
+  const path = join2(resolveDataDir({ override, xdgDataHome: xdg }, homedir()), "auth-load-balancer-cc-version.json");
+  cachedVersion = { override, xdg, path };
+  return path;
+}
 
 // src/pool/store.ts
 function emptyPool() {
@@ -12635,6 +12659,10 @@ function normalizeAccounts(rows) {
     }
     if (!Number.isFinite(row.cooldownUntil))
       row.cooldownUntil = 0;
+    if (row.cooldownKind !== undefined && row.cooldownKind !== "quota" && row.cooldownKind !== "auth" && row.cooldownKind !== "transient")
+      delete row.cooldownKind;
+    if (row.cooldownUntil <= 0)
+      delete row.cooldownKind;
     if (row.modelCooldownsUntil !== undefined) {
       if (!isPlainObject2(row.modelCooldownsUntil)) {
         delete row.modelCooldownsUntil;
@@ -12846,6 +12874,156 @@ async function bootstrapFromOpencodeAuth(providerID, getAuth) {
   });
 }
 
+// src/scheduler/score-core.ts
+var DAY_MS = 24 * 60 * 60 * 1000;
+var WEEK_MS = 7 * DAY_MS;
+var HOUR_MS = 60 * 60 * 1000;
+var HOURLY_WINDOW_MS = 5 * HOUR_MS;
+var RESET_CUSHION_DAYS = 0.25;
+var SCORE_DEFAULTS = {
+  hourlyInfluence: 0.5,
+  minResetMs: 5 * 60 * 1000,
+  weekWindowMs: WEEK_MS,
+  exhaustedAt: 0.999,
+  migrateAt: 0.95,
+  weeklyDrainTarget: 0.98
+};
+function readEnvNumber(env, key, dflt) {
+  const raw = env[key];
+  if (raw === undefined || raw.trim() === "")
+    return dflt;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : dflt;
+}
+function loadScoreConfig(env = process.env) {
+  const num = (key, dflt) => readEnvNumber(env, key, dflt);
+  return {
+    hourlyInfluence: num("OPENCODE_AUTH_LB_HOURLY_INFLUENCE", SCORE_DEFAULTS.hourlyInfluence),
+    minResetMs: num("OPENCODE_AUTH_LB_MIN_RESET_MS", SCORE_DEFAULTS.minResetMs),
+    weekWindowMs: num("OPENCODE_AUTH_LB_WEEK_WINDOW_MS", SCORE_DEFAULTS.weekWindowMs),
+    exhaustedAt: num("OPENCODE_AUTH_LB_EXHAUSTED_AT", SCORE_DEFAULTS.exhaustedAt),
+    migrateAt: num("OPENCODE_AUTH_LB_MIGRATE_AT", SCORE_DEFAULTS.migrateAt),
+    weeklyDrainTarget: num("OPENCODE_AUTH_LB_WEEKLY_DRAIN_TARGET", SCORE_DEFAULTS.weeklyDrainTarget)
+  };
+}
+function clamp012(n) {
+  if (!Number.isFinite(n))
+    return 0;
+  return Math.min(1, Math.max(0, n));
+}
+function isWindowExpired(window, now) {
+  return window.resetAt > 0 && window.resetAt <= now;
+}
+function utilOf(window, now) {
+  if (!window || isWindowExpired(window, now))
+    return 0;
+  return clamp012(window.utilization);
+}
+function displayUtil(window, now) {
+  if (!window)
+    return null;
+  return isWindowExpired(window, now) ? 0 : clamp012(window.utilization);
+}
+function maxUtil(account, now) {
+  return Math.max(utilOf(account.usage.hourly, now), utilOf(account.usage.weekly, now));
+}
+function isExhausted(account, cfg, now) {
+  return maxUtil(account, now) >= cfg.exhaustedAt;
+}
+function isAvailable(account, cfg, now) {
+  if (account.disabledReason)
+    return false;
+  if (account.cooldownUntil > now)
+    return false;
+  if (isExhausted(account, cfg, now))
+    return false;
+  return true;
+}
+function weeklyUrgency(account, cfg, now) {
+  const weekly = account.usage.weekly;
+  const drainable = Math.max(0, cfg.weeklyDrainTarget - utilOf(weekly, now));
+  if (drainable === 0)
+    return 0;
+  const resetAt = weekly?.resetAt ?? 0;
+  const ms = resetAt > now ? resetAt - now : weekly ? resetAt === 0 ? cfg.minResetMs : WEEK_MS - (now - resetAt) % WEEK_MS : cfg.weekWindowMs;
+  const days = Math.max(ms, cfg.minResetMs) / DAY_MS + RESET_CUSHION_DAYS;
+  return drainable / (days * days);
+}
+function scoreAccount(account, cfg, now) {
+  const urgency = weeklyUrgency(account, cfg, now);
+  if (urgency === 0)
+    return 0;
+  const hourly = account.usage.hourly;
+  if (!hourly)
+    return urgency;
+  const hourlyUtil = utilOf(hourly, now);
+  if (hourlyUtil === 0)
+    return urgency;
+  const resetAt = hourly.resetAt;
+  const msToReset = resetAt > now ? resetAt - now : HOURLY_WINDOW_MS;
+  const resetFactor = clamp012(msToReset / HOURLY_WINDOW_MS);
+  const pressure = hourlyUtil * resetFactor;
+  return urgency * (1 - cfg.hourlyInfluence * pressure);
+}
+function compareRanked(x, y) {
+  if (x.available !== y.available)
+    return x.available ? -1 : 1;
+  if (x.available)
+    return y.score - x.score;
+  return x.weeklyUtil - y.weeklyUtil;
+}
+
+// src/pending/recovery.ts
+function exhaustedWindows(account, cfg, now) {
+  const windows = [];
+  const hourly = account.usage.hourly;
+  const weekly = account.usage.weekly;
+  if (hourly && utilOf(hourly, now) >= cfg.exhaustedAt)
+    windows.push(hourly);
+  if (weekly && utilOf(weekly, now) >= cfg.exhaustedAt)
+    windows.push(weekly);
+  return windows;
+}
+function classifyProviderRecovery(accounts, providerID, cfg, now, pollMs) {
+  let hasQuotaCandidate = false;
+  let hasUnknownReset = false;
+  const knownAccountRecoveries = [];
+  for (const account of accounts) {
+    if (account.providerID !== providerID || account.disabledReason)
+      continue;
+    const windows = exhaustedWindows(account, cfg, now);
+    const cooldownActive = account.cooldownUntil > now;
+    if (!cooldownActive && windows.length === 0)
+      return { state: "available" };
+    if (cooldownActive && (account.cooldownKind === "auth" || account.cooldownKind === "transient"))
+      continue;
+    if (cooldownActive && account.cooldownKind === undefined && !windows.length)
+      continue;
+    hasQuotaCandidate = true;
+    const constraints = [];
+    let accountHasUnknownReset = false;
+    for (const window of windows) {
+      if (window.resetAt > now)
+        constraints.push(window.resetAt);
+      else
+        accountHasUnknownReset = true;
+    }
+    if (cooldownActive)
+      constraints.push(account.cooldownUntil);
+    if (accountHasUnknownReset) {
+      hasUnknownReset = true;
+      continue;
+    }
+    knownAccountRecoveries.push(Math.max(...constraints));
+  }
+  if (!hasQuotaCandidate)
+    return { state: "unusable" };
+  const resumeAt = knownAccountRecoveries.length ? Math.min(...knownAccountRecoveries) : null;
+  const pollAt = hasUnknownReset ? now + Math.max(0, pollMs) : Number.POSITIVE_INFINITY;
+  const nextCheckAt = Math.min(resumeAt ?? Number.POSITIVE_INFINITY, pollAt);
+  return { state: "quota-blocked", nextCheckAt, resumeAt };
+}
+
 // src/providers/anthropic/constants.ts
 var PROVIDER_ID = "anthropic";
 var CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
@@ -12880,10 +13058,12 @@ var OPENCODE_IDENTITY_PREFIX = "You are OpenCode";
 var CLAUDE_CODE_IDENTITY = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
 var CCH_SALT = "59cf53e54c78";
 var CCH_POSITIONS = [4, 7, 20];
-var CLAUDE_CODE_VERSION = "2.1.87";
 var CLAUDE_CODE_ENTRYPOINT = "sdk-cli";
-var USER_AGENT = `claude-cli/${CLAUDE_CODE_VERSION} (external, cli)`;
-var USAGE_USER_AGENT = `claude-code/${CLAUDE_CODE_VERSION}`;
+var FALLBACK_CLAUDE_CODE_VERSION = "2.1.258";
+var CLAUDE_CODE_VERSION_ENV = "OPENCODE_AUTH_LB_ANTHROPIC_CLAUDE_CODE_VERSION";
+var CLAUDE_CODE_REGISTRY_URL = "https://registry.npmjs.org/-/package/@anthropic-ai%2Fclaude-code/dist-tags";
+var CLAUDE_CODE_VERSION_TTL_MS = 24 * 60 * 60 * 1000;
+var REGISTRY_HTTP_TIMEOUT_MS = 1e4;
 var PARAGRAPH_REMOVAL_ANCHORS = [
   "github.com/anomalyco/opencode",
   "opencode.ai/docs"
@@ -13033,112 +13213,13 @@ async function ensureAccessToken(adapter, account, now) {
   const existing = inflight.get(account.id);
   if (existing)
     return settleRefresh(adapter, account, existing);
-  const job = runRefresh(adapter, account, now);
-  inflight.set(account.id, job);
-  try {
-    return await settleRefresh(adapter, account, job);
-  } finally {
-    inflight.delete(account.id);
-  }
-}
-
-// src/scheduler/score-core.ts
-var DAY_MS = 24 * 60 * 60 * 1000;
-var WEEK_MS = 7 * DAY_MS;
-var HOUR_MS = 60 * 60 * 1000;
-var HOURLY_WINDOW_MS = 5 * HOUR_MS;
-var RESET_CUSHION_DAYS = 0.25;
-var SCORE_DEFAULTS = {
-  hourlyInfluence: 0.5,
-  minResetMs: 5 * 60 * 1000,
-  weekWindowMs: WEEK_MS,
-  exhaustedAt: 0.999,
-  migrateAt: 0.95,
-  weeklyDrainTarget: 0.98
-};
-function readEnvNumber(env, key, dflt) {
-  const raw = env[key];
-  if (raw === undefined || raw.trim() === "")
-    return dflt;
-  const n = Number(raw);
-  return Number.isFinite(n) ? n : dflt;
-}
-function loadScoreConfig(env = process.env) {
-  const num = (key, dflt) => readEnvNumber(env, key, dflt);
-  return {
-    hourlyInfluence: num("OPENCODE_AUTH_LB_HOURLY_INFLUENCE", SCORE_DEFAULTS.hourlyInfluence),
-    minResetMs: num("OPENCODE_AUTH_LB_MIN_RESET_MS", SCORE_DEFAULTS.minResetMs),
-    weekWindowMs: num("OPENCODE_AUTH_LB_WEEK_WINDOW_MS", SCORE_DEFAULTS.weekWindowMs),
-    exhaustedAt: num("OPENCODE_AUTH_LB_EXHAUSTED_AT", SCORE_DEFAULTS.exhaustedAt),
-    migrateAt: num("OPENCODE_AUTH_LB_MIGRATE_AT", SCORE_DEFAULTS.migrateAt),
-    weeklyDrainTarget: num("OPENCODE_AUTH_LB_WEEKLY_DRAIN_TARGET", SCORE_DEFAULTS.weeklyDrainTarget)
-  };
-}
-function clamp012(n) {
-  if (!Number.isFinite(n))
-    return 0;
-  return Math.min(1, Math.max(0, n));
-}
-function isWindowExpired(window, now) {
-  return window.resetAt > 0 && window.resetAt <= now;
-}
-function utilOf(window, now) {
-  if (!window || isWindowExpired(window, now))
-    return 0;
-  return clamp012(window.utilization);
-}
-function displayUtil(window, now) {
-  if (!window)
-    return null;
-  return isWindowExpired(window, now) ? 0 : clamp012(window.utilization);
-}
-function maxUtil(account, now) {
-  return Math.max(utilOf(account.usage.hourly, now), utilOf(account.usage.weekly, now));
-}
-function isExhausted(account, cfg, now) {
-  return maxUtil(account, now) >= cfg.exhaustedAt;
-}
-function isAvailable(account, cfg, now) {
-  if (account.disabledReason)
-    return false;
-  if (account.cooldownUntil > now)
-    return false;
-  if (isExhausted(account, cfg, now))
-    return false;
-  return true;
-}
-function weeklyUrgency(account, cfg, now) {
-  const weekly = account.usage.weekly;
-  const drainable = Math.max(0, cfg.weeklyDrainTarget - utilOf(weekly, now));
-  if (drainable === 0)
-    return 0;
-  const resetAt = weekly?.resetAt ?? 0;
-  const ms = resetAt > now ? resetAt - now : weekly ? resetAt === 0 ? cfg.minResetMs : WEEK_MS - (now - resetAt) % WEEK_MS : cfg.weekWindowMs;
-  const days = Math.max(ms, cfg.minResetMs) / DAY_MS + RESET_CUSHION_DAYS;
-  return drainable / (days * days);
-}
-function scoreAccount(account, cfg, now) {
-  const urgency = weeklyUrgency(account, cfg, now);
-  if (urgency === 0)
-    return 0;
-  const hourly = account.usage.hourly;
-  if (!hourly)
-    return urgency;
-  const hourlyUtil = utilOf(hourly, now);
-  if (hourlyUtil === 0)
-    return urgency;
-  const resetAt = hourly.resetAt;
-  const msToReset = resetAt > now ? resetAt - now : HOURLY_WINDOW_MS;
-  const resetFactor = clamp012(msToReset / HOURLY_WINDOW_MS);
-  const pressure = hourlyUtil * resetFactor;
-  return urgency * (1 - cfg.hourlyInfluence * pressure);
-}
-function compareRanked(x, y) {
-  if (x.available !== y.available)
-    return x.available ? -1 : 1;
-  if (x.available)
-    return y.score - x.score;
-  return x.weeklyUtil - y.weeklyUtil;
+  const job = runRefresh(adapter, account, now);
+  inflight.set(account.id, job);
+  try {
+    return await settleRefresh(adapter, account, job);
+  } finally {
+    inflight.delete(account.id);
+  }
 }
 
 // src/scheduler/config.ts
@@ -13267,6 +13348,7 @@ function selectForSession(pool, providerID, sessionKey, now, cfg = DEFAULT_CONFI
 // src/session.ts
 import { createHash } from "node:crypto";
 var SESSION_HEADER = "x-allb-session";
+var MESSAGE_HEADER = "x-allb-message";
 function firstUserFromList(list) {
   if (!Array.isArray(list))
     return null;
@@ -13611,6 +13693,101 @@ async function refresh(refreshToken) {
 
 // src/providers/anthropic/cch.ts
 import { createHash as createHash2 } from "node:crypto";
+
+// src/providers/anthropic/version.ts
+import { readFile as readFile3 } from "node:fs/promises";
+
+// src/providers/usage-http.ts
+async function fetchJson(url2, headers, timeoutMs) {
+  let response;
+  try {
+    response = await fetch(url2, {
+      headers,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch {
+    return null;
+  }
+  if (!response.ok) {
+    await response.body?.cancel().catch(ignore);
+    return null;
+  }
+  return await response.json().catch(() => null);
+}
+
+// src/providers/anthropic/version.ts
+var VERSION_RE = /^\d+\.\d+\.\d+$/;
+function compareVersions2(a, b) {
+  const left = a.split(".");
+  const right = b.split(".");
+  for (let i = 0;i < 3; i++) {
+    const delta = Number(left[i]) - Number(right[i]);
+    if (delta !== 0)
+      return delta;
+  }
+  return 0;
+}
+var current = FALLBACK_CLAUDE_CODE_VERSION;
+function adopt(candidate) {
+  const trimmed = candidate.trim();
+  if (!VERSION_RE.test(trimmed))
+    return;
+  if (compareVersions2(trimmed, current) <= 0)
+    return;
+  current = trimmed;
+}
+function envOverride() {
+  const raw = process.env[CLAUDE_CODE_VERSION_ENV]?.trim();
+  return raw && VERSION_RE.test(raw) ? raw : undefined;
+}
+function claudeCodeVersion() {
+  return envOverride() ?? current;
+}
+function userAgent() {
+  return `claude-cli/${claudeCodeVersion()} (external, cli)`;
+}
+function usageUserAgent() {
+  return `claude-code/${claudeCodeVersion()}`;
+}
+async function readCache() {
+  let text;
+  try {
+    text = await readFile3(versionCacheFilePath(), "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (!isPlainObject2(parsed))
+      return null;
+    const { version: version2, fetchedAt } = parsed;
+    if (typeof version2 !== "string" || !Number.isFinite(fetchedAt))
+      return null;
+    return { version: version2, fetchedAt };
+  } catch {
+    return null;
+  }
+}
+async function refreshClaudeCodeVersion(now) {
+  const tags = await fetchJson(CLAUDE_CODE_REGISTRY_URL, { accept: "application/json" }, REGISTRY_HTTP_TIMEOUT_MS);
+  if (!isPlainObject2(tags) || typeof tags.latest !== "string")
+    return;
+  adopt(tags.latest);
+  await writeJsonAtomic(versionCacheFilePath(), JSON.stringify({ version: current, fetchedAt: now })).catch(ignore);
+}
+async function primeClaudeCodeVersion(now) {
+  if (envOverride())
+    return;
+  const cached2 = await readCache();
+  if (cached2) {
+    adopt(cached2.version);
+    if (now - cached2.fetchedAt < CLAUDE_CODE_VERSION_TTL_MS)
+      return;
+  }
+  refreshClaudeCodeVersion(now).catch(ignore);
+}
+
+// src/providers/anthropic/cch.ts
 function messageText({ content }) {
   if (typeof content === "string")
     return content;
@@ -13625,7 +13802,7 @@ function messageText({ content }) {
 function computeCCH(messageText2) {
   return createHash2("sha256").update(messageText2).digest("hex").slice(0, 5);
 }
-function computeVersionSuffix(text, version2 = CLAUDE_CODE_VERSION) {
+function computeVersionSuffix(text, version2 = claudeCodeVersion()) {
   const chars = CCH_POSITIONS.map((index) => text[index] || "0").join("");
   return createHash2("sha256").update(`${CCH_SALT}${chars}${version2}`).digest("hex").slice(0, 3);
 }
@@ -13642,13 +13819,14 @@ function buildBillingHeaderValue(messages, entrypoint) {
   if (!userMsg)
     return null;
   const text = messageText(userMsg);
-  const key = `${entrypoint}\x00${text}`;
+  const version2 = claudeCodeVersion();
+  const key = `${version2}\x00${entrypoint}\x00${text}`;
   const hit = cachedHeader.get(key);
   if (hit !== undefined)
     return hit;
-  const suffix = computeVersionSuffix(text);
+  const suffix = computeVersionSuffix(text, version2);
   const cch = computeCCH(text);
-  const value = "x-anthropic-billing-header: " + `cc_version=${CLAUDE_CODE_VERSION}.${suffix}; ` + `cc_entrypoint=${entrypoint}; ` + `cch=${cch};`;
+  const value = "x-anthropic-billing-header: " + `cc_version=${version2}.${suffix}; ` + `cc_entrypoint=${entrypoint}; ` + `cch=${cch};`;
   setBounded(cachedHeader, key, value, CACHED_HEADER_MAX);
   return value;
 }
@@ -13676,7 +13854,7 @@ function mergeBetaHeaders(headers) {
 function setOAuthHeaders(headers, accessToken) {
   headers.set("authorization", `Bearer ${accessToken}`);
   headers.set("anthropic-beta", mergeBetaHeaders(headers));
-  headers.set("user-agent", USER_AGENT);
+  headers.set("user-agent", userAgent());
   headers.delete("x-api-key");
 }
 function prefixToolNames(parsed) {
@@ -13900,24 +14078,6 @@ function endpointWindowFrom(w, utilOf2, divisor, resetOf) {
   return { utilization: clamp01(util / divisor), resetAt: resetOf(w) };
 }
 
-// src/providers/usage-http.ts
-async function fetchUsageJson(url2, headers, timeoutMs) {
-  let response;
-  try {
-    response = await fetch(url2, {
-      headers,
-      signal: AbortSignal.timeout(timeoutMs)
-    });
-  } catch {
-    return null;
-  }
-  if (!response.ok) {
-    await response.body?.cancel().catch(ignore);
-    return null;
-  }
-  return await response.json().catch(() => null);
-}
-
 // src/providers/anthropic/usage.ts
 var HEADER_SPEC = {
   hourlyUtil: "anthropic-ratelimit-unified-5h-utilization",
@@ -13950,10 +14110,10 @@ function endpointWindow(w) {
   return endpointWindowFrom(w, (win) => win.utilization, 100, (win) => parseResetAt(win.resets_at));
 }
 async function fetchUsage(account, now) {
-  const json2 = await fetchUsageJson(USAGE_URL, {
+  const json2 = await fetchJson(USAGE_URL, {
     authorization: `Bearer ${account.access}`,
     "anthropic-beta": "oauth-2025-04-20",
-    "user-agent": USAGE_USER_AGENT,
+    "user-agent": usageUserAgent(),
     "content-type": "application/json"
   }, USAGE_HTTP_TIMEOUT_MS);
   if (!json2)
@@ -13982,6 +14142,7 @@ var anthropicAdapter = {
   parseUsageHeaders,
   fetchUsage,
   classifyError: classifyHttpStatus,
+  prime: primeClaudeCodeVersion,
   requestModelTier,
   planModelFallback: downgradeModel,
   planReactiveFallback
@@ -13997,10 +14158,10 @@ var REDIRECT_URI = "http://localhost:1455/auth/callback";
 var OAUTH_SCOPES2 = ["openid", "profile", "email", "offline_access"];
 var CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
 var USAGE_URL2 = "https://chatgpt.com/backend-api/wham/usage";
-var USAGE_USER_AGENT2 = "codex-cli";
+var USAGE_USER_AGENT = "codex-cli";
 var ORIGINATOR = "opencode";
 var OPENAI_BETA = "responses=experimental";
-var USER_AGENT2 = `opencode/0.2.0 (${platform()} ${release()}; ${arch()})`;
+var USER_AGENT = `opencode/0.2.0 (${platform()} ${release()}; ${arch()})`;
 var SESSION_ID = crypto.randomUUID();
 
 // src/providers/openai/jwt.ts
@@ -14119,7 +14280,7 @@ function applyAuth(headers, account) {
     headers.set("chatgpt-account-id", accountId);
   headers.set("openai-beta", OPENAI_BETA);
   headers.set("originator", ORIGINATOR);
-  headers.set("user-agent", USER_AGENT2);
+  headers.set("user-agent", USER_AGENT);
   headers.set("session-id", SESSION_ID);
 }
 function rewriteUrl2(input) {
@@ -14207,13 +14368,13 @@ function endpointWindow2(w) {
 async function fetchUsage2(account, now) {
   const headers = {
     authorization: `Bearer ${account.access}`,
-    "user-agent": USAGE_USER_AGENT2,
+    "user-agent": USAGE_USER_AGENT,
     accept: "application/json"
   };
   const accountId = resolveAccountId(account);
   if (accountId)
     headers["chatgpt-account-id"] = accountId;
-  const json2 = await fetchUsageJson(USAGE_URL2, headers, USAGE_HTTP_TIMEOUT_MS);
+  const json2 = await fetchJson(USAGE_URL2, headers, USAGE_HTTP_TIMEOUT_MS);
   const rateLimit = json2?.rate_limit;
   if (!isPlainObject2(rateLimit))
     return null;
@@ -14256,7 +14417,7 @@ function adapterFor(adapters, providerID) {
 }
 
 // src/usage-refresh.ts
-var SEED_TTL_MS = 5 * 60 * 1000;
+var USAGE_REFRESH_TTL_MS = 5 * 60 * 1000;
 var MAX_TRANSIENT_COOLDOWN_MS = 5 * 60 * 1000;
 var lastPoll = new Map;
 async function refreshUsage(adapters, now, poolSnapshot) {
@@ -14267,12 +14428,12 @@ async function refreshUsage(adapters, now, poolSnapshot) {
     aliveIds?.add(account.id);
     if (account.disabledReason)
       continue;
-    if (account.usage.capturedAt !== 0 && now - account.usage.capturedAt <= SEED_TTL_MS)
+    if (account.usage.capturedAt !== 0 && now - account.usage.capturedAt <= USAGE_REFRESH_TTL_MS)
       continue;
     const adapter = adapterFor(adapters, account.providerID);
     if (!adapter)
       continue;
-    if ((lastPoll.get(account.id) ?? 0) > now - SEED_TTL_MS)
+    if ((lastPoll.get(account.id) ?? 0) > now - USAGE_REFRESH_TTL_MS)
       continue;
     lastPoll.set(account.id, now);
     stale ??= [];
@@ -14299,8 +14460,10 @@ async function refreshUsage(adapters, now, poolSnapshot) {
               weekly: snapshot.weekly === null ? stored.usage.weekly : preserveWeeklyAnchor(snapshot.weekly, stored.usage.weekly, now),
               capturedAt: snapshot.weekly === null ? stored.usage.capturedAt : now
             };
-            if (snapshot.weekly !== null && stored.cooldownUntil > now + MAX_TRANSIENT_COOLDOWN_MS && !isExhausted(stored, scoreCfg, now))
+            if (snapshot.weekly !== null && stored.cooldownUntil > now + MAX_TRANSIENT_COOLDOWN_MS && !isExhausted(stored, scoreCfg, now)) {
               stored.cooldownUntil = 0;
+              delete stored.cooldownKind;
+            }
           }
         });
       }
@@ -14359,15 +14522,17 @@ function cooldownUntilFrom(res, fallbackMs, now) {
   }
   return until;
 }
-async function applyCooldown(accountId, fallbackMs) {
+async function applyCooldown(accountId, fallbackMs, kind) {
   const until = cooldownUntilFrom(null, fallbackMs, Date.now());
   await bestEffort("cooldown", () => mutatePool((pool) => {
     const account = findAccount(pool, accountId);
-    if (account)
-      account.cooldownUntil = Math.max(account.cooldownUntil, until);
+    if (account && until >= account.cooldownUntil) {
+      account.cooldownUntil = until;
+      account.cooldownKind = kind;
+    }
   }));
 }
-async function recordRotation(adapter, accountId, res, fallbackMs, now) {
+async function recordRotation(adapter, accountId, res, fallbackMs, now, kind) {
   const partial2 = adapter.parseUsageHeaders(res.headers);
   const until = cooldownUntilFrom(res, fallbackMs, now);
   await bestEffort("rotation", () => mutatePool((pool) => {
@@ -14376,7 +14541,10 @@ async function recordRotation(adapter, accountId, res, fallbackMs, now) {
       return;
     if (partial2)
       applyUsagePartial(account, partial2, now);
-    account.cooldownUntil = Math.max(account.cooldownUntil, until);
+    if (until >= account.cooldownUntil) {
+      account.cooldownUntil = until;
+      account.cooldownKind = kind;
+    }
   }));
 }
 async function recordModelCooldown(accountId, tier, until, partial2, now) {
@@ -14396,8 +14564,10 @@ async function recordSuccess(adapter, accountId, partial2, sessionKey, now, cfg,
     if (account) {
       if (partial2)
         applyUsagePartial(account, partial2, now);
-      if (partial2 && account.cooldownUntil > now + ACCOUNT_COOLDOWN_MS && !isExhausted(account, cfg, now))
+      if (partial2 && account.cooldownUntil > now + ACCOUNT_COOLDOWN_MS && !isExhausted(account, cfg, now)) {
         account.cooldownUntil = 0;
+        delete account.cooldownKind;
+      }
       pool.lastSelected[adapter.id] = accountId;
     }
     if (sessionKey) {
@@ -14438,15 +14608,24 @@ function soonestCooldownUntil(accounts, now, accountIds) {
   }
   return Number.isFinite(soonest) ? soonest : null;
 }
-function createLoadBalancedFetch(adapter, hooks = {}, models = []) {
+function createLoadBalancedFetch(adapter, hooks = {}, models = [], pending) {
   const cfg = loadConfig();
   return async (input, init) => {
     const bodyStr = typeof init?.body === "string" ? init.body : undefined;
     const baseHeaders = mergeHeaders(input, init);
+    const sessionID = baseHeaders.get(SESSION_HEADER);
+    const messageID = baseHeaders.get(MESSAGE_HEADER);
+    const pendingRef = pending && sessionID && messageID ? {
+      workspace: pending.workspace,
+      providerID: adapter.id,
+      sessionID,
+      messageID
+    } : null;
     const signal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
     const baseKey = deriveSessionKey(baseHeaders, bodyStr);
     const sessionKey = baseKey ? `${adapter.id}:${baseKey}` : null;
     baseHeaders.delete(SESSION_HEADER);
+    baseHeaders.delete(MESSAGE_HEADER);
     const tried = new Set;
     let waitableCooldownIds = null;
     let lastError = null;
@@ -14481,10 +14660,26 @@ function createLoadBalancedFetch(adapter, hooks = {}, models = []) {
         usageSeeded = true;
         refreshAllUsageInBackground(now, pool).catch(ignore);
       }
+      if (pendingRef && pending) {
+        const recovery = classifyProviderRecovery(pool.accounts, adapter.id, cfg, now, USAGE_REFRESH_TTL_MS);
+        if (recovery.state === "quota-blocked") {
+          const result = await pending.waitForCapacity(pendingRef, recovery, signal);
+          if (result === "unusable") {
+            await pending.complete(pendingRef).catch(ignore);
+            return noUsableAccountResponse(adapter.id);
+          }
+          tried.clear();
+          waitableCooldownIds?.clear();
+          continue;
+        }
+      }
       const selection = selectForSession(pool, adapter.id, sessionKey, now, cfg, tried, requestBytes);
       if (!selection) {
-        if (tried.size === 0)
+        if (tried.size === 0) {
+          if (pendingRef && pending)
+            await pending.complete(pendingRef).catch(ignore);
           return noUsableAccountResponse(adapter.id);
+        }
         if (pendingTierFallback !== null) {
           const adopted = pendingTierFallback;
           pendingTierFallback = null;
@@ -14558,7 +14753,7 @@ function createLoadBalancedFetch(adapter, hooks = {}, models = []) {
             }
           }
           const ms = cls === "auth" ? AUTH_COOLDOWN_MS : ACCOUNT_COOLDOWN_MS;
-          await recordRotation(adapter, account.id, res, ms, Date.now());
+          await recordRotation(adapter, account.id, res, ms, Date.now(), cls === "auth" ? "auth" : "quota");
           if (cls === "account") {
             waitableCooldownIds ??= new Set;
             waitableCooldownIds.add(account.id);
@@ -14576,19 +14771,26 @@ function createLoadBalancedFetch(adapter, hooks = {}, models = []) {
           hooks.onModelFallback?.(adapter.id, account, fallbackInfo.fromModel, fallbackInfo.toModel, fallbackInfo.fromTier);
         hooks.onUse?.(adapter.id, account);
         await recordSuccess(adapter, account.id, partial2, sessionKey, successNow, cfg, fallbackInfo);
+        if (pendingRef && pending)
+          await pending.complete(pendingRef).catch(ignore);
         return adapter.transformResponse(res);
       } catch (error45) {
         lastError = error45;
         const aborted2 = signal?.aborted === true || error45 instanceof Error && error45.name === "AbortError";
-        if (aborted2)
+        if (aborted2) {
+          if (pendingRef && pending)
+            await pending.abort(pendingRef).catch(ignore);
           throw error45;
+        }
         if (!account.disabledReason)
-          await applyCooldown(account.id, AUTH_COOLDOWN_MS);
+          await applyCooldown(account.id, AUTH_COOLDOWN_MS, "transient");
         if (DEBUG)
           log(`!! ${account.label} threw: ${error45 instanceof Error ? error45.message : String(error45)}`);
         continue;
       }
     }
+    if (pendingRef && pending)
+      await pending.complete(pendingRef).catch(ignore);
     throw lastError ?? new Error(`${adapter.id}: no usable account in the load-balancer pool`);
   };
 }
@@ -14607,7 +14809,7 @@ function byProviderId(a, b) {
 function isExpired(window, now) {
   return !!window && window.resetAt > 0 && window.resetAt <= now;
 }
-function toStatus(account, now, current, available, rank) {
+function toStatus(account, now, current2, available, rank) {
   const weekly = account.usage.weekly;
   const weeklyExpired = isExpired(weekly, now);
   return {
@@ -14620,7 +14822,7 @@ function toStatus(account, now, current, available, rank) {
     cooldownUntil: account.cooldownUntil,
     modelCooldownsUntil: account.modelCooldownsUntil ?? {},
     disabledReason: account.disabledReason,
-    current,
+    current: current2,
     rank
   };
 }
@@ -14695,13 +14897,40 @@ function stateOf(a, now) {
 function providerName(providerID) {
   return PROVIDER_NAMES[providerID] ?? providerID;
 }
+function renderPendingStatus(turns, now = Date.now()) {
+  if (turns.length === 0)
+    return "";
+  const grouped = new Map;
+  for (const turn of turns) {
+    let group = grouped.get(turn.providerID);
+    if (!group) {
+      group = { sessions: new Set, resumeAt: [], nextCheckAt: [] };
+      grouped.set(turn.providerID, group);
+    }
+    group.sessions.add(turn.sessionID);
+    if (turn.resumeAt !== null)
+      group.resumeAt.push(turn.resumeAt);
+    group.nextCheckAt.push(turn.nextCheckAt);
+  }
+  const groups = [...grouped.entries()].sort(([a], [b]) => compareAscii(a, b));
+  const width = groups.reduce((max, [providerID]) => Math.max(max, displayWidth(providerName(providerID))), 0);
+  const pendingTime = (at) => at <= now ? "now" : relTime(at, now);
+  const lines = ["Pending turns"];
+  for (const [providerID, group] of groups) {
+    const count = group.sessions.size;
+    const timing = group.resumeAt.length ? `nearest recovery ${pendingTime(Math.min(...group.resumeAt))}` : `checking again ${pendingTime(Math.min(...group.nextCheckAt))}`;
+    lines.push(`  ${padDisplayEnd(providerName(providerID), width)}  ${count} session${count === 1 ? "" : "s"} · ${timing}`);
+  }
+  return lines.join(`
+`);
+}
 function renderStatus(providers, now = Date.now()) {
   if (providers.length === 0)
     return "auth-load-balancer: no accounts registered.";
   const lines = [];
   for (const p of providers) {
-    const current = p.accounts.find((a) => a.current);
-    lines.push(`${providerName(p.providerID)} — in use: ${current ? current.label : "(none yet)"}`);
+    const current2 = p.accounts.find((a) => a.current);
+    lines.push(`${providerName(p.providerID)} — in use: ${current2 ? current2.label : "(none yet)"}`);
     const width = p.accounts.reduce((w, a) => Math.max(w, displayWidth(a.label)), 16);
     lines.push(`  #  ${"account".padEnd(width + 3)}weekly   5h   resets   state`);
     for (const a of p.accounts) {
@@ -14759,6 +14988,538 @@ async function notifyModelFallback(client, providerID, account, fromModel, toMod
     duration: 6000
   });
 }
+function pendingDate(at) {
+  const date5 = new Date(at);
+  const months = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ];
+  const month = months[date5.getMonth()] ?? "";
+  const hour = String(date5.getHours()).padStart(2, "0");
+  const minute = String(date5.getMinutes()).padStart(2, "0");
+  return `${month} ${date5.getDate()}, ${hour}:${minute}`;
+}
+async function notifyPending(client, providerID, recovery, now = Date.now()) {
+  const provider = providerName(providerID);
+  const message = recovery.resumeAt === null ? `${provider} usage exhausted — checking again in ${Math.max(1, Math.round((recovery.nextCheckAt - now) / 60000))}m (Esc to cancel)` : `${provider} usage exhausted — pending until ${pendingDate(recovery.resumeAt)} (Esc to cancel)`;
+  await postToast(client, {
+    title: `${provider} request pending`,
+    message,
+    variant: "warning",
+    duration: 8000
+  });
+}
+async function notifyPendingResumed(client, providerID) {
+  const provider = providerName(providerID);
+  await postToast(client, {
+    title: `${provider} request resumed`,
+    message: `${provider} usage recovered — resuming request`,
+    variant: "success",
+    duration: 5000
+  });
+}
+async function notifyPendingRestored(client, providerID, count) {
+  const provider = providerName(providerID);
+  await postToast(client, {
+    title: `${provider} pending restored`,
+    message: `Restored ${count} pending ${provider} session${count === 1 ? "" : "s"}`,
+    variant: "info",
+    duration: 6000
+  });
+}
+var restoreErrorsToasted = new Map;
+async function notifyPendingRestoreError(client, providerID, messageID) {
+  const key = `${providerID}:${messageID}`;
+  if (restoreErrorsToasted.has(key))
+    return;
+  setBounded(restoreErrorsToasted, key, true, 256);
+  const provider = providerName(providerID);
+  await postToast(client, {
+    title: `${provider} pending restore`,
+    message: `Could not restore a pending ${provider} request yet — retrying automatically`,
+    variant: "error",
+    duration: 8000
+  });
+}
+
+// src/pending/lease.ts
+var DEFAULT_PENDING_LEASE = {
+  staleMs: 30000,
+  timeoutMs: 0,
+  retryMs: 25,
+  heartbeatMs: 5000
+};
+function pendingLeasePath(key) {
+  return `${pendingFilePath()}.${key}.lease`;
+}
+function acquirePendingLease(key, options = DEFAULT_PENDING_LEASE) {
+  return acquireLock(pendingLeasePath(key), options);
+}
+
+// src/pending/store.ts
+import { createHash as createHash3 } from "node:crypto";
+import { readFile as readFile4 } from "node:fs/promises";
+var PENDING_WRITE_LOCK = {
+  staleMs: 30000,
+  timeoutMs: 30000,
+  retryMs: 25,
+  heartbeatMs: 5000
+};
+function emptyPending() {
+  return { version: 1, turns: [] };
+}
+
+class PendingReadError extends Error {
+  path;
+  reason;
+  constructor(path, reason) {
+    super(`Failed to read pending-turn file: ${path}`);
+    this.path = path;
+    this.reason = reason;
+    this.name = "PendingReadError";
+  }
+}
+function pendingKey(ref) {
+  return createHash3("sha256").update(JSON.stringify([
+    ref.workspace,
+    ref.providerID,
+    ref.sessionID,
+    ref.messageID
+  ])).digest("hex");
+}
+function finiteNonNegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function normalizeTurn(value) {
+  if (!isPlainObject2(value))
+    return null;
+  const row = value;
+  if (typeof row.workspace !== "string" || typeof row.providerID !== "string" || typeof row.sessionID !== "string" || typeof row.messageID !== "string" || !finiteNonNegative(row.createdAt) || !finiteNonNegative(row.updatedAt) || !finiteNonNegative(row.nextCheckAt) || row.resumeAt !== null && !finiteNonNegative(row.resumeAt))
+    return null;
+  const ref = {
+    workspace: row.workspace,
+    providerID: row.providerID,
+    sessionID: row.sessionID,
+    messageID: row.messageID
+  };
+  return {
+    ...ref,
+    key: pendingKey(ref),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    nextCheckAt: row.nextCheckAt,
+    resumeAt: row.resumeAt
+  };
+}
+async function readRaw2() {
+  let text;
+  try {
+    text = await readFile4(pendingFilePath(), "utf8");
+  } catch (error45) {
+    if (error45.code === "ENOENT")
+      return emptyPending();
+    throw new PendingReadError(pendingFilePath(), error45);
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (!isPlainObject2(parsed) || parsed.version !== 1 || !Array.isArray(parsed.turns))
+      return emptyPending();
+    const turns = [];
+    const positions = new Map;
+    for (const value of parsed.turns) {
+      const turn = normalizeTurn(value);
+      if (!turn)
+        continue;
+      const position = positions.get(turn.key);
+      if (position === undefined) {
+        positions.set(turn.key, turns.length);
+        turns.push(turn);
+        continue;
+      }
+      const existing = turns[position];
+      if (!existing)
+        continue;
+      const createdAt = Math.min(existing.createdAt, turn.createdAt);
+      if (turn.updatedAt > existing.updatedAt)
+        turns[position] = { ...turn, createdAt };
+      else
+        existing.createdAt = createdAt;
+    }
+    return { version: 1, turns };
+  } catch {
+    return emptyPending();
+  }
+}
+async function writeRaw2(file2) {
+  await writeJsonAtomic(pendingFilePath(), JSON.stringify(file2, null, 2));
+}
+var chain2 = Promise.resolve();
+function withProcessLock(fn) {
+  const run = chain2.then(fn, fn);
+  chain2 = run.then(ignore, ignore);
+  return run;
+}
+function pendingLockDir() {
+  return `${pendingFilePath()}.lock`;
+}
+async function readPending() {
+  return withProcessLock(readRaw2);
+}
+async function mutatePending(fn) {
+  return withProcessLock(() => withLock(pendingLockDir(), PENDING_WRITE_LOCK, async () => {
+    const file2 = await readRaw2();
+    const result = await fn(file2);
+    await writeRaw2(file2);
+    return result;
+  }));
+}
+async function upsertPending(ref, schedule) {
+  return mutatePending((file2) => {
+    const key = pendingKey(ref);
+    const existing = file2.turns.find((turn2) => turn2.key === key);
+    const turn = {
+      ...ref,
+      key,
+      createdAt: existing?.createdAt ?? schedule.now,
+      updatedAt: schedule.now,
+      nextCheckAt: schedule.nextCheckAt,
+      resumeAt: schedule.resumeAt
+    };
+    if (existing)
+      Object.assign(existing, turn);
+    else
+      file2.turns.push(turn);
+    return existing ?? turn;
+  });
+}
+async function removePending(refOrKey) {
+  const key = typeof refOrKey === "string" ? refOrKey : pendingKey(refOrKey);
+  return mutatePending((file2) => {
+    const before = file2.turns.length;
+    file2.turns = file2.turns.filter((turn) => turn.key !== key);
+    return file2.turns.length !== before;
+  });
+}
+async function removePendingSession(workspace, sessionID) {
+  return mutatePending((file2) => {
+    const before = file2.turns.length;
+    file2.turns = file2.turns.filter((turn) => turn.workspace !== workspace || turn.sessionID !== sessionID);
+    return before - file2.turns.length;
+  });
+}
+async function listPendingForWorkspace(workspace, providerID) {
+  const file2 = await readPending();
+  return file2.turns.filter((turn) => turn.workspace === workspace && (providerID === undefined || turn.providerID === providerID));
+}
+
+// src/pending/coordinator.ts
+var disposedError = () => new Error("OpenCode plugin disposed");
+
+class PendingCoordinator {
+  workspace;
+  providerID;
+  adapter;
+  config;
+  dependencies;
+  leases = new Map;
+  acquiring = new Map;
+  active = new Map;
+  restoring = new Map;
+  pendingToasts = new Map;
+  disposing = false;
+  constructor(options) {
+    this.workspace = options.workspace;
+    this.providerID = options.adapter.id;
+    this.adapter = options.adapter;
+    this.config = options.config;
+    this.dependencies = {
+      now: Date.now,
+      sleep: sleepAbortable,
+      readPool,
+      refreshUsage: refreshUsageInBackground.bind(null, this.adapter),
+      upsert: upsertPending,
+      remove: removePending,
+      acquireLease: acquirePendingLease,
+      list: listPendingForWorkspace,
+      removeSession: removePendingSession,
+      onPending: ignore,
+      onResumed: ignore,
+      onRestored: ignore,
+      onRestoreError: ignore,
+      ...options.dependencies
+    };
+  }
+  async ensureLease(key) {
+    if (this.leases.has(key))
+      return;
+    let acquisition = this.acquiring.get(key);
+    if (!acquisition) {
+      acquisition = this.dependencies.acquireLease(key);
+      this.acquiring.set(key, acquisition);
+    }
+    try {
+      const handle = await acquisition;
+      this.leases.set(key, handle);
+    } finally {
+      this.acquiring.delete(key);
+    }
+  }
+  async releaseLease(key) {
+    const handle = this.leases.get(key);
+    if (!handle)
+      return;
+    this.leases.delete(key);
+    await handle.release();
+  }
+  async notifyPending(ref, recovery) {
+    const key = pendingKey(ref);
+    const signature = recovery.resumeAt?.toString() ?? "unknown";
+    if (this.pendingToasts.get(key) === signature)
+      return;
+    this.pendingToasts.set(key, signature);
+    await Promise.resolve(this.dependencies.onPending(ref, recovery)).catch(ignore);
+  }
+  async clear(ref) {
+    const key = pendingKey(ref);
+    try {
+      await this.dependencies.remove(ref);
+      this.pendingToasts.delete(key);
+    } finally {
+      await this.releaseLease(key);
+    }
+  }
+  async waitForCapacity(ref, initial, outerSignal) {
+    const key = pendingKey(ref);
+    if (this.disposing)
+      throw disposedError();
+    await this.ensureLease(key);
+    try {
+      await this.dependencies.upsert(ref, {
+        now: this.dependencies.now(),
+        nextCheckAt: initial.nextCheckAt,
+        resumeAt: initial.resumeAt
+      });
+    } catch (error45) {
+      await this.releaseLease(key);
+      throw error45;
+    }
+    if (this.disposing) {
+      await this.releaseLease(key);
+      throw disposedError();
+    }
+    const controller = new AbortController;
+    const forwardAbort = () => controller.abort(outerSignal?.reason);
+    if (outerSignal?.aborted)
+      forwardAbort();
+    else
+      outerSignal?.addEventListener("abort", forwardAbort, { once: true });
+    this.active.set(controller, ref);
+    let recovery = initial;
+    await this.notifyPending(ref, recovery);
+    try {
+      for (;; ) {
+        await this.dependencies.sleep(Math.max(0, recovery.nextCheckAt - this.dependencies.now()), controller.signal);
+        const now = this.dependencies.now();
+        await this.dependencies.refreshUsage(now).catch(ignore);
+        let next;
+        try {
+          const pool = await this.dependencies.readPool();
+          next = classifyProviderRecovery(pool.accounts, this.providerID, this.config, now, USAGE_REFRESH_TTL_MS);
+        } catch {
+          next = {
+            state: "quota-blocked",
+            nextCheckAt: now + USAGE_REFRESH_TTL_MS,
+            resumeAt: recovery.resumeAt
+          };
+        }
+        if (next.state === "available") {
+          await Promise.resolve(this.dependencies.onResumed(ref)).catch(ignore);
+          return "available";
+        }
+        if (next.state === "unusable") {
+          await this.clear(ref);
+          return "unusable";
+        }
+        recovery = next;
+        await this.dependencies.upsert(ref, {
+          now,
+          nextCheckAt: recovery.nextCheckAt,
+          resumeAt: recovery.resumeAt
+        }).catch(ignore);
+        await this.notifyPending(ref, recovery);
+      }
+    } catch (error45) {
+      if (controller.signal.aborted) {
+        if (this.disposing)
+          await this.releaseLease(key);
+        else
+          await this.clear(ref);
+      } else {
+        await this.releaseLease(key);
+      }
+      throw error45;
+    } finally {
+      outerSignal?.removeEventListener("abort", forwardAbort);
+      this.active.delete(controller);
+    }
+  }
+  async complete(ref) {
+    const key = pendingKey(ref);
+    if (!this.leases.has(key) && !this.pendingToasts.has(key))
+      return;
+    await this.clear(ref);
+  }
+  async abort(ref) {
+    const key = pendingKey(ref);
+    if (!this.leases.has(key) && !this.pendingToasts.has(key))
+      return;
+    if (this.disposing) {
+      this.pendingToasts.delete(key);
+      await this.releaseLease(key);
+      return;
+    }
+    await this.clear(ref);
+  }
+  async restoreOnce(turn, client) {
+    const message = await client.session.message({
+      path: { id: turn.sessionID, messageID: turn.messageID },
+      query: { directory: this.workspace }
+    });
+    if (message.response?.status === 404) {
+      await this.clear(turn);
+      return;
+    }
+    if (message.error !== undefined)
+      throw new Error(`Failed to read pending message ${turn.messageID}`);
+    const info = message.data?.info;
+    if (!info || info.role !== "user" || info.id !== turn.messageID || info.sessionID !== turn.sessionID || info.model.providerID !== turn.providerID) {
+      await this.clear(turn);
+      return;
+    }
+    const history = await client.session.messages({
+      path: { id: turn.sessionID },
+      query: { directory: this.workspace }
+    });
+    if (history.response?.status === 404) {
+      await this.clear(turn);
+      return;
+    }
+    if (history.error !== undefined || !history.data)
+      throw new Error(`Failed to read pending session ${turn.sessionID}`);
+    const completed = history.data.some((entry) => entry.info.role === "assistant" && entry.info.parentID === turn.messageID && typeof entry.info.finish === "string" && entry.info.finish.length > 0 && entry.info.error === undefined);
+    if (completed) {
+      await this.clear(turn);
+      return;
+    }
+    const prompt = await client.session.prompt({
+      path: { id: turn.sessionID },
+      query: { directory: this.workspace },
+      body: {
+        messageID: info.id,
+        model: info.model,
+        agent: info.agent,
+        ...info.system === undefined ? {} : { system: info.system },
+        ...info.tools === undefined ? {} : { tools: info.tools },
+        parts: []
+      }
+    });
+    if (prompt.response?.status === 404) {
+      await this.clear(turn);
+      return;
+    }
+    if (prompt.error !== undefined)
+      throw new Error(`Failed to restore pending message ${turn.messageID}`);
+  }
+  async restoreWithRetry(original, client) {
+    const controller = new AbortController;
+    this.active.set(controller, original);
+    let backoffMs = 1000;
+    try {
+      for (;; ) {
+        if (this.disposing)
+          return;
+        try {
+          const current2 = (await this.dependencies.list(this.workspace, this.providerID)).find((turn) => turn.key === original.key);
+          if (!current2)
+            return;
+          await this.ensureLease(current2.key);
+          try {
+            await this.restoreOnce(current2, client);
+            return;
+          } finally {
+            await this.releaseLease(current2.key);
+          }
+        } catch (error45) {
+          if (this.disposing || controller.signal.aborted)
+            return;
+          await Promise.resolve(this.dependencies.onRestoreError(original, error45)).catch(ignore);
+          try {
+            await this.dependencies.sleep(backoffMs, controller.signal);
+          } catch (sleepError) {
+            if (this.disposing || controller.signal.aborted)
+              return;
+            throw sleepError;
+          }
+          backoffMs = Math.min(backoffMs * 2, 60000);
+        }
+      }
+    } finally {
+      this.active.delete(controller);
+    }
+  }
+  async restore(client) {
+    if (this.disposing)
+      return;
+    const turns = (await this.dependencies.list(this.workspace, this.providerID)).filter((turn) => turn.workspace === this.workspace && turn.providerID === this.providerID);
+    if (turns.length === 0)
+      return;
+    await Promise.resolve(this.dependencies.onRestored(turns.length)).catch(ignore);
+    const tasks = turns.map((turn) => {
+      const existing = this.restoring.get(turn.key);
+      if (existing)
+        return existing;
+      const task = this.restoreWithRetry(turn, client);
+      this.restoring.set(turn.key, task);
+      task.finally(() => {
+        if (this.restoring.get(turn.key) === task)
+          this.restoring.delete(turn.key);
+      }).catch(ignore);
+      return task;
+    });
+    await Promise.allSettled(tasks);
+  }
+  async removeSession(sessionID) {
+    const turns = (await this.dependencies.list(this.workspace)).filter((turn) => turn.sessionID === sessionID);
+    for (const [controller, ref] of this.active) {
+      if (ref.sessionID === sessionID)
+        controller.abort();
+    }
+    const removed = await this.dependencies.removeSession(this.workspace, sessionID);
+    await Promise.allSettled(turns.map(async (turn) => {
+      this.pendingToasts.delete(turn.key);
+      await this.releaseLease(turn.key);
+    }));
+    return removed;
+  }
+  async dispose() {
+    if (this.disposing)
+      return;
+    this.disposing = true;
+    for (const controller of this.active.keys())
+      controller.abort(disposedError());
+    await Promise.allSettled([...this.leases.keys()].map((key) => this.releaseLease(key)));
+  }
+}
 
 // src/prime.ts
 async function primeInUse(providerID, now) {
@@ -14790,13 +15551,14 @@ function zeroOutCost(provider) {
     };
   }
 }
-function buildAuthHook(adapter, client) {
+function buildAuthHook(adapter, client, pending) {
   const label = PROVIDER_LABELS[adapter.id] ?? adapter.id;
   return {
     provider: adapter.id,
     async loader(getAuth, provider) {
       await bootstrapFromOpencodeAuth(adapter.id, getAuth);
       zeroOutCost(provider);
+      await adapter.prime?.(Date.now()).catch(ignore);
       refreshUsageInBackground(adapter, Date.now()).then(() => primeInUse(adapter.id, Date.now())).catch(ignore);
       return {
         apiKey: "",
@@ -14807,7 +15569,7 @@ function buildAuthHook(adapter, client) {
           onModelFallback: (providerID, account, fromModel, toModel, fromTier) => {
             notifyModelFallback(client, providerID, account, fromModel, toModel, fromTier);
           }
-        }, Object.keys(provider.models))
+        }, Object.keys(provider.models), pending)
       };
     },
     methods: [
@@ -14842,21 +15604,41 @@ function buildAuthHook(adapter, client) {
 function createProviderPlugin(adapter) {
   return async (input) => {
     const client = input.client;
+    const pending = new PendingCoordinator({
+      workspace: input.worktree || input.directory,
+      adapter,
+      config: loadConfig(),
+      dependencies: {
+        onPending: (_ref, recovery) => notifyPending(client, adapter.id, recovery),
+        onResumed: () => notifyPendingResumed(client, adapter.id),
+        onRestored: (count) => notifyPendingRestored(client, adapter.id, count),
+        onRestoreError: (ref) => notifyPendingRestoreError(client, adapter.id, ref.messageID)
+      }
+    });
+    pending.restore(input.client).catch(ignore);
     return {
-      auth: buildAuthHook(adapter, client),
+      auth: buildAuthHook(adapter, client, pending),
       "chat.headers": async (hook, output) => {
         if (hook.model.providerID !== adapter.id)
           return;
-        if (hook.sessionID)
+        if (hook.sessionID) {
           output.headers[SESSION_HEADER] = hook.sessionID;
-      }
+          output.headers[MESSAGE_HEADER] = hook.message.id;
+        }
+      },
+      event: async ({ event }) => {
+        if (event.type !== "session.deleted")
+          return;
+        await pending.removeSession(event.properties.info.id);
+      },
+      dispose: () => pending.dispose()
     };
   };
 }
 var AnthropicLoadBalancerPlugin = createProviderPlugin(anthropicAdapter);
 var OpenAILoadBalancerPlugin = createProviderPlugin(openaiAdapter);
 var lbResult = (output) => ({ title: "Auth Load Balancer", output });
-var AuthLoadBalancerStatusPlugin = async () => ({
+var AuthLoadBalancerStatusPlugin = async (input) => ({
   tool: {
     auth_lb_status: tool({
       description: "Show the auth load-balancer pool: the in-use account per provider, each account's weekly and 5h usage, cooldowns, and the ranked next-candidate accounts. Refreshes stale usage from the provider usage endpoints (throttled) before rendering.",
@@ -14866,7 +15648,11 @@ var AuthLoadBalancerStatusPlugin = async () => ({
         const pool = await readPool();
         await refreshAllUsageInBackground(now, pool).catch(ignore);
         const renderedAt = Date.now();
-        return lbResult(renderStatus(await readStatus(renderedAt), renderedAt));
+        const status = renderStatus(await readStatus(renderedAt), renderedAt);
+        const pending = renderPendingStatus(await listPendingForWorkspace(input.worktree || input.directory), renderedAt);
+        return lbResult(pending ? `${status}
+
+${pending}` : status);
       }
     }),
     auth_lb_rename: tool({
@@ -14923,7 +15709,7 @@ var AuthLoadBalancerStatusPlugin = async () => ({
   }
 });
 export {
-  OpenAILoadBalancerPlugin,
+  AnthropicLoadBalancerPlugin,
   AuthLoadBalancerStatusPlugin,
-  AnthropicLoadBalancerPlugin
+  OpenAILoadBalancerPlugin
 };