@cortexkit/opencode-openai-auth 1.0.5 → 1.1.0

package/src/tui-compiled/runtime/shared/dbc61cd405941828-accounts.js

@@ -0,0 +1,1470 @@
+import { createHash, randomUUID } from "node:crypto";
+import { setTimeout as sleep } from "node:timers/promises";
+import {
+  acquireRefreshFileLock,
+  writeJsonAtomic
+} from "./ec971142548df90e-index.js";
+import {
+  buildQuotaOperationError,
+  buildRefreshOperationError,
+  formatRefreshBackoffMessage,
+  isTransientQuotaError,
+  quotaBackoffActive,
+  refreshBackoffActive
+} from "./134b008900698fe0-backoff.js";
+import { createLogger } from "./d669d72c40e9e116-logger.js";
+import { extractAccountId } from "./4d05c2d7a531aece-oauth.js";
+import {
+  ACCOUNT_FILE_NAME,
+  ACCOUNT_STATE_FILE_NAME,
+  deriveStatePath
+} from "./b85c5301fddcb98a-paths.js";
+import { PRIMARY, SECONDARY } from "./85512cc5263ba259-provider.js";
+import { quotaWindowResetIsPast } from "./2dce6e9613993329-quota-manager.js";
+import {
+  assertNotTombstoneRefresh,
+  HOST_SLOT_TOMBSTONE_REFRESH,
+  isTombstoned,
+  TombstoneRefreshError
+} from "./4593a4d71edf69fd-tombstone.js";
+const logR = createLogger("refresh"), logA = createLogger("accounts"), SAVE_ACCOUNTS_LOCK_TTL_MS = 1e4, SAVE_ACCOUNTS_LOCK_WAIT_MS = 15000, SAVE_ACCOUNTS_LOCK_RETRY_MS = 50;
+
+export { ACCOUNT_FILE_NAME, ACCOUNT_STATE_FILE_NAME, deriveStatePath };
+export { PRIMARY, SECONDARY };
+export function isOAuthAccount(account) {
+  return account.type === "oauth" && account.corrupt !== !0;
+}
+export function isApiKeyAccount(account) {
+  return account.type === "api";
+}
+export function isValidApiBaseURL(value) {
+  const raw = value?.trim();
+  if (!raw)
+    return !1;
+  try {
+    const url = new URL(raw);
+    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password;
+  } catch {
+    return !1;
+  }
+}
+export const KILLSWITCH_FLOORS_SCHEMA = "floors-v1";
+export function isCostZeroingEnabled(storage) {
+  return storage.costZeroing?.enabled !== !1;
+}
+
+export class AccountRemovedDuringRefreshError extends Error {
+  code = "ACCOUNT_REMOVED_DURING_REFRESH";
+  constructor(accountId) {
+    super(`Fallback account ${accountId} was removed before refresh`);
+    this.name = "AccountRemovedDuringRefreshError";
+  }
+}
+const DEFAULT_FALLBACK_ON = [401, 403, 429], DEFAULT_MINIMUM_REMAINING = {
+  primary: 0,
+  secondary: 0
+}, DEFAULT_FAIL_CLOSED_ON_UNKNOWN_QUOTA = !1;
+export const DEFAULT_KILLSWITCH_THRESHOLDS = {
+  primary: 5,
+  secondary: 10
+};
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+const UNSAFE_RESET_ACCOUNT_KEYS = new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+export function isSafeResetAccountKey(accountKey) {
+  return accountKey.length > 0 && !UNSAFE_RESET_ACCOUNT_KEYS.has(accountKey);
+}
+function isAccountRemovedDuringRefreshError(error) {
+  return error instanceof AccountRemovedDuringRefreshError || isRecord(error) && error.name === "AccountRemovedDuringRefreshError" && error.code === "ACCOUNT_REMOVED_DURING_REFRESH";
+}
+function normalizeAccountBase(value) {
+  return {
+    id: typeof value.id === "string" && value.id.trim() ? value.id.trim() : randomUUID(),
+    label: typeof value.label === "string" ? value.label : void 0,
+    enabled: typeof value.enabled === "boolean" ? value.enabled : void 0,
+    addedAt: typeof value.addedAt === "number" ? value.addedAt : void 0,
+    lastUsed: typeof value.lastUsed === "number" ? value.lastUsed : void 0,
+    accountId: typeof value.accountId === "string" ? value.accountId : void 0
+  };
+}
+function normalizeOperationError(value) {
+  if (!isRecord(value))
+    return;
+  if (typeof value.message !== "string")
+    return;
+  const checkedAt = Number(value.checkedAt);
+  if (!Number.isFinite(checkedAt))
+    return;
+  const nextRetryAt = Number(value.nextRetryAt), retryCount = Number(value.retryCount);
+  return {
+    message: value.message,
+    checkedAt,
+    nextRetryAt: Number.isFinite(nextRetryAt) ? nextRetryAt : void 0,
+    retryCount: Number.isFinite(retryCount) ? retryCount : void 0,
+    tokenHash: typeof value.tokenHash === "string" ? value.tokenHash : void 0
+  };
+}
+function normalizeQuota(value) {
+  if (!isRecord(value))
+    return;
+  const quota = {};
+  for (const key of ["primary", "secondary"]) {
+    const window = value[key];
+    if (!isRecord(window))
+      continue;
+    const usedPercent = Number(window.usedPercent), remainingPercent = Number(window.remainingPercent), checkedAt = Number(window.checkedAt);
+    if (!Number.isFinite(usedPercent) || !Number.isFinite(remainingPercent) || !Number.isFinite(checkedAt))
+      continue;
+    const windowMinutes = typeof window.windowMinutes === "number" ? window.windowMinutes : Number.NaN;
+    quota[key] = {
+      usedPercent,
+      remainingPercent,
+      checkedAt,
+      resetsAt: typeof window.resetsAt === "string" ? window.resetsAt : void 0,
+      ...Number.isFinite(windowMinutes) && windowMinutes > 0 ? { windowMinutes } : {}
+    };
+  }
+  for (const key of [
+    "resetCreditsAvailable",
+    "resetCreditsApplicable"
+  ]) {
+    const credits = typeof value[key] === "number" ? value[key] : Number.NaN;
+    if (Number.isFinite(credits) && credits >= 0)
+      quota[key] = credits;
+  }
+  const spendControl = value.spendControl;
+  if (isRecord(spendControl)) {
+    const limit = Number(spendControl.limit), used = Number(spendControl.used), remaining = Number(spendControl.remaining), usedPercent = Number(spendControl.usedPercent), remainingPercent = Number(spendControl.remainingPercent);
+    if (Number.isFinite(limit) && Number.isFinite(used) && Number.isFinite(remaining) && Number.isFinite(usedPercent) && Number.isFinite(remainingPercent) && typeof spendControl.reached === "boolean")
+      quota.spendControl = {
+        limit,
+        used,
+        remaining,
+        usedPercent,
+        remainingPercent,
+        resetsAt: typeof spendControl.resetsAt === "string" ? spendControl.resetsAt : void 0,
+        unit: typeof spendControl.unit === "string" ? spendControl.unit : void 0,
+        source: typeof spendControl.source === "string" ? spendControl.source : void 0,
+        reached: spendControl.reached
+      };
+  }
+  const credits = value.credits;
+  if (isRecord(credits) && typeof credits.hasCredits === "boolean" && typeof credits.unlimited === "boolean" && typeof credits.overageLimitReached === "boolean") {
+    const balance = Number(credits.balance);
+    quota.credits = {
+      hasCredits: credits.hasCredits,
+      unlimited: credits.unlimited,
+      overageLimitReached: credits.overageLimitReached,
+      ...Number.isFinite(balance) ? { balance } : {}
+    };
+  }
+  return Object.keys(quota).length ? quota : void 0;
+}
+export function normalizeAccount(value) {
+  if (!isRecord(value))
+    return null;
+  if (value.type === "api") {
+    const baseURL = typeof value.baseURL === "string" ? value.baseURL.trim() : "", apiKey = typeof value.apiKey === "string" ? value.apiKey.trim() : "";
+    if (!isValidApiBaseURL(baseURL))
+      return null;
+    const authHeader = value.authHeader === "x-api-key" ? "x-api-key" : "authorization-bearer";
+    return {
+      ...normalizeAccountBase(value),
+      type: "api",
+      apiKey: apiKey || void 0,
+      baseURL,
+      authHeader
+    };
+  }
+  if (value.type !== "oauth")
+    return null;
+  if (value.corrupt === !0) {
+    if (typeof value.id !== "string" || !value.id.trim())
+      return null;
+    return {
+      ...normalizeAccountBase(value),
+      type: "oauth",
+      corrupt: !0
+    };
+  }
+  if (typeof value.refresh !== "string" || !value.refresh.trim()) {
+    if (!Object.hasOwn(value, "refresh") || typeof value.id !== "string" || !value.id.trim())
+      return null;
+    return {
+      ...normalizeAccountBase(value),
+      type: "oauth",
+      corrupt: !0
+    };
+  }
+  return {
+    ...normalizeAccountBase(value),
+    type: "oauth",
+    access: typeof value.access === "string" ? value.access : void 0,
+    refresh: value.refresh,
+    expires: typeof value.expires === "number" ? value.expires : void 0,
+    lastRefreshedAt: typeof value.lastRefreshedAt === "number" ? value.lastRefreshedAt : void 0,
+    lastRefreshError: normalizeOperationError(value.lastRefreshError),
+    lastQuotaRefreshError: normalizeOperationError(value.lastQuotaRefreshError),
+    quota: normalizeQuota(value.quota)
+  };
+}
+function normalizeResetState(value) {
+  if (!isRecord(value))
+    return;
+  const normalized = Object.create(null);
+  for (const [accountId, candidate] of Object.entries(value)) {
+    if (!isSafeResetAccountKey(accountId) || !isRecord(candidate))
+      continue;
+    const state = {};
+    if (isRecord(candidate.inFlight))
+      state.inFlight = { ...candidate.inFlight };
+    if (isRecord(candidate.lastOutcome) && typeof candidate.lastOutcome.code === "string" && candidate.lastOutcome.code.length > 0 && typeof candidate.lastOutcome.at === "number" && Number.isFinite(candidate.lastOutcome.at))
+      state.lastOutcome = {
+        code: candidate.lastOutcome.code,
+        at: candidate.lastOutcome.at,
+        ...isRecord(candidate.lastOutcome.previousOutcome) && typeof candidate.lastOutcome.previousOutcome.code === "string" && candidate.lastOutcome.previousOutcome.code.length > 0 && typeof candidate.lastOutcome.previousOutcome.at === "number" && Number.isFinite(candidate.lastOutcome.previousOutcome.at) ? {
+          previousOutcome: {
+            code: candidate.lastOutcome.previousOutcome.code,
+            at: candidate.lastOutcome.previousOutcome.at
+          }
+        } : {}
+      };
+    if (typeof candidate.cooldownUntil === "number" && Number.isFinite(candidate.cooldownUntil))
+      state.cooldownUntil = candidate.cooldownUntil;
+    if (Object.keys(state).length > 0)
+      normalized[accountId] = state;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+const warnedRosterDrops = new Set;
+function emitRosterDropWarning(droppedIds) {
+  if (droppedIds.length === 0)
+    return;
+  const key = JSON.stringify([...droppedIds].sort());
+  if (warnedRosterDrops.has(key))
+    return;
+  warnedRosterDrops.add(key);
+  logA.warn("account load-dropped, preserved on disk", {
+    droppedIds
+  });
+}
+function normalizeStorage(value) {
+  if (!isRecord(value) || !Array.isArray(value.accounts))
+    return null;
+  const inputAccounts = value.accounts, normalizedAccounts = inputAccounts.map(normalizeAccount).filter((account) => account != null);
+  if (normalizedAccounts.length < inputAccounts.length) {
+    const inputIds = new Set;
+    for (const candidate of inputAccounts)
+      if (isRecord(candidate) && typeof candidate.id === "string" && candidate.id.trim())
+        inputIds.add(candidate.id.trim());
+    const loadedIds = new Set(normalizedAccounts.map((account) => account.id)), dropped = [];
+    for (const id of inputIds)
+      if (!loadedIds.has(id))
+        dropped.push(id);
+    emitRosterDropWarning(dropped);
+  }
+  return {
+    version: 1,
+    main: { type: "opencode", provider: "openai" },
+    routing: isRecord(value.routing) ? value.routing : void 0,
+    fallbackOn: Array.isArray(value.fallbackOn) ? value.fallbackOn.filter((status) => Number.isInteger(status)) : void 0,
+    refresh: isRecord(value.refresh) ? value.refresh : void 0,
+    quota: isRecord(value.quota) ? value.quota : void 0,
+    reset: normalizeResetState(value.reset),
+    dump: isRecord(value.dump) ? value.dump : void 0,
+    costZeroing: isRecord(value.costZeroing) ? value.costZeroing : void 0,
+    killswitch: isRecord(value.killswitch) ? value.killswitch : void 0,
+    logging: isRecord(value.logging) ? value.logging : void 0,
+    cachekeep: isRecord(value.cachekeep) ? value.cachekeep : void 0,
+    cacheKeep: isRecord(value.cacheKeep) ? value.cacheKeep : void 0,
+    mainAccountId: typeof value.mainAccountId === "string" ? value.mainAccountId : void 0,
+    accounts: normalizedAccounts
+  };
+}
+function withoutRetiredSettings(config) {
+  if (!("claustrum" in config))
+    return config;
+  const { claustrum: _retired, ...rest } = config;
+  return rest;
+}
+import { readFile } from "node:fs/promises";
+async function readJsonIfPresent(path) {
+  try {
+    return { exists: !0, value: JSON.parse(await readFile(path, "utf8")) };
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { exists: !1, value: null };
+    throw error;
+  }
+}
+function objectWithDefinedEntries(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+export async function readConfigRosterIds(path) {
+  let value;
+  try {
+    value = (await readJsonIfPresent(path)).value;
+  } catch {
+    return null;
+  }
+  return collectConfigRosterIds(value);
+}
+function mergeConfigAndState(configValue, stateValue) {
+  if (!isRecord(configValue))
+    return configValue;
+  const state = isRecord(stateValue) ? stateValue : {}, mainState = isRecord(state.main) ? state.main : void 0, stateAccounts = isRecord(state.accounts) ? state.accounts : {}, quotaConfig = isRecord(configValue.quota) ? configValue.quota : {}, refreshConfig = isRecord(configValue.refresh) ? configValue.refresh : {}, mainQuotaSource = mainState ?? quotaConfig, mainRefreshSource = mainState ?? refreshConfig, mainLease = refreshConfig.mainRefreshLeaseId !== void 0 ? {
+    id: refreshConfig.mainRefreshLeaseId,
+    until: refreshConfig.mainRefreshLeaseUntil,
+    tokenHash: refreshConfig.mainRefreshLeaseTokenHash
+  } : {
+    id: mainRefreshSource.refreshLeaseId,
+    until: mainRefreshSource.refreshLeaseUntil,
+    tokenHash: mainRefreshSource.refreshLeaseTokenHash
+  }, accounts = Array.isArray(configValue.accounts) ? configValue.accounts.map((account) => {
+    if (!isRecord(account))
+      return account;
+    const stateAccount = typeof account.id === "string" && isRecord(stateAccounts[account.id]) ? stateAccounts[account.id] : {};
+    return { ...account, ...stateAccount };
+  }) : void 0;
+  return omitUndefinedTopLevel({
+    ...configValue,
+    refresh: objectWithDefinedEntries({
+      ...refreshConfig,
+      mainLastRefreshError: refreshConfig.mainLastRefreshError ?? mainRefreshSource.lastRefreshError,
+      mainRefreshLeaseId: mainLease.id,
+      mainRefreshLeaseUntil: mainLease.until,
+      mainRefreshLeaseTokenHash: mainLease.tokenHash
+    }),
+    quota: objectWithDefinedEntries({
+      ...quotaConfig,
+      mainQuota: mainQuotaSource.quota,
+      mainQuotaCheckedAt: mainQuotaSource.quotaCheckedAt,
+      mainQuotaToken: mainQuotaSource.quotaToken,
+      mainLastQuotaApiError: mainQuotaSource.lastQuotaApiError
+    }),
+    accounts
+  });
+}
+export async function loadAccounts(paths) {
+  const config = await readJsonIfPresent(paths.configPath);
+  if (!config.exists)
+    return null;
+  const state = await readJsonIfPresent(paths.statePath);
+  return normalizeStorage(mergeConfigAndState(config.value, state.value));
+}
+function omitUndefinedTopLevel(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function accountConfig(account) {
+  return objectWithDefinedEntries({
+    id: account.id,
+    label: account.label,
+    type: account.type,
+    corrupt: account.type === "oauth" && account.corrupt === !0 ? !0 : void 0,
+    enabled: account.enabled,
+    addedAt: account.addedAt,
+    accountId: account.accountId,
+    baseURL: account.type === "api" ? account.baseURL : void 0,
+    authHeader: account.type === "api" ? account.authHeader : void 0
+  });
+}
+function accountRuntimeState(account) {
+  if (account.type === "api")
+    return objectWithDefinedEntries({
+      apiKey: account.apiKey,
+      lastUsed: account.lastUsed
+    });
+  if (account.corrupt)
+    return {};
+  return objectWithDefinedEntries({
+    access: account.access,
+    refresh: account.refresh,
+    expires: account.expires,
+    lastUsed: account.lastUsed,
+    lastRefreshedAt: account.lastRefreshedAt,
+    lastRefreshError: account.lastRefreshError,
+    lastQuotaRefreshError: account.lastQuotaRefreshError,
+    quota: account.quota
+  });
+}
+function quotaSnapshotCheckedAt(quota) {
+  return Math.max(quota?.primary?.checkedAt ?? 0, quota?.secondary?.checkedAt ?? 0);
+}
+function copyRuntimeField(target, source, key) {
+  if (key in source)
+    target[key] = source[key];
+  else
+    delete target[key];
+}
+function tokenFieldsMatch(existing, incoming) {
+  return existing.access === incoming.access && existing.refresh === incoming.refresh && existing.expires === incoming.expires && existing.lastRefreshedAt === incoming.lastRefreshedAt;
+}
+function selectSameTokenState(existing, incoming) {
+  if (!tokenFieldsMatch(existing, incoming))
+    return incoming;
+  if (!("lastRefreshError" in incoming))
+    return existing;
+  if (!("lastRefreshError" in existing))
+    return incoming;
+  return (incoming.lastRefreshError?.checkedAt ?? 0) > (existing.lastRefreshError?.checkedAt ?? 0) ? incoming : existing;
+}
+const FUTURE_REFRESH_STAMP_TOLERANCE_MS = 300000;
+function trustedRefreshStamp(stamp, now) {
+  if (stamp === void 0)
+    return 0;
+  return stamp > now + FUTURE_REFRESH_STAMP_TOLERANCE_MS ? 0 : stamp;
+}
+function applyNewerTokenState(merged, existing, incoming) {
+  const now = Date.now(), existingRefreshAt = trustedRefreshStamp(existing.lastRefreshedAt, now), incomingRefreshAt = trustedRefreshStamp(incoming.lastRefreshedAt, now), existingExpires = existing.expires ?? 0, incomingExpires = incoming.expires ?? 0, tokenSource = incomingRefreshAt > existingRefreshAt ? incoming : existingRefreshAt > incomingRefreshAt ? existing : incomingExpires > existingExpires ? incoming : existingExpires > incomingExpires ? existing : selectSameTokenState(existing, incoming);
+  copyRuntimeField(merged, tokenSource, "access");
+  copyRuntimeField(merged, tokenSource, "refresh");
+  copyRuntimeField(merged, tokenSource, "expires");
+  copyRuntimeField(merged, tokenSource, "lastRefreshedAt");
+  copyRuntimeField(merged, tokenSource, "lastRefreshError");
+}
+function mergeAccountRuntimeState(existing, incoming) {
+  if (!isRecord(existing))
+    return incoming;
+  const existingEntry = existing, existingQuotaCheckedAt = quotaSnapshotCheckedAt(existingEntry.quota), incomingQuotaCheckedAt = quotaSnapshotCheckedAt(incoming.quota), existingQuotaIsNewer = existingQuotaCheckedAt > incomingQuotaCheckedAt, merged = existingQuotaIsNewer ? {
+    ...existingEntry,
+    ...incoming,
+    quota: existingEntry.quota,
+    lastQuotaRefreshError: existingEntry.lastQuotaRefreshError
+  } : { ...existingEntry, ...incoming };
+  if (!existingQuotaIsNewer && !("lastQuotaRefreshError" in incoming))
+    delete merged.lastQuotaRefreshError;
+  if (!("lastRefreshError" in incoming))
+    delete merged.lastRefreshError;
+  if (typeof existingEntry.lastUsed === "number" && (typeof incoming.lastUsed !== "number" || existingEntry.lastUsed > incoming.lastUsed))
+    merged.lastUsed = existingEntry.lastUsed;
+  applyNewerTokenState(merged, existingEntry, incoming);
+  return merged;
+}
+function configFromStorage(storage) {
+  const refresh = storage.refresh ? objectWithDefinedEntries({
+    enabled: storage.refresh.enabled,
+    refreshBeforeExpiryMinutes: storage.refresh.refreshBeforeExpiryMinutes
+  }) : void 0, quota = storage.quota ? objectWithDefinedEntries({
+    enabled: storage.quota.enabled,
+    checkIntervalMinutes: storage.quota.checkIntervalMinutes,
+    refreshEveryNRequests: storage.quota.refreshEveryNRequests,
+    minimumRemaining: storage.quota.minimumRemaining,
+    failClosedOnUnknownQuota: storage.quota.failClosedOnUnknownQuota
+  }) : void 0;
+  return omitUndefinedTopLevel({
+    version: 1,
+    main: storage.main,
+    routing: storage.routing,
+    fallbackOn: storage.fallbackOn,
+    refresh,
+    quota,
+    reset: storage.reset,
+    dump: storage.dump,
+    costZeroing: storage.costZeroing,
+    killswitch: storage.killswitch,
+    logging: storage.logging,
+    cachekeep: storage.cachekeep,
+    cacheKeep: storage.cacheKeep,
+    mainAccountId: storage.mainAccountId,
+    accounts: storage.accounts.map(accountConfig)
+  });
+}
+const CREDENTIAL_FIELDS = [
+  "access",
+  "refresh",
+  "expires",
+  "lastRefreshedAt",
+  "lastRefreshError"
+];
+function keepNewerCredential(onDisk, incoming) {
+  if (!isOAuthAccount(onDisk) || !isOAuthAccount(incoming))
+    return incoming;
+  const incomingEntry = accountRuntimeState(incoming), chosen = { ...incomingEntry };
+  applyNewerTokenState(chosen, accountRuntimeState(onDisk), incomingEntry);
+  const result = { ...incoming };
+  for (const field of CREDENTIAL_FIELDS)
+    if (field in chosen)
+      result[field] = chosen[field];
+    else
+      delete result[field];
+  return result;
+}
+function mergeStorageForSave(latest, incoming) {
+  if (!latest)
+    return incoming;
+  const accounts = new Map;
+  for (const account of latest.accounts)
+    accounts.set(account.id, account);
+  for (const account of incoming.accounts) {
+    const onDisk = accounts.get(account.id);
+    accounts.set(account.id, onDisk ? keepNewerCredential(onDisk, account) : account);
+  }
+  return {
+    ...latest,
+    ...incoming,
+    accounts: [...accounts.values()]
+  };
+}
+async function acquireSaveAccountsLock(path, renew = !1) {
+  const startedAt = Date.now(), deadline = startedAt + SAVE_ACCOUNTS_LOCK_WAIT_MS;
+  let attempts = 0;
+  while (Date.now() <= deadline) {
+    attempts++;
+    const lock = await acquireRefreshFileLock({
+      name: "save",
+      ttlMs: SAVE_ACCOUNTS_LOCK_TTL_MS,
+      path,
+      renew
+    });
+    if (lock)
+      return lock;
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0)
+      break;
+    await sleep(Math.min(SAVE_ACCOUNTS_LOCK_RETRY_MS + jitterMs(SAVE_ACCOUNTS_LOCK_RETRY_MS), remainingMs));
+  }
+  const elapsedMs = Date.now() - startedAt, averageGapMs = Math.round(elapsedMs / Math.max(1, attempts));
+  throw Error(`Timed out after ${elapsedMs}ms waiting for the account store lock on ${path} (${attempts} attempts, ~${averageGapMs}ms apart; retry interval is ${SAVE_ACCOUNTS_LOCK_RETRY_MS}ms). A gap near the retry interval means lock contention; a much larger one means this process's event loop was saturated and the wait expired without getting scheduled.`);
+}
+function stateFromStorage(storage) {
+  const accounts = Object.fromEntries(storage.accounts.map((account) => [
+    account.id,
+    accountRuntimeState(account)
+  ]));
+  return {
+    version: 1,
+    main: objectWithDefinedEntries({
+      quota: storage.quota?.mainQuota,
+      quotaCheckedAt: storage.quota?.mainQuotaCheckedAt,
+      quotaToken: storage.quota?.mainQuotaToken,
+      lastQuotaApiError: storage.quota?.mainLastQuotaApiError,
+      lastRefreshError: storage.refresh?.mainLastRefreshError,
+      refreshLeaseId: storage.refresh?.mainRefreshLeaseId,
+      refreshLeaseUntil: storage.refresh?.mainRefreshLeaseUntil,
+      refreshLeaseTokenHash: storage.refresh?.mainRefreshLeaseTokenHash
+    }),
+    accounts
+  };
+}
+export async function saveAccounts(storage, paths, canWrite = void 0) {
+  const { configPath: path, statePath } = paths, lock = await acquireSaveAccountsLock(path);
+  try {
+    const stateLock = await acquireSaveAccountsLock(statePath);
+    try {
+      const configJson = await readJsonIfPresent(path), stateJson = await readJsonIfPresent(statePath), latest = configJson.exists ? normalizeStorage(mergeConfigAndState(configJson.value, stateJson.value)) : null, merged = mergeStorageForSave(latest, storage), existing = isRecord(configJson.value) ? configJson.value : {}, latestAccountIds = latest ? new Set(latest.accounts.map((a) => a.id)) : new Set, preserved = buildPreservedAdditions(configJson.value, latestAccountIds, new Set), baseConfig = configFromStorage(merged), writtenIds = new Set((Array.isArray(baseConfig.accounts) ? baseConfig.accounts : []).map((e) => isRecord(e) && typeof e.id === "string" ? e.id.trim() : "").filter(Boolean)), additions = preserved.filter((raw) => {
+        if (!isRecord(raw))
+          return !1;
+        if (typeof raw.id !== "string")
+          return !1;
+        return !writtenIds.has(raw.id.trim());
+      }), nextConfig = {
+        ...withoutRetiredSettings(existing),
+        ...baseConfig,
+        accounts: [
+          ...Array.isArray(baseConfig.accounts) ? baseConfig.accounts : [],
+          ...additions
+        ]
+      };
+      if (canWrite && !canWrite())
+        return;
+      await writeJsonAtomic(path, nextConfig);
+      if (canWrite && !canWrite())
+        return;
+      await writeJsonAtomic(statePath, stateFromStorage(merged));
+    } finally {
+      await stateLock.release();
+    }
+  } finally {
+    await lock.release();
+  }
+}
+function collectConfigRosterIds(value) {
+  if (!isRecord(value) || !Array.isArray(value.accounts))
+    return null;
+  const ids = new Set;
+  for (const account of value.accounts) {
+    if (!isRecord(account))
+      continue;
+    if (typeof account.id !== "string")
+      continue;
+    const trimmed = account.id.trim();
+    if (!trimmed)
+      continue;
+    ids.add(trimmed);
+  }
+  return ids;
+}
+function pickRawRosterEntriesForPreservation(rawValue, rawIds, currentAccountIds, allowDrop) {
+  if (!isRecord(rawValue) || !Array.isArray(rawValue.accounts))
+    return { preservedRawEntries: [], preservedIds: [] };
+  const preservedRawEntries = [], preservedIds = [];
+  for (const id of rawIds) {
+    if (currentAccountIds.has(id))
+      continue;
+    if (allowDrop.has(id))
+      continue;
+    const rawEntry = rawValue.accounts.find((acc) => isRecord(acc) && typeof acc.id === "string" && acc.id.trim() === id);
+    if (!rawEntry)
+      continue;
+    preservedRawEntries.push(rawEntry);
+    preservedIds.push(id);
+  }
+  return { preservedRawEntries, preservedIds };
+}
+function collectStringIds(entries) {
+  if (!Array.isArray(entries))
+    return [];
+  const ids = [];
+  for (const entry of entries) {
+    if (!isRecord(entry))
+      continue;
+    if (typeof entry.id !== "string")
+      continue;
+    ids.push(entry.id);
+  }
+  return ids;
+}
+function buildPreservedAdditions(rawConfigValue, loadedIds, allowDrop) {
+  const rawIds = collectConfigRosterIds(rawConfigValue);
+  if (rawIds === null)
+    return [];
+  const { preservedRawEntries, preservedIds } = pickRawRosterEntriesForPreservation(rawConfigValue, rawIds, loadedIds, allowDrop);
+  emitRosterDropWarning(preservedIds);
+  return preservedRawEntries;
+}
+export async function mutateAccounts(mutate, paths, options = {}) {
+  const { configPath: path, statePath } = paths, lock = await acquireSaveAccountsLock(path);
+  try {
+    const stateLock = await acquireSaveAccountsLock(statePath);
+    try {
+      const configJson = await readJsonIfPresent(path), stateJson = await readJsonIfPresent(statePath), current = (configJson.exists ? normalizeStorage(mergeConfigAndState(configJson.value, stateJson.value)) : null) ?? emptyAccountStorage(), currentAccountIds = new Set(current.accounts.map((a) => a.id)), rawRosterIds = collectConfigRosterIds(configJson.value) ?? new Set, next = mutate(current, {
+        rawRosterIds: [...rawRosterIds],
+        loadedRosterIds: [...currentAccountIds]
+      }) ?? current, allowDrop = new Set(options.allowDrop ?? []), preserved = buildPreservedAdditions(configJson.value, currentAccountIds, allowDrop), baseConfig = configFromStorage(next), writtenIds = new Set((Array.isArray(baseConfig.accounts) ? baseConfig.accounts : []).map((e) => isRecord(e) && typeof e.id === "string" ? e.id.trim() : "").filter(Boolean)), additions = preserved.filter((raw) => {
+        if (!isRecord(raw))
+          return !1;
+        if (typeof raw.id !== "string")
+          return !1;
+        return !writtenIds.has(raw.id.trim());
+      }), existing = isRecord(configJson.value) ? configJson.value : {}, nextConfig = {
+        ...withoutRetiredSettings(existing),
+        ...baseConfig,
+        accounts: [
+          ...Array.isArray(baseConfig.accounts) ? baseConfig.accounts : [],
+          ...additions
+        ]
+      };
+      if (options.canWrite && !options.canWrite())
+        return current;
+      await writeJsonAtomic(path, nextConfig);
+      if (options.canWrite && !options.canWrite())
+        return current;
+      await writeJsonAtomic(statePath, stateFromStorage(next));
+      logA.debug("account config written", {
+        accountCount: nextConfig.accounts.length,
+        accountIds: collectStringIds(nextConfig.accounts)
+      });
+      return next;
+    } finally {
+      await stateLock.release();
+    }
+  } finally {
+    await lock.release();
+  }
+}
+function emptyAccountStorage() {
+  return {
+    version: 1,
+    main: { type: "opencode", provider: "openai" },
+    accounts: []
+  };
+}
+function applyMainQuotaStatePatch(state, storage) {
+  state.main = state.main ?? {};
+  const existingCheckedAt = typeof state.main.quotaCheckedAt === "number" ? state.main.quotaCheckedAt : quotaSnapshotCheckedAt(state.main.quota), incomingCheckedAt = typeof storage.quota?.mainQuotaCheckedAt === "number" ? storage.quota.mainQuotaCheckedAt : quotaSnapshotCheckedAt(storage.quota?.mainQuota);
+  if (existingCheckedAt > incomingCheckedAt)
+    return;
+  state.main.quota = storage.quota?.mainQuota;
+  state.main.quotaCheckedAt = storage.quota?.mainQuotaCheckedAt;
+  state.main.quotaToken = storage.quota?.mainQuotaToken;
+  state.main.lastQuotaApiError = storage.quota?.mainLastQuotaApiError;
+}
+function applyMainRefreshStatePatch(state, storage) {
+  state.main = state.main ?? {};
+  state.main.lastRefreshError = storage.refresh?.mainLastRefreshError;
+  state.main.refreshLeaseId = storage.refresh?.mainRefreshLeaseId;
+  state.main.refreshLeaseUntil = storage.refresh?.mainRefreshLeaseUntil;
+  state.main.refreshLeaseTokenHash = storage.refresh?.mainRefreshLeaseTokenHash;
+}
+function pruneUndefined(value) {
+  if (Array.isArray(value))
+    return value.map(pruneUndefined);
+  if (!isRecord(value))
+    return value;
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0).map(([key, entry]) => [key, pruneUndefined(entry)]));
+}
+export async function saveAccountState(storage, paths, scope = {
+  mainQuota: !0,
+  mainRefresh: !0,
+  accounts: !0
+}, canWrite) {
+  const statePath = paths.statePath, lock = await acquireSaveAccountsLock(statePath);
+  try {
+    const existing = (await readJsonIfPresent(statePath)).value, next = isRecord(existing) ? { ...existing, version: 1 } : { version: 1 };
+    if (scope.mainQuota)
+      applyMainQuotaStatePatch(next, storage);
+    if (scope.mainRefresh)
+      applyMainRefreshStatePatch(next, storage);
+    if (scope.accounts) {
+      const ids = scope.accounts === !0 ? null : new Set(scope.accounts), roster = await readConfigRosterIds(paths.configPath);
+      next.accounts = { ...isRecord(next.accounts) ? next.accounts : {} };
+      for (const account of storage.accounts) {
+        if (ids && !ids.has(account.id))
+          continue;
+        if (roster && !roster.has(account.id))
+          continue;
+        next.accounts[account.id] = mergeAccountRuntimeState(next.accounts[account.id], accountRuntimeState(account));
+      }
+      if (ids) {
+        for (const id of ids)
+          if (!storage.accounts.some((account) => account.id === id))
+            delete next.accounts[id];
+      }
+      if (roster) {
+        for (const id of Object.keys(next.accounts))
+          if (!roster.has(id))
+            delete next.accounts[id];
+      }
+    }
+    if (canWrite && !canWrite())
+      return;
+    await writeJsonAtomic(statePath, pruneUndefined(next));
+  } finally {
+    await lock.release();
+  }
+}
+export function getFallbackStatuses(storage) {
+  return storage?.fallbackOn?.length ? storage.fallbackOn : DEFAULT_FALLBACK_ON;
+}
+export function shouldFallbackStatus(status, storage) {
+  return getFallbackStatuses(storage).includes(status);
+}
+function normalizeThresholds(storage) {
+  const configured = storage?.quota?.minimumRemaining || {};
+  return {
+    primary: configured.primary ?? configured["5h"] ?? DEFAULT_MINIMUM_REMAINING.primary,
+    secondary: configured.secondary ?? configured["1w"] ?? DEFAULT_MINIMUM_REMAINING.secondary
+  };
+}
+function quotaEnabled(storage) {
+  return storage?.quota?.enabled !== !1;
+}
+function failClosedOnUnknownQuota(storage) {
+  return storage?.quota?.failClosedOnUnknownQuota ?? DEFAULT_FAIL_CLOSED_ON_UNKNOWN_QUOTA;
+}
+export function quotaSnapshotPassesPolicy(quota, storage, now = Date.now()) {
+  if (!quotaEnabled(storage))
+    return !0;
+  if (!quota)
+    return !failClosedOnUnknownQuota(storage);
+  const thresholds = normalizeThresholds(storage), failClosed = failClosedOnUnknownQuota(storage);
+  for (const key of ["primary", "secondary"]) {
+    const window = quota[key];
+    if (!window)
+      continue;
+    if (quotaWindowResetIsPast(window, now)) {
+      if (failClosed)
+        return !1;
+      continue;
+    }
+    if (window.remainingPercent < thresholds[key])
+      return !1;
+  }
+  return !0;
+}
+export function isKillswitchEnabled(storage) {
+  return storage?.killswitch?.enabled === !0;
+}
+function normalizeKillswitchThresholds(thresholds) {
+  return {
+    primary: thresholds?.primary ?? thresholds?.["5h"] ?? DEFAULT_KILLSWITCH_THRESHOLDS.primary,
+    secondary: thresholds?.secondary ?? thresholds?.["1w"] ?? DEFAULT_KILLSWITCH_THRESHOLDS.secondary
+  };
+}
+export function cacheKeepSettings(storage) {
+  return storage?.cacheKeep ?? storage?.cachekeep;
+}
+function floorOf(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+export function getKillswitchThresholdsForAccount(storage, accountId) {
+  if (!storage?.killswitch)
+    return DEFAULT_KILLSWITCH_THRESHOLDS;
+  if (storage.killswitch.schema === KILLSWITCH_FLOORS_SCHEMA) {
+    const { accounts, defaults } = storage.killswitch, id = accountId ?? "main", own = isRecord(accounts) && Object.hasOwn(accounts, id) && isRecord(accounts[id]) ? accounts[id] : isRecord(defaults) ? defaults : void 0;
+    return {
+      primary: floorOf(own?.primary),
+      secondary: floorOf(own?.secondary)
+    };
+  }
+  if (accountId && storage.killswitch.accounts?.[accountId])
+    return normalizeKillswitchThresholds(storage.killswitch.accounts[accountId]);
+  return normalizeKillswitchThresholds(storage.killswitch.main);
+}
+export function killswitchPassesPolicy(quota, storage, accountId, now = Date.now()) {
+  if (!isKillswitchEnabled(storage))
+    return !0;
+  if (!quota)
+    return !failClosedOnUnknownQuota(storage);
+  const thresholds = getKillswitchThresholdsForAccount(storage, accountId), failClosed = failClosedOnUnknownQuota(storage);
+  for (const key of ["primary", "secondary"]) {
+    const window = quota[key];
+    if (!window)
+      continue;
+    if (quotaWindowResetIsPast(window, now)) {
+      if (failClosed)
+        return !1;
+      continue;
+    }
+    if (window.remainingPercent < thresholds[key])
+      return !1;
+  }
+  return !0;
+}
+export function killswitchRetryAfterSeconds(mainQuota, fallbackAccounts, now, storage) {
+  if (!isKillswitchEnabled(storage))
+    return 300;
+  const accountResetTimes = [], accounts = [
+    { accountId: void 0, quota: mainQuota },
+    ...fallbackAccounts
+  ];
+  for (const { accountId, quota } of accounts) {
+    if (!quota)
+      continue;
+    const thresholds = getKillswitchThresholdsForAccount(storage, accountId), violatingResetTimes = [];
+    let resetUnknown = !1;
+    for (const key of ["primary", "secondary"]) {
+      const window = quota[key];
+      if (!window || quotaWindowResetIsPast(window, now))
+        continue;
+      if (window.remainingPercent >= thresholds[key])
+        continue;
+      const resetTime = window.resetsAt ? Date.parse(window.resetsAt) : NaN;
+      if (!Number.isFinite(resetTime) || resetTime <= now) {
+        resetUnknown = !0;
+        break;
+      }
+      violatingResetTimes.push(resetTime);
+    }
+    if (resetUnknown || violatingResetTimes.length === 0)
+      continue;
+    accountResetTimes.push(Math.max(...violatingResetTimes));
+  }
+  if (accountResetTimes.length === 0)
+    return 300;
+  const earliest = Math.min(...accountResetTimes);
+  return Math.max(1, Math.ceil((earliest - now) / 1000));
+}
+function isAccountStore(value) {
+  return typeof value.version === "number" && Array.isArray(value.accounts);
+}
+export async function migrateIfNeeded(existingToken, paths) {
+  const { configPath: path, statePath } = paths;
+  if (!existingToken)
+    return;
+  try {
+    const current = await readJsonIfPresent(path);
+    if (current.exists && isRecord(current.value) && isAccountStore(current.value))
+      return;
+  } catch {}
+  const lock = await acquireSaveAccountsLock(path);
+  try {
+    const stateLock = await acquireSaveAccountsLock(statePath);
+    try {
+      const existing = await readJsonIfPresent(path);
+      if (existing.exists && isRecord(existing.value)) {
+        if (isAccountStore(existing.value))
+          return;
+      }
+      if (!existingToken)
+        return;
+      const storage = {
+        version: 1,
+        main: { type: "opencode", provider: "openai" },
+        accounts: []
+      };
+      if (existingToken.access) {
+        const accountId = extractAccountId({
+          id_token: "",
+          access_token: existingToken.access,
+          refresh_token: existingToken.refresh
+        });
+        if (accountId)
+          storage.mainAccountId = accountId;
+      }
+      const existingFields = existing.exists && isRecord(existing.value) ? existing.value : {}, nextConfig = {
+        ...withoutRetiredSettings(existingFields),
+        ...configFromStorage(storage)
+      };
+      await writeJsonAtomic(path, nextConfig);
+      await writeJsonAtomic(statePath, stateFromStorage(storage));
+    } finally {
+      await stateLock.release();
+    }
+  } finally {
+    await lock.release();
+  }
+}
+function refreshEnabled(storage) {
+  return storage?.refresh?.enabled !== !1;
+}
+export function refreshBeforeExpiryMs(storage) {
+  return (storage?.refresh?.refreshBeforeExpiryMinutes ?? 240) * 60000;
+}
+function jitterMs(maxMs) {
+  return Math.floor(Math.random() * (maxMs + 1));
+}
+function tokenNeedsRefresh(account, storage, now) {
+  return !account.access || !account.expires || account.expires - now <= refreshBeforeExpiryMs(storage);
+}
+function hasUnexpiredAccessToken(account, now) {
+  return Boolean(account.access && typeof account.expires === "number" && account.expires > now);
+}
+export function isShieldedMainRow(storage, account) {
+  return Boolean(storage?.mainAccountId && account.accountId && account.accountId === storage.mainAccountId);
+}
+
+export class ShieldedMainRowRefreshError extends Error {
+  constructor(accountId) {
+    super(`Refusing to refresh account ${accountId}: it holds the main account's credential while the main slot is live`);
+    this.name = "ShieldedMainRowRefreshError";
+  }
+}
+export const POOL_MAIN_PLACEHOLDER_REFRESH = "common-auth-placeholder:v1:openai", POOL_MAIN_ROW_ID = "main";
+export function isPoolMainPlaceholder(auth) {
+  return isRecord(auth) && auth.type === "oauth" && (auth.refresh === POOL_MAIN_PLACEHOLDER_REFRESH || auth.refresh === HOST_SLOT_TOMBSTONE_REFRESH);
+}
+export function findPoolMainRow(storage) {
+  return storage?.accounts.find((account) => account.id === POOL_MAIN_ROW_ID && account.enabled !== !1 && isOAuthAccount(account));
+}
+export function withoutPoolMainRow(storage) {
+  if (!storage)
+    return storage;
+  return {
+    ...storage,
+    accounts: storage.accounts.filter((account) => account.id !== POOL_MAIN_ROW_ID)
+  };
+}
+function updateStoredAccount(storage, account) {
+  const idx = storage.accounts.findIndex((candidate) => candidate.id === account.id);
+  if (idx !== -1)
+    storage.accounts[idx] = account;
+}
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function recordRefreshError(account, error, now) {
+  if (error instanceof TombstoneRefreshError)
+    return;
+  account.lastRefreshError = buildRefreshOperationError({
+    error,
+    now,
+    refreshToken: account.refresh,
+    previous: account.lastRefreshError
+  });
+}
+function recordQuotaRefreshError(account, error, now) {
+  if (error instanceof TombstoneRefreshError)
+    return;
+  account.lastQuotaRefreshError = buildQuotaOperationError({
+    error,
+    now,
+    previous: account.lastQuotaRefreshError
+  });
+  if (error?.isRefreshError === !0)
+    recordRefreshError(account, error, now);
+}
+function cachedQuotaWindowStillRelevant(window, now) {
+  if (!window)
+    return !1;
+  if (!window.resetsAt)
+    return !0;
+  const resetTime = Date.parse(window.resetsAt);
+  return Number.isFinite(resetTime) ? resetTime > now : !0;
+}
+function cachedQuotaSnapshotStillRelevant(quota, now) {
+  if (!quota)
+    return !1;
+  return cachedQuotaWindowStillRelevant(quota.primary, now) || cachedQuotaWindowStillRelevant(quota.secondary, now);
+}
+function quotaSnapshotIsFresh(quota, storage, now) {
+  if (!quota)
+    return !1;
+  const intervalMinutes = storage?.quota?.checkIntervalMinutes ?? 5, staleAfterMs = Math.max(1, intervalMinutes) * 60000, checkedAt = Math.max(quota.primary?.checkedAt ?? 0, quota.secondary?.checkedAt ?? 0);
+  return now - checkedAt < staleAfterMs;
+}
+function quotaIsStale(account, storage, now) {
+  return !quotaSnapshotIsFresh(account.quota, storage, now);
+}
+function canUseCachedQuotaAfterRefreshError(account, storage, error, now) {
+  return isTransientQuotaError(error) && quotaSnapshotPassesPolicy(account.quota, storage, now) && cachedQuotaSnapshotStillRelevant(account.quota, now);
+}
+export function getQuotaCheckIntervalMs(storage) {
+  const minutes = storage?.quota?.checkIntervalMinutes ?? 5;
+  return Math.max(1, minutes) * 60000;
+}
+const BACKGROUND_TICK_MS = 60000, BACKGROUND_TICK_JITTER_MS = 60000;
+export const FALLBACK_REFRESH_LOCK_TTL_MS = 600000;
+export function fallbackRefreshLockName(accountId) {
+  return `fallback-oauth-refresh-${createHash("sha256").update(accountId).digest("base64url").slice(0, 16)}`;
+}
+const FALLBACK_REFRESH_JOIN_WAIT_MS = 1e4, FALLBACK_REFRESH_JOIN_POLL_MS = 100;
+
+export class FallbackAccountManager {
+  now;
+  fetchImpl;
+  paths;
+  refreshPromises = new Map;
+  refreshTimer = null;
+  quotaTimer = null;
+  quotaManager;
+  onFallbackStorageChanged;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.paths = options.paths;
+    this.quotaManager = options.quotaManager ?? null;
+    this.onFallbackStorageChanged = options.onFallbackStorageChanged;
+  }
+  assertNotTombstoned(account) {
+    if (account)
+      assertNotTombstoneRefresh(account.refresh);
+  }
+  seedFallbackQuota(account, storage) {
+    if (!this.quotaManager)
+      return;
+    if (!account.quota)
+      return;
+    const checkedAt = Math.max(account.quota.primary?.checkedAt ?? 0, account.quota.secondary?.checkedAt ?? 0);
+    if (checkedAt <= 0)
+      return;
+    const existing = this.quotaManager.getFallback(account.id, account.access);
+    if (existing && existing.checkedAt >= checkedAt)
+      return;
+    this.quotaManager.setFallback(account.id, {
+      quota: account.quota,
+      refreshAfter: checkedAt + getQuotaCheckIntervalMs(storage),
+      checkedAt
+    }, account.access, !1, account.accountId);
+  }
+  async load() {
+    return loadAccounts(this.paths);
+  }
+  selectionBookkeeping = Promise.resolve();
+  selectionBookkeepingSettled() {
+    return this.selectionBookkeeping;
+  }
+  async save(storage, accountIds) {
+    await saveAccountState(storage, this.paths, {
+      accounts: accountIds ?? !0
+    }, this.options.canWrite);
+  }
+  startBackgroundRefresh() {
+    const run = async () => {
+      if (await this.options.backgroundRefreshPaused?.())
+        return;
+      await this.refreshDueAccounts();
+      if (this.options.fetchQuotaFn)
+        await this.refreshQuotaForDueAccounts();
+    };
+    run().catch(() => {});
+    if (!this.refreshTimer) {
+      this.refreshTimer = setInterval(() => {
+        run().catch(() => {});
+      }, BACKGROUND_TICK_MS + jitterMs(BACKGROUND_TICK_JITTER_MS));
+      if ("unref" in this.refreshTimer)
+        this.refreshTimer.unref();
+    }
+  }
+  stopBackgroundRefresh() {
+    if (this.refreshTimer)
+      clearInterval(this.refreshTimer);
+    if (this.quotaTimer)
+      clearInterval(this.quotaTimer);
+    this.refreshTimer = null;
+    this.quotaTimer = null;
+  }
+  async getUsableFallbackAccounts(existingStorage) {
+    const storage = existingStorage !== void 0 ? existingStorage : await this.load();
+    if (!storage)
+      return [];
+    const usable = [];
+    let changed = !1;
+    for (const account of storage.accounts) {
+      if (account.enabled === !1 || !isOAuthAccount(account))
+        continue;
+      if (isShieldedMainRow(storage, account))
+        continue;
+      if (isTombstoned(account))
+        continue;
+      let refreshFailed = !1, candidate = account;
+      try {
+        if (tokenNeedsRefresh(candidate, storage, this.now())) {
+          const refreshError = candidate.lastRefreshError;
+          if (refreshError && refreshBackoffActive(refreshError, candidate.refresh, this.now())) {
+            refreshFailed = !0;
+            throw Error(formatRefreshBackoffMessage(refreshError, this.now()));
+          }
+          try {
+            candidate = await this.refreshAccount(candidate, storage);
+            changed = !0;
+          } catch (error) {
+            if (isAccountRemovedDuringRefreshError(error))
+              continue;
+            refreshFailed = !0;
+            const stored = storage.accounts.find((candidate) => candidate.id === account.id && isOAuthAccount(candidate));
+            if (stored && !refreshBackoffActive(stored.lastRefreshError, stored.refresh, this.now())) {
+              recordRefreshError(stored, error, this.now());
+              updateStoredAccount(storage, stored);
+              changed = !0;
+            }
+            throw error;
+          }
+        }
+        this.seedFallbackQuota(candidate, storage);
+        if (this.accountPassesQuotaPolicy(this.quotaPolicyAccount(candidate), storage))
+          usable.push(candidate);
+      } catch (error) {
+        const hasUsableCandidateToken = hasUnexpiredAccessToken(candidate, this.now());
+        if (refreshFailed) {
+          if (!hasUsableCandidateToken)
+            continue;
+        } else if (!hasUsableCandidateToken)
+          continue;
+        if (canUseCachedQuotaAfterRefreshError(candidate, storage, error, this.now())) {
+          logR.debug("fallback quota using cached quota after refresh error", {
+            pid: process.pid,
+            accountId: candidate.id,
+            error: formatErrorMessage(error)
+          });
+          usable.push(candidate);
+        } else if (!failClosedOnUnknownQuota(storage))
+          usable.push(candidate);
+      }
+    }
+    if (changed) {
+      const snapshot = structuredClone(storage);
+      this.selectionBookkeeping = this.selectionBookkeeping.then(() => this.save(snapshot)).catch((error) => {
+        logA.warn("fallback selection bookkeeping not persisted", {
+          pid: process.pid,
+          error: formatErrorMessage(error)
+        });
+      });
+    }
+    return usable;
+  }
+  async markUsed(account) {
+    try {
+      const storage = await this.load();
+      if (!storage)
+        return;
+      const stored = storage.accounts.find((candidate) => candidate.id === account.id);
+      if (!stored)
+        return;
+      stored.lastUsed = this.now();
+      await this.save(storage, [stored.id]);
+    } catch (error) {
+      logA.warn("lastUsed stamp not persisted", {
+        pid: process.pid,
+        accountId: account.id,
+        error: formatErrorMessage(error)
+      });
+    }
+  }
+  accountPassesQuotaPolicy(account, storage) {
+    return quotaSnapshotPassesPolicy(account.quota, storage, this.now());
+  }
+  quotaPolicyAccount(account) {
+    if (!this.quotaManager)
+      return account;
+    const cached = this.quotaManager.getFallback(account.id, account.access)?.quota;
+    return cached ? { ...account, quota: cached } : account;
+  }
+  async refreshDueAccounts() {
+    const storage = await this.load();
+    if (!storage || !refreshEnabled(storage))
+      return;
+    let changed = !1;
+    for (const account of storage.accounts) {
+      if (account.enabled === !1 || !isOAuthAccount(account))
+        continue;
+      if (isShieldedMainRow(storage, account))
+        continue;
+      if (isTombstoned(account))
+        continue;
+      if (!tokenNeedsRefresh(account, storage, this.now()))
+        continue;
+      if (refreshBackoffActive(account.lastRefreshError, account.refresh, this.now()))
+        continue;
+      try {
+        logR.debug("fallback oauth background due", {
+          pid: process.pid,
+          accountId: account.id,
+          expiresInMs: account.expires ? account.expires - this.now() : void 0
+        });
+        await this.refreshAccount(account, storage);
+        changed = !0;
+      } catch (error) {
+        logR.warn("fallback oauth background failed", {
+          pid: process.pid,
+          accountId: account.id,
+          error: formatErrorMessage(error)
+        });
+        recordRefreshError(account, error, this.now());
+        updateStoredAccount(storage, account);
+        changed = !0;
+      }
+    }
+    if (changed)
+      await this.save(storage);
+  }
+  async refreshQuotaForDueAccounts() {
+    const storage = await this.load();
+    if (!storage || !quotaEnabled(storage))
+      return;
+    if (!this.options.fetchQuotaFn)
+      return;
+    let changed = !1;
+    for (const account of storage.accounts) {
+      if (account.enabled === !1 || !isOAuthAccount(account))
+        continue;
+      if (isShieldedMainRow(storage, account))
+        continue;
+      if (isTombstoned(account))
+        continue;
+      let next = account;
+      try {
+        if (tokenNeedsRefresh(next, storage, this.now())) {
+          if (refreshBackoffActive(next.lastRefreshError, next.refresh, this.now()))
+            continue;
+          next = await this.refreshAccount(next, storage);
+          changed = !0;
+        }
+        if (quotaBackoffActive(next.lastQuotaRefreshError, this.now()))
+          continue;
+        this.seedFallbackQuota(next, storage);
+        if (!(this.quotaManager ? this.quotaManager.isFallbackStale(next.id, next.access) : quotaIsStale(next, storage, this.now())))
+          continue;
+        await this.refreshAccountQuota(next, storage);
+        changed = !0;
+      } catch (error) {
+        recordQuotaRefreshError(account, error, this.now());
+        updateStoredAccount(storage, account);
+        changed = !0;
+      }
+    }
+    if (changed) {
+      await this.save(storage);
+      this.onFallbackStorageChanged?.();
+    }
+  }
+  async refreshQuotaForAllAccounts(options = {}) {
+    const storage = await this.load(), errors = [];
+    if (!storage || !quotaEnabled(storage))
+      return { storage, errors };
+    if (!this.options.fetchQuotaFn)
+      return { storage, errors };
+    const force = options.force ?? !1;
+    let changed = !1;
+    for (const account of storage.accounts) {
+      if (account.enabled === !1 || !isOAuthAccount(account))
+        continue;
+      if (isShieldedMainRow(storage, account))
+        continue;
+      if (isTombstoned(account))
+        continue;
+      let next = account;
+      try {
+        if (tokenNeedsRefresh(next, storage, this.now())) {
+          const refreshError = next.lastRefreshError;
+          if (refreshError && refreshBackoffActive(refreshError, next.refresh, this.now()))
+            throw Error(formatRefreshBackoffMessage(refreshError, this.now()));
+          next = await this.refreshAccount(next, storage);
+          changed = !0;
+        }
+        if (!force && !quotaIsStale(next, storage, this.now())) {
+          if (next.lastQuotaRefreshError) {
+            next.lastQuotaRefreshError = void 0;
+            updateStoredAccount(storage, next);
+            changed = !0;
+          }
+          continue;
+        }
+        await this.refreshAccountQuota(next, storage);
+        changed = !0;
+      } catch (error) {
+        recordQuotaRefreshError(account, error, this.now());
+        updateStoredAccount(storage, account);
+        changed = !0;
+        errors.push({
+          accountId: account.id,
+          message: formatErrorMessage(error)
+        });
+      }
+    }
+    if (changed)
+      await this.save(storage);
+    return { storage, errors };
+  }
+  async refreshAccount(account, storage, options = {}) {
+    const existing = this.refreshPromises.get(account.id);
+    if (existing) {
+      const refreshed = await existing;
+      updateStoredAccount(storage, refreshed);
+      return refreshed;
+    }
+    const promise = this.refreshAccountNow(account, storage, options).finally(() => {
+      this.refreshPromises.delete(account.id);
+    });
+    this.refreshPromises.set(account.id, promise);
+    const refreshed = await promise;
+    updateStoredAccount(storage, refreshed);
+    return refreshed;
+  }
+  async waitForConcurrentFallbackRefresh(account, storage, previous, options) {
+    const deadline = Date.now() + FALLBACK_REFRESH_JOIN_WAIT_MS;
+    while (Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, FALLBACK_REFRESH_JOIN_POLL_MS));
+      const latestStorage = await this.load(), latestAccount = latestStorage?.accounts.find((candidate) => candidate.id === account.id && isOAuthAccount(candidate));
+      if (!latestAccount)
+        continue;
+      this.assertNotTombstoned(latestAccount);
+      if ((latestAccount.access !== previous.access || latestAccount.refresh !== previous.refresh || (latestAccount.expires ?? 0) > (previous.expires ?? 0) + 60000) && (options.force || !tokenNeedsRefresh(latestAccount, latestStorage, this.now()))) {
+        updateStoredAccount(storage, latestAccount);
+        logR.debug("fallback oauth joined concurrent refresh", {
+          pid: process.pid,
+          accountId: latestAccount.id,
+          expiresInMs: latestAccount.expires ? latestAccount.expires - this.now() : void 0
+        });
+        return latestAccount;
+      }
+      const refreshError = latestAccount.lastRefreshError;
+      if (refreshError && refreshBackoffActive(refreshError, latestAccount.refresh, this.now())) {
+        updateStoredAccount(storage, latestAccount);
+        throw Error(formatRefreshBackoffMessage(refreshError, this.now()));
+      }
+    }
+    return null;
+  }
+  assertNotShieldedMainRow(storage, account, options) {
+    if (options.asPoolMain || !account)
+      return;
+    if (isShieldedMainRow(storage, account))
+      throw new ShieldedMainRowRefreshError(account.id);
+  }
+  async refreshAccountNow(account, storage, options) {
+    let latestStorage = await this.load(), latestAccount = latestStorage?.accounts.find((candidate) => candidate.id === account.id && isOAuthAccount(candidate));
+    this.assertNotTombstoned(latestAccount);
+    this.assertNotShieldedMainRow(latestStorage, latestAccount, options);
+    if (latestAccount && !options.force && !tokenNeedsRefresh(latestAccount, latestStorage, this.now())) {
+      updateStoredAccount(storage, latestAccount);
+      return latestAccount;
+    }
+    let sourceAccount = latestAccount ?? account;
+    const fileLock = await acquireRefreshFileLock({
+      name: fallbackRefreshLockName(sourceAccount.id),
+      ttlMs: FALLBACK_REFRESH_LOCK_TTL_MS,
+      path: this.paths.configPath,
+      renew: !0
+    });
+    if (!fileLock) {
+      logR.debug("fallback oauth refresh skipped file lock", {
+        pid: process.pid,
+        accountId: sourceAccount.id
+      });
+      const concurrent = await this.waitForConcurrentFallbackRefresh(account, storage, sourceAccount, options);
+      if (concurrent)
+        return concurrent;
+      throw Error("Fallback OAuth refresh is already in progress");
+    }
+    try {
+      latestStorage = await this.load();
+      latestAccount = latestStorage?.accounts.find((candidate) => candidate.id === account.id && isOAuthAccount(candidate));
+      this.assertNotTombstoned(latestAccount);
+      this.assertNotShieldedMainRow(latestStorage, latestAccount, options);
+      if (latestAccount && !options.force && !tokenNeedsRefresh(latestAccount, latestStorage, this.now())) {
+        updateStoredAccount(storage, latestAccount);
+        return latestAccount;
+      }
+      if (!latestAccount)
+        throw new AccountRemovedDuringRefreshError(account.id);
+      sourceAccount = latestAccount;
+      const providerRefreshFn = this.options.refreshFn ?? (async () => {
+        throw Error("No refreshFn injected into FallbackAccountManager");
+      });
+      logR.debug("fallback oauth refresh request start", {
+        pid: process.pid,
+        accountId: sourceAccount.id,
+        force: options.force === !0,
+        expiresInMs: sourceAccount.expires ? sourceAccount.expires - this.now() : void 0
+      });
+      const refreshed = await providerRefreshFn({
+        refreshToken: sourceAccount.refresh,
+        fetchImpl: this.fetchImpl,
+        now: this.now
+      });
+      sourceAccount.access = refreshed.access;
+      sourceAccount.refresh = refreshed.refresh;
+      sourceAccount.expires = refreshed.expires;
+      sourceAccount.lastRefreshedAt = refreshed.expires - refreshed.expiresIn * 1000;
+      sourceAccount.lastRefreshError = void 0;
+      updateStoredAccount(storage, sourceAccount);
+      await this.save(storage);
+      if (!(await this.load())?.accounts.some((candidate) => candidate.id === account.id))
+        throw new AccountRemovedDuringRefreshError(account.id);
+      logR.debug("fallback oauth refresh succeeded", {
+        pid: process.pid,
+        accountId: sourceAccount.id,
+        expiresInMs: sourceAccount.expires ? sourceAccount.expires - this.now() : void 0
+      });
+      return sourceAccount;
+    } finally {
+      await fileLock.release();
+    }
+  }
+  async refreshAccountQuota(account, storage) {
+    const target = account;
+    this.assertNotTombstoned(target);
+    if (!target.access)
+      throw Error(`Fallback account ${account.id} has no access token`);
+    if (!this.options.fetchQuotaFn)
+      throw Error("No fetchQuotaFn injected \u2014 wham/usage supplement is disabled");
+    const snapshotFn = this.options.fetchQuotaFn ?? (async () => {
+      throw Error("No fetchQuotaFn injected \u2014 wham/usage supplement is disabled");
+    }), fetchSnapshot = (accessToken) => this.quotaManager ? this.quotaManager.refreshFallback(target.id, accessToken) : snapshotFn({
+      accessToken,
+      fetchImpl: this.fetchImpl,
+      now: this.now
+    });
+    try {
+      if (!target.access)
+        throw Error(`Fallback account ${account.id} has no access token`);
+      const quota = await fetchSnapshot(target.access);
+      target.quota = quota;
+      target.lastQuotaRefreshError = void 0;
+      updateStoredAccount(storage, target);
+      await this.save(storage);
+    } catch (error) {
+      recordQuotaRefreshError(account, error, this.now());
+      updateStoredAccount(storage, account);
+      throw error;
+    }
+  }
+}