@cortexkit/opencode-openai-auth 0.11.1 → 1.0.0

package/src/tui-compiled/raw/sidebar-state.js

@@ -0,0 +1,960 @@
+import {
+  formatQuota,
+  projectQuota,
+  quotaWindowName
+} from "./shared/d5a8f1061ee2f114-index.js";
+const QUOTA_WINDOW_KEYS = ["primary", "secondary"], LEGACY_WINDOW_MINUTES = {
+  primary: 300,
+  secondary: 10080
+};
+export function formatWindowLabel(windowMinutes, fallbackKey) {
+  return quotaWindowName({ scope: "all", label: fallbackKey, windowMinutes });
+}
+export function getPresentQuotaWindows(quota) {
+  if (!quota)
+    return [];
+  const rows = [];
+  for (const key of QUOTA_WINDOW_KEYS) {
+    const window = quota[key];
+    if (!window)
+      continue;
+    const configuredMinutes = window.windowMinutes, windowMinutes = configuredMinutes !== void 0 && Number.isFinite(configuredMinutes) && configuredMinutes > 0 ? configuredMinutes : LEGACY_WINDOW_MINUTES[key];
+    rows.push({
+      key,
+      label: formatWindowLabel(configuredMinutes, key),
+      window,
+      windowMs: windowMinutes * 60000
+    });
+  }
+  return rows;
+}
+import { createHash } from "node:crypto";
+import { constants, copyFileSync, mkdirSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import {
+  createSidebarFile
+} from "./shared/7a91bb630e6f4804-index.js";
+import { createLogger } from "./logger.js";
+const logSb = createLogger("sidebar"), STATE_FILE_ENV = "OPENCODE_OPENAI_AUTH_SIDEBAR_STATE_FILE";
+function defaultStateFile() {
+  const base = process.env.XDG_STATE_HOME || join(homedir(), ".local", "state");
+  return join(base, "cortexkit", "openai-auth", "sidebar-state.json");
+}
+let legacySidebarStateFile = join(tmpdir(), "opencode-openai-auth", "sidebar-state.json");
+export function setLegacySidebarStateFileForTest(file) {
+  legacySidebarStateFile = file;
+  importedDefaultFiles.clear();
+}
+const SESSION_HASH_PATTERN = /^[a-f0-9]{64}$/;
+export const STICKY_ASSIGNMENT_MAX_AGE_MS = 604800000, STICKY_ASSIGNMENT_MAX_ENTRIES = 256;
+const STICKY_ASSIGNMENT_LAST_SEEN_TOUCH_MS = 3600000;
+export function hashSidebarSessionId(sessionId) {
+  return createHash("sha256").update(sessionId).digest("hex");
+}
+function normalizeResetCredits(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function resetCreditsField(value) {
+  const credits = normalizeResetCredits(value);
+  return credits !== void 0 ? { resetCredits: credits } : {};
+}
+function normalizeActiveRouting(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return;
+  const normalized = {};
+  for (const [sessionId, rawEntry] of Object.entries(value)) {
+    if (rawEntry === null || typeof rawEntry !== "object" || Array.isArray(rawEntry))
+      continue;
+    const entry = rawEntry;
+    if (typeof entry.activeId !== "string" || typeof entry.route !== "string" || typeof entry.updatedAt !== "number" || !Number.isFinite(entry.updatedAt))
+      continue;
+    normalized[sessionId] = {
+      activeId: entry.activeId,
+      route: entry.route,
+      updatedAt: entry.updatedAt
+    };
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function normalizeStickyAssignments(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return;
+  const normalized = {};
+  for (const [sessionHash, rawAssignment] of Object.entries(value)) {
+    if (!SESSION_HASH_PATTERN.test(sessionHash) || rawAssignment === null || typeof rawAssignment !== "object" || Array.isArray(rawAssignment))
+      continue;
+    const assignment = rawAssignment;
+    if (typeof assignment.accountId !== "string" || assignment.accountId.length === 0 || typeof assignment.assignedAt !== "number" || !Number.isFinite(assignment.assignedAt) || assignment.assignedAt < 0 || typeof assignment.lastSeenAt !== "number" || !Number.isFinite(assignment.lastSeenAt) || assignment.lastSeenAt < 0 || typeof assignment.inputBytes !== "number" || !Number.isFinite(assignment.inputBytes) || assignment.inputBytes < 0)
+      continue;
+    const quotaCheckedAt = assignment.quotaCheckedAt;
+    if (quotaCheckedAt !== void 0 && (typeof quotaCheckedAt !== "number" || !Number.isFinite(quotaCheckedAt) || quotaCheckedAt < 0))
+      continue;
+    const wireAccountId = assignment.wireAccountId;
+    normalized[sessionHash] = {
+      accountId: assignment.accountId,
+      assignedAt: assignment.assignedAt,
+      lastSeenAt: assignment.lastSeenAt,
+      inputBytes: assignment.inputBytes,
+      ...quotaCheckedAt === void 0 ? {} : { quotaCheckedAt },
+      ...typeof wireAccountId === "string" ? { wireAccountId } : {}
+    };
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+export function getSidebarStateFile() {
+  const override = process.env[STATE_FILE_ENV];
+  if (override)
+    return override;
+  const file = defaultStateFile();
+  if (!importedDefaultFiles.has(file)) {
+    importedDefaultFiles.add(file);
+    importLegacySidebarState(file, legacySidebarStateFile);
+  }
+  return file;
+}
+const importedDefaultFiles = new Set;
+function importLegacySidebarState(file, legacyFile) {
+  try {
+    mkdirSync(dirname(file), { recursive: !0, mode: 448 });
+    copyFileSync(legacyFile, file, constants.COPYFILE_EXCL);
+  } catch {}
+}
+export const DEFAULT_SIDEBAR_STATE = {
+  main: { quota: null, killed: !1 },
+  fallbacks: [],
+  activeId: void 0,
+  route: "main",
+  lastUpdated: 0
+};
+export function normalizeSidebarState(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+    return DEFAULT_SIDEBAR_STATE;
+  const r = raw, rawMain = r.main;
+  let main;
+  if (rawMain !== null && typeof rawMain === "object" && !Array.isArray(rawMain)) {
+    const m = rawMain;
+    main = {
+      quota: "quota" in m ? m.quota : null,
+      killed: typeof m.killed === "boolean" ? m.killed : !1,
+      ...typeof m.mainAccountId === "string" ? { mainAccountId: m.mainAccountId } : {},
+      ...typeof m.quotaBackedOff === "boolean" ? { quotaBackedOff: m.quotaBackedOff } : {},
+      ...typeof m.quotaBackoffUntil === "number" ? { quotaBackoffUntil: m.quotaBackoffUntil } : {},
+      ...typeof m.refreshBackedOff === "boolean" ? { refreshBackedOff: m.refreshBackedOff } : {},
+      ...typeof m.refreshBackoffUntil === "number" ? { refreshBackoffUntil: m.refreshBackoffUntil } : {},
+      ...resetCreditsField(m.resetCredits)
+    };
+  } else
+    main = { quota: null, killed: !1 };
+  const fallbacks = normalizeAccountList(r.fallbacks), vaultAccounts = Array.isArray(r.vaultAccounts) ? normalizeAccountList(r.vaultAccounts) : void 0, activeId = typeof r.activeId === "string" ? r.activeId : void 0, route = typeof r.route === "string" ? r.route : DEFAULT_SIDEBAR_STATE.route, lastUpdated = typeof r.lastUpdated === "number" ? r.lastUpdated : 0, planType = typeof r.planType === "string" ? r.planType : void 0, credits = typeof r.credits === "number" ? r.credits : void 0, activeRouting = normalizeActiveRouting(r.activeRouting), stickyAssignments = normalizeStickyAssignments(r.stickyAssignments);
+  return {
+    main,
+    fallbacks,
+    activeId,
+    route,
+    lastUpdated,
+    ...activeRouting !== void 0 ? { activeRouting } : {},
+    ...stickyAssignments !== void 0 ? { stickyAssignments } : {},
+    ...planType !== void 0 ? { planType } : {},
+    ...credits !== void 0 ? { credits } : {},
+    ...r.accountPool === !0 ? { accountPool: !0 } : {},
+    ...vaultAccounts !== void 0 ? { vaultAccounts } : {}
+  };
+}
+function normalizeAccountList(raw) {
+  if (!Array.isArray(raw))
+    return [];
+  return raw.filter((entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry) && typeof entry.id === "string").map((e) => ({
+    id: e.id,
+    label: typeof e.label === "string" ? e.label : void 0,
+    ...typeof e.accountId === "string" ? { accountId: e.accountId } : {},
+    quota: "quota" in e ? e.quota : null,
+    killed: typeof e.killed === "boolean" ? e.killed : !1,
+    enabled: typeof e.enabled === "boolean" ? e.enabled : !0,
+    ...resetCreditsField(e.resetCredits)
+  }));
+}
+function routingAccountsOf(state) {
+  return [...state.fallbacks, ...state.vaultAccounts ?? []];
+}
+export async function getSidebarState(stateFile = getSidebarStateFile()) {
+  try {
+    const raw = await readFile(stateFile, "utf8");
+    return normalizeSidebarState(JSON.parse(raw));
+  } catch {
+    return DEFAULT_SIDEBAR_STATE;
+  }
+}
+export const ACTIVE_ROUTING_MAX_AGE_MS = 3600000, ACTIVE_ROUTING_MAX_ENTRIES = 128;
+export function isUsableRoutingEntry(entry, accounts, now = Date.now()) {
+  if (!(entry.updatedAt >= now - ACTIVE_ROUTING_MAX_AGE_MS && entry.updatedAt <= now))
+    return !1;
+  if (accounts === void 0)
+    return !0;
+  return entry.activeId === "main" || accounts.some((account) => account.enabled !== !1 && account.killed !== !0 && account.id === entry.activeId);
+}
+export function spendControlExhaustedResetAt(quota, now = Date.now()) {
+  const spendControl = quota?.spendControl;
+  if (spendControl?.reached !== !0 || typeof spendControl.resetsAt !== "string")
+    return;
+  const resetAtMs = Date.parse(spendControl.resetsAt);
+  if (!Number.isFinite(resetAtMs) || resetAtMs <= now)
+    return;
+  return { resetsAt: spendControl.resetsAt, resetAtMs };
+}
+export function exhaustedQuotaResetAt(quota, now = Date.now()) {
+  let earliest;
+  for (const key of QUOTA_WINDOW_KEYS) {
+    const window = quota?.[key];
+    if (typeof window?.resetsAt !== "string" || !Number.isFinite(window.usedPercent) || window.usedPercent < 100)
+      continue;
+    const resetAtMs = Date.parse(window.resetsAt);
+    if (!Number.isFinite(resetAtMs) || resetAtMs <= now)
+      continue;
+    if (!earliest || resetAtMs < earliest.resetAtMs)
+      earliest = { resetsAt: window.resetsAt, resetAtMs };
+  }
+  const spendReset = spendControlExhaustedResetAt(quota, now);
+  if (spendReset && (!earliest || spendReset.resetAtMs < earliest.resetAtMs))
+    earliest = spendReset;
+  return earliest;
+}
+export function isQuotaExhausted(quota, now = Date.now()) {
+  return exhaustedQuotaResetAt(quota, now) !== void 0;
+}
+export function resolveSessionStickyAccount(state, sessionId, now = Date.now()) {
+  if (!sessionId || state.route !== "sticky-balanced")
+    return;
+  const assignment = state.stickyAssignments?.[hashSidebarSessionId(sessionId)];
+  if (!assignment || assignment.lastSeenAt < now - STICKY_ASSIGNMENT_MAX_AGE_MS)
+    return;
+  if (assignment.accountId === "main")
+    return state.main?.killed || isQuotaExhausted(state.main?.quota, now) ? void 0 : "main";
+  const fallback = routingAccountsOf(state).find((account) => account.id === assignment.accountId);
+  if (!fallback || fallback.enabled === !1 || fallback.killed === !0 || isQuotaExhausted(fallback.quota, now))
+    return;
+  return fallback.id;
+}
+export function resolveSessionSidebarRouting(state, sessionId, now = Date.now()) {
+  if (!sessionId)
+    return { activeId: state.activeId ?? "main", route: state.route };
+  const own = sessionId ? state.activeRouting?.[sessionId] : void 0, accounts = routingAccountsOf(state), ownQuota = own?.activeId === "main" ? state.main.quota : accounts.find((account) => account.id === own?.activeId)?.quota;
+  if (own && isUsableRoutingEntry(own, accounts, now) && !isQuotaExhausted(ownQuota, now))
+    return { activeId: own.activeId, route: own.route };
+  const stickyAccountId = resolveSessionStickyAccount(state, sessionId, now);
+  if (stickyAccountId)
+    return { activeId: stickyAccountId, route: state.route };
+  const vaultMode = state.vaultAccounts !== void 0, enabledFallbacks = (vaultMode ? state.vaultAccounts ?? [] : state.fallbacks).filter((account) => account.enabled && !account.killed), fallback = enabledFallbacks.find((account) => !isQuotaExhausted(account.quota, now)) ?? enabledFallbacks[0];
+  return {
+    activeId: (vaultMode || state.route === "fallback-first") && fallback ? fallback.id : "main",
+    route: state.route
+  };
+}
+export function pruneActiveRouting(activeRouting, accounts, now = Date.now(), removedSessionId) {
+  if (!activeRouting)
+    return;
+  const kept = Object.entries(activeRouting).filter(([sessionId, entry]) => sessionId !== removedSessionId && isUsableRoutingEntry(entry, accounts, now)), bounded = kept.length <= ACTIVE_ROUTING_MAX_ENTRIES ? kept : kept.sort((left, right) => right[1].updatedAt - left[1].updatedAt).slice(0, ACTIVE_ROUTING_MAX_ENTRIES);
+  return bounded.length > 0 ? Object.fromEntries(bounded) : void 0;
+}
+export function pruneStickyAssignments(assignments, validAccountIds, now = Date.now(), removedSessionHash) {
+  if (!assignments)
+    return;
+  let accountNotInRoster = 0, expired = 0, explicitRemoval = 0;
+  const kept = [];
+  for (const [sessionHash, assignment] of Object.entries(assignments)) {
+    if (sessionHash === removedSessionHash) {
+      explicitRemoval += 1;
+      continue;
+    }
+    if (assignment.lastSeenAt < now - STICKY_ASSIGNMENT_MAX_AGE_MS) {
+      expired += 1;
+      continue;
+    }
+    if (validAccountIds !== void 0 && !validAccountIds.has(assignment.accountId)) {
+      accountNotInRoster += 1;
+      continue;
+    }
+    kept.push([sessionHash, assignment]);
+  }
+  const removed = accountNotInRoster + expired + explicitRemoval;
+  if (removed > 0)
+    logSb.debug("pruned sticky assignments", {
+      pid: process.pid,
+      removed,
+      reasons: {
+        "account-not-in-roster": accountNotInRoster,
+        expired,
+        "explicit-removal": explicitRemoval
+      }
+    });
+  return kept.length > 0 ? Object.fromEntries(kept) : void 0;
+}
+function limitStickyAssignments(assignments, protectedSessionHash) {
+  const overflow = Object.keys(assignments).length - STICKY_ASSIGNMENT_MAX_ENTRIES;
+  if (overflow <= 0)
+    return assignments;
+  const evicted = new Set(Object.entries(assignments).filter(([sessionHash]) => sessionHash !== protectedSessionHash).sort(([leftHash, left], [rightHash, right]) => left.lastSeenAt - right.lastSeenAt || leftHash.localeCompare(rightHash)).slice(0, overflow).map(([sessionHash]) => sessionHash));
+  return Object.fromEntries(Object.entries(assignments).filter(([sessionHash]) => !evicted.has(sessionHash)));
+}
+function stickyAssignmentsEqual(left, right) {
+  if (left === right)
+    return !0;
+  if (!left || !right)
+    return !1;
+  const leftEntries = Object.entries(left);
+  if (leftEntries.length !== Object.keys(right).length)
+    return !1;
+  return leftEntries.every(([sessionHash, assignment]) => Object.is(right[sessionHash], assignment));
+}
+function isValidStickyAssignment(assignment, validPinnedAccountIds, excludedAccountIds, now) {
+  return assignment !== void 0 && validPinnedAccountIds.has(assignment.accountId) && !excludedAccountIds.has(assignment.accountId) && assignment.lastSeenAt >= now - STICKY_ASSIGNMENT_MAX_AGE_MS;
+}
+function stickyAssignmentNeedsMetadataUpdate(assignment, requestBytes, now, wireAccountId) {
+  return requestBytes > assignment.inputBytes || now - assignment.lastSeenAt >= STICKY_ASSIGNMENT_LAST_SEEN_TOUCH_MS || assignment.wireAccountId === void 0 && wireAccountId !== void 0;
+}
+function hasStickyIdentityMismatch(assignment, wireAccountId) {
+  return typeof assignment.wireAccountId === "string" && typeof wireAccountId === "string" && assignment.wireAccountId !== wireAccountId;
+}
+function readonlyPendingBytes(pendingBytes) {
+  const snapshot = new Map(pendingBytes), view = {
+    get size() {
+      return snapshot.size;
+    },
+    has: (key) => snapshot.has(key),
+    get: (key) => snapshot.get(key),
+    entries: () => snapshot.entries(),
+    keys: () => snapshot.keys(),
+    values: () => snapshot.values(),
+    forEach: (callback, thisArg) => {
+      snapshot.forEach((value, key) => {
+        callback.call(thisArg, value, key, view);
+      });
+    },
+    [Symbol.iterator]: () => snapshot[Symbol.iterator]()
+  };
+  return Object.freeze(view);
+}
+function pendingBytesForAssignments(assignments, quotaCheckedAtByAccount, excludedSessionHash) {
+  const pendingBytes = new Map;
+  for (const [sessionHash, assignment] of Object.entries(assignments ?? {})) {
+    if (sessionHash === excludedSessionHash)
+      continue;
+    if (assignment.quotaCheckedAt !== quotaCheckedAtByAccount[assignment.accountId])
+      continue;
+    pendingBytes.set(assignment.accountId, (pendingBytes.get(assignment.accountId) ?? 0) + assignment.inputBytes);
+  }
+  return readonlyPendingBytes(pendingBytes);
+}
+function usableRoutingAccountIds(accounts) {
+  if (accounts === void 0)
+    return;
+  return new Set([
+    "main",
+    ...accounts.filter((account) => account.enabled !== !1 && account.killed !== !0).map((account) => account.id)
+  ]);
+}
+let sidebarWriteChain = Promise.resolve();
+function enqueueSidebarWrite(operation) {
+  const result = sidebarWriteChain.then(operation);
+  sidebarWriteChain = result.catch(() => {});
+  return result;
+}
+const sidebarFiles = new Map;
+function sidebarFileFor(file) {
+  let sidebarFile = sidebarFiles.get(file);
+  if (!sidebarFile) {
+    sidebarFile = createSidebarFile({
+      path: file,
+      defaultValue: DEFAULT_SIDEBAR_STATE,
+      normalize: normalizeSidebarState,
+      secureDir: file === defaultStateFile(),
+      logger: logSb
+    });
+    sidebarFiles.set(file, sidebarFile);
+  }
+  return sidebarFile;
+}
+const failingSidebarFiles = new Set;
+async function logWriteFailure(file, write) {
+  try {
+    await write;
+  } catch (e) {
+    const fields = {
+      pid: process.pid,
+      error: e instanceof Error ? e.message : String(e)
+    };
+    if (failingSidebarFiles.has(file))
+      logSb.debug("sidebar write failed again", fields);
+    else {
+      failingSidebarFiles.add(file);
+      logSb.warn("sidebar write failed", fields);
+    }
+    throw e;
+  }
+  if (failingSidebarFiles.delete(file))
+    logSb.info("sidebar write recovered", { pid: process.pid });
+}
+export function setSidebarState(state, file = getSidebarStateFile()) {
+  return enqueueSidebarWrite(() => logWriteFailure(file, sidebarFileFor(file).write(normalizeSidebarState(state))));
+}
+function readSidebarState(file) {
+  return sidebarFileFor(file).read();
+}
+function writeMergedSidebarState(file, merge, hooks) {
+  const refused = Symbol("sidebar authority changed");
+  return logWriteFailure(file, sidebarFileFor(file).update((latest) => {
+    if (hooks?.canWrite && !hooks.canWrite())
+      return;
+    const next = merge(latest);
+    return next === void 0 ? void 0 : normalizeSidebarState(next);
+  }, {
+    beforeRecheck: async (...args) => {
+      await hooks?.beforeRecheck?.(...args);
+      if (hooks?.canWrite && !hooks.canWrite())
+        throw refused;
+    }
+  }).catch((error) => {
+    if (error !== refused)
+      throw error;
+  }));
+}
+function latestQuotaCheckedAt(quota) {
+  let latest;
+  for (const checkedAt of [
+    quota?.primary?.checkedAt,
+    quota?.secondary?.checkedAt,
+    quota?.checkedAt
+  ])
+    if (typeof checkedAt === "number" && Number.isFinite(checkedAt))
+      latest = latest === void 0 ? checkedAt : Math.max(latest, checkedAt);
+  return latest;
+}
+function freshestQuota(incoming, existing) {
+  const incomingCheckedAt = latestQuotaCheckedAt(incoming), existingCheckedAt = latestQuotaCheckedAt(existing);
+  if (existingCheckedAt !== void 0 && (incomingCheckedAt === void 0 || existingCheckedAt > incomingCheckedAt))
+    return existing;
+  return incoming;
+}
+function sameAccountIdentity(incoming, existing) {
+  return incoming !== void 0 && existing !== void 0 && incoming === existing;
+}
+function finiteWindowCheckedAt(window, fallback) {
+  const checkedAt = window?.checkedAt;
+  if (typeof checkedAt === "number" && Number.isFinite(checkedAt))
+    return checkedAt;
+  if (typeof fallback === "number" && Number.isFinite(fallback))
+    return fallback;
+  return;
+}
+function freshestWindow(incoming, existing, existingSnapshotIsFresher, incomingSnapshotCheckedAt, existingSnapshotCheckedAt) {
+  if (incoming && existing) {
+    const incomingAt = finiteWindowCheckedAt(incoming, incomingSnapshotCheckedAt), existingAt = finiteWindowCheckedAt(existing, existingSnapshotCheckedAt);
+    if (existingAt !== void 0 && (incomingAt === void 0 || existingAt > incomingAt))
+      return existing;
+    return incoming;
+  }
+  return existingSnapshotIsFresher ? existing : incoming;
+}
+function mergeSpendControl(fresher, older) {
+  if (fresher.spendControl !== void 0)
+    return fresher.spendControl;
+  if (fresher.spendControlCleared === !0)
+    return;
+  return older.spendControl;
+}
+function mergeQuotaByWindow(incoming, existing) {
+  if (!incoming)
+    return existing;
+  if (!existing)
+    return incoming;
+  const incomingAt = latestQuotaCheckedAt(incoming), existingAt = latestQuotaCheckedAt(existing), existingSnapshotIsFresher = existingAt !== void 0 && (incomingAt === void 0 || existingAt > incomingAt), primary = freshestWindow(incoming.primary, existing.primary, existingSnapshotIsFresher, incoming.checkedAt, existing.checkedAt), secondary = freshestWindow(incoming.secondary, existing.secondary, existingSnapshotIsFresher, incoming.checkedAt, existing.checkedAt), spendControl = existingSnapshotIsFresher ? mergeSpendControl(existing, incoming) : mergeSpendControl(incoming, existing), spendControlCleared = spendControl === void 0 && (incoming.spendControlCleared === !0 || existing.spendControlCleared === !0);
+  let checkedAt;
+  for (const stamp of [
+    finiteWindowCheckedAt(primary),
+    finiteWindowCheckedAt(secondary)
+  ])
+    if (stamp !== void 0)
+      checkedAt = checkedAt === void 0 ? stamp : Math.max(checkedAt, stamp);
+  const {
+    spendControl: _incomingSpendControl,
+    spendControlCleared: _incomingCleared,
+    ...incomingRest
+  } = incoming;
+  return {
+    ...incomingRest,
+    primary,
+    secondary,
+    ...spendControl !== void 0 ? { spendControl } : {},
+    ...spendControlCleared ? { spendControlCleared: !0 } : {},
+    checkedAt: checkedAt ?? incoming.checkedAt
+  };
+}
+export function setSidebarMachineState(machineState, file = getSidebarStateFile(), hooks) {
+  return enqueueSidebarWrite(async () => {
+    await writeMergedSidebarState(file, (latest) => {
+      const latestFallbacks = new Map(latest.fallbacks.map((account) => [account.id, account])), mainSameIdentity = sameAccountIdentity(machineState.main.mainAccountId, latest.main.mainAccountId), mergedMainQuota = mainSameIdentity ? mergeQuotaByWindow(machineState.main.quota, latest.main.quota) : freshestQuota(machineState.main.quota, latest.main.quota), now = Date.now(), stickyAssignments = pruneStickyAssignments(latest.stickyAssignments, usableRoutingAccountIds(routingAccountsOf(machineState)), now);
+      return {
+        ...latest,
+        ...machineState,
+        main: {
+          ...machineState.main,
+          quota: mergedMainQuota,
+          mainAccountId: mainSameIdentity ? machineState.main.mainAccountId : mergedMainQuota === latest.main.quota && mergedMainQuota !== machineState.main.quota ? latest.main.mainAccountId : machineState.main.mainAccountId
+        },
+        fallbacks: machineState.fallbacks.map((account) => {
+          const existing = latestFallbacks.get(account.id), fallbackSameIdentity = sameAccountIdentity(account.accountId, existing?.accountId), mergedQuota = fallbackSameIdentity ? mergeQuotaByWindow(account.quota, existing?.quota ?? null) : freshestQuota(account.quota, existing?.quota ?? null);
+          return {
+            ...account,
+            quota: mergedQuota,
+            accountId: fallbackSameIdentity ? account.accountId : mergedQuota === existing?.quota && mergedQuota !== account.quota ? existing?.accountId : account.accountId
+          };
+        }),
+        activeId: latest.activeId,
+        activeRouting: latest.activeRouting,
+        stickyAssignments,
+        lastUpdated: Math.max(now, latest.lastUpdated + 1),
+        accountPool: machineState.accountPool === !0 ? !0 : void 0,
+        vaultAccounts: machineState.vaultAccounts
+      };
+    }, hooks);
+  });
+}
+export function upsertSidebarActiveRouting(input, accounts, file = getSidebarStateFile(), hooks) {
+  return enqueueSidebarWrite(async () => {
+    await writeMergedSidebarState(file, (latest) => {
+      const activeRouting = pruneActiveRouting({
+        ...latest.activeRouting,
+        [input.sessionId]: {
+          activeId: input.activeId,
+          route: input.route,
+          updatedAt: input.updatedAt
+        }
+      }, accounts, Date.now()), stickyAssignments = pruneStickyAssignments(latest.stickyAssignments, usableRoutingAccountIds(accounts), Date.now());
+      return {
+        ...latest,
+        activeId: input.activeId,
+        route: input.route,
+        activeRouting,
+        stickyAssignments,
+        lastUpdated: Math.max(Date.now(), latest.lastUpdated + 1)
+      };
+    }, hooks);
+  });
+}
+export function setSidebarLegacyRouting(input, file = getSidebarStateFile(), hooks) {
+  return enqueueSidebarWrite(async () => {
+    await writeMergedSidebarState(file, (latest) => ({
+      ...latest,
+      activeId: input.activeId,
+      route: input.route,
+      lastUpdated: Math.max(Date.now(), latest.lastUpdated + 1)
+    }), hooks);
+  });
+}
+export function removeSidebarActiveRouting(sessionId, accounts, file = getSidebarStateFile(), hooks) {
+  return enqueueSidebarWrite(async () => {
+    await writeMergedSidebarState(file, (latest) => {
+      const now = Date.now(), activeRouting = pruneActiveRouting(latest.activeRouting, accounts, now, sessionId), stickyAssignments = pruneStickyAssignments(latest.stickyAssignments, usableRoutingAccountIds(accounts), now, hashSidebarSessionId(sessionId));
+      return {
+        ...latest,
+        activeRouting,
+        stickyAssignments,
+        lastUpdated: Math.max(Date.now(), latest.lastUpdated + 1)
+      };
+    }, hooks);
+  });
+}
+function stickyAssignmentIsCurrent(existing, input) {
+  return isValidStickyAssignment(existing, new Set(input.validPinnedAccountIds), new Set(input.excludeAccountIds), input.now) && !hasStickyIdentityMismatch(existing, input.wireAccountIdByAccount?.[existing.accountId]) && !stickyAssignmentNeedsMetadataUpdate(existing, input.requestBytes, input.now, input.wireAccountIdByAccount?.[existing.accountId]);
+}
+export function planSidebarStickyAssignment(latest, input) {
+  const sessionHash = hashSidebarSessionId(input.sessionId), validPinnedAccountIds = new Set(input.validPinnedAccountIds), excludedAccountIds = new Set(input.excludeAccountIds), stickyAssignments = pruneStickyAssignments(latest.stickyAssignments, validPinnedAccountIds, input.now), assignmentsPruned = !stickyAssignmentsEqual(latest.stickyAssignments, stickyAssignments), current = stickyAssignments?.[sessionHash], currentIdentityMismatch = current !== void 0 && hasStickyIdentityMismatch(current, input.wireAccountIdByAccount?.[current.accountId]);
+  if (isValidStickyAssignment(current, validPinnedAccountIds, excludedAccountIds, input.now) && !currentIdentityMismatch) {
+    const metadataNeedsUpdate = stickyAssignmentNeedsMetadataUpdate(current, input.requestBytes, input.now, input.wireAccountIdByAccount?.[current.accountId]), assignment = metadataNeedsUpdate ? {
+      ...current,
+      inputBytes: Math.max(current.inputBytes, input.requestBytes),
+      ...current.wireAccountId === void 0 && input.wireAccountIdByAccount?.[current.accountId] !== void 0 ? {
+        wireAccountId: input.wireAccountIdByAccount?.[current.accountId]
+      } : {},
+      ...input.now - current.lastSeenAt >= STICKY_ASSIGNMENT_LAST_SEEN_TOUCH_MS ? { lastSeenAt: input.now } : {}
+    } : current;
+    if (!assignmentsPruned && !metadataNeedsUpdate)
+      return { assignment, next: void 0 };
+    return {
+      assignment,
+      next: {
+        ...latest,
+        stickyAssignments: {
+          ...stickyAssignments,
+          [sessionHash]: assignment
+        },
+        lastUpdated: Math.max(input.now, latest.lastUpdated + 1)
+      }
+    };
+  }
+  const choice = input.choose(pendingBytesForAssignments(stickyAssignments, input.quotaCheckedAtByAccount, currentIdentityMismatch ? sessionHash : void 0));
+  if (!choice) {
+    if (!assignmentsPruned)
+      return { assignment: void 0, next: void 0 };
+    return {
+      assignment: void 0,
+      next: {
+        ...latest,
+        stickyAssignments,
+        lastUpdated: Math.max(input.now, latest.lastUpdated + 1)
+      }
+    };
+  }
+  const assignment = {
+    accountId: choice.accountId,
+    assignedAt: input.now,
+    lastSeenAt: input.now,
+    inputBytes: input.requestBytes,
+    ...choice.quotaCheckedAt === void 0 ? {} : { quotaCheckedAt: choice.quotaCheckedAt },
+    ...input.wireAccountIdByAccount?.[choice.accountId] === void 0 ? {} : {
+      wireAccountId: input.wireAccountIdByAccount?.[choice.accountId]
+    }
+  };
+  return {
+    assignment,
+    next: {
+      ...latest,
+      stickyAssignments: limitStickyAssignments({
+        ...stickyAssignments,
+        [sessionHash]: assignment
+      }, sessionHash),
+      lastUpdated: Math.max(input.now, latest.lastUpdated + 1)
+    }
+  };
+}
+export async function resolveSidebarStickyAssignment(input, file = getSidebarStateFile(), hooks) {
+  const sessionHash = hashSidebarSessionId(input.sessionId), existing = (await readSidebarState(file)).stickyAssignments?.[sessionHash];
+  if (stickyAssignmentIsCurrent(existing, input))
+    return existing;
+  let resolved;
+  await enqueueSidebarWrite(async () => {
+    await writeMergedSidebarState(file, (latest) => {
+      const plan = planSidebarStickyAssignment(latest, input);
+      resolved = plan.assignment;
+      return plan.next;
+    }, hooks);
+  });
+  return resolved;
+}
+export function planSidebarStickyAssignmentFromSnapshot(state, input) {
+  const existing = state.stickyAssignments?.[hashSidebarSessionId(input.sessionId)];
+  if (stickyAssignmentIsCurrent(existing, input))
+    return { assignment: existing, next: void 0 };
+  return planSidebarStickyAssignment(state, input);
+}
+export function persistSidebarStickyAssignment(input, file = getSidebarStateFile()) {
+  const sessionHash = hashSidebarSessionId(input.sessionId), validPinnedAccountIds = new Set(input.validPinnedAccountIds);
+  return enqueueSidebarWrite(async () => {
+    await writeMergedSidebarState(file, (latest) => {
+      const now = Date.now(), stickyAssignments = pruneStickyAssignments(latest.stickyAssignments, validPinnedAccountIds, now), current = stickyAssignments?.[sessionHash];
+      if (current && current.assignedAt > input.assignment.assignedAt) {
+        if (stickyAssignmentsEqual(latest.stickyAssignments, stickyAssignments))
+          return;
+        return {
+          ...latest,
+          stickyAssignments,
+          lastUpdated: Math.max(now, latest.lastUpdated + 1)
+        };
+      }
+      const assignment = current !== void 0 && current.accountId === input.assignment.accountId && current.assignedAt === input.assignment.assignedAt ? {
+        ...input.assignment,
+        inputBytes: Math.max(current.inputBytes, input.assignment.inputBytes),
+        lastSeenAt: Math.max(current.lastSeenAt, input.assignment.lastSeenAt)
+      } : input.assignment;
+      return {
+        ...latest,
+        stickyAssignments: limitStickyAssignments({ ...stickyAssignments, [sessionHash]: assignment }, sessionHash),
+        lastUpdated: Math.max(now, latest.lastUpdated + 1)
+      };
+    });
+  });
+}
+export async function clearSidebarStickyAssignment(sessionId, file = getSidebarStateFile()) {
+  const sessionHash = hashSidebarSessionId(sessionId);
+  let removed = !1;
+  await enqueueSidebarWrite(async () => {
+    await writeMergedSidebarState(file, (latest) => {
+      const assignments = latest.stickyAssignments;
+      if (assignments?.[sessionHash] === void 0) {
+        removed = !1;
+        return;
+      }
+      removed = !0;
+      const { [sessionHash]: _removed, ...remaining } = assignments;
+      return {
+        ...latest,
+        ...Object.keys(remaining).length > 0 ? { stickyAssignments: remaining } : { stickyAssignments: void 0 },
+        lastUpdated: Math.max(Date.now(), latest.lastUpdated + 1)
+      };
+    });
+  });
+  return removed;
+}
+export function drainSidebarWrites() {
+  return sidebarWriteChain;
+}
+export const HOT_PATH_READ_BUDGET_MS = 500;
+export function settleWithinBudget(read, budgetMs, stale) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => resolve(stale()), budgetMs);
+    timer.unref?.();
+    read.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }, (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+export function createSidebarStateCache(file, options = {}) {
+  const readBudgetMs = options.readBudgetMs ?? HOT_PATH_READ_BUDGET_MS;
+  let snapshot, inflight;
+  const statKey = () => {
+    try {
+      const stat = statSync(file);
+      return `${stat.ino}:${stat.size}:${stat.mtimeMs}`;
+    } catch {
+      return;
+    }
+  }, startRead = (key) => {
+    if (inflight && inflight.key === key)
+      return inflight.promise;
+    const readAt = Date.now(), promise = getSidebarState(file).then((state) => {
+      if (!snapshot || snapshot.readAt <= readAt)
+        snapshot = { state, readAt, key };
+      return { state, readAt };
+    }), entry = { key, promise };
+    inflight = entry;
+    const clear = () => {
+      if (inflight === entry)
+        inflight = void 0;
+    };
+    promise.then(clear, clear);
+    return promise;
+  };
+  return {
+    get() {
+      const key = statKey();
+      if (snapshot && snapshot.key === key)
+        return Promise.resolve({
+          state: snapshot.state,
+          readAt: snapshot.readAt
+        });
+      return settleWithinBudget(startRead(key), readBudgetMs, () => snapshot ? { state: snapshot.state, readAt: snapshot.readAt } : { state: DEFAULT_SIDEBAR_STATE, readAt: 0 });
+    },
+    read() {
+      return startRead(statKey());
+    },
+    refreshInBackground() {
+      const key = statKey();
+      if (snapshot?.key === key)
+        return;
+      startRead(key);
+    }
+  };
+}
+export function rememberStickyPin(overlay, sessionHash, assignment) {
+  const entry = { assignment };
+  overlay.delete(sessionHash);
+  overlay.set(sessionHash, entry);
+  while (overlay.size > STICKY_ASSIGNMENT_MAX_ENTRIES) {
+    const oldest = overlay.keys().next().value;
+    if (oldest === void 0)
+      break;
+    overlay.delete(oldest);
+  }
+  return entry;
+}
+export function applyStickyPinOverlay(snapshot, overlay) {
+  if (overlay.size === 0)
+    return snapshot.state;
+  const assignments = {
+    ...snapshot.state.stickyAssignments
+  };
+  let applied = !1;
+  for (const [sessionHash, entry] of overlay) {
+    if (entry.persistedAt !== void 0 && snapshot.readAt > entry.persistedAt) {
+      overlay.delete(sessionHash);
+      continue;
+    }
+    assignments[sessionHash] = entry.assignment;
+    applied = !0;
+  }
+  if (!applied)
+    return snapshot.state;
+  return { ...snapshot.state, stickyAssignments: assignments };
+}
+export function createSidebarBookkeepingQueue(options) {
+  const baseDelayMs = options.retryDelayMs ?? 500, maxDelayMs = options.maxRetryDelayMs ?? 30000, generation = new Map, retries = new Map, failing = new Set;
+  let sequence = 0, delayMs = baseDelayMs, timer, stopped = !1;
+  const schedule = () => {
+    if (timer || stopped || retries.size === 0)
+      return;
+    timer = setTimeout(() => {
+      timer = void 0;
+      const due = [...retries];
+      retries.clear();
+      delayMs = Math.min(delayMs * 2, maxDelayMs);
+      for (const [key, retry] of due) {
+        const current = generation.get(key);
+        if (current !== void 0)
+          attempt(key, retry.label, retry.write, current);
+      }
+    }, delayMs);
+    timer.unref?.();
+  }, attempt = (key, label, write, ownGeneration) => {
+    let running;
+    try {
+      running = write();
+    } catch (error) {
+      running = Promise.reject(error);
+    }
+    running.then(() => {
+      if (generation.get(key) !== ownGeneration)
+        return;
+      generation.delete(key);
+      if (failing.delete(key))
+        options.logger.info("sidebar bookkeeping write recovered", {
+          pid: process.pid,
+          write: label
+        });
+      if (failing.size === 0)
+        delayMs = baseDelayMs;
+      options.onWritten?.();
+    }, (error) => {
+      if (generation.get(key) !== ownGeneration)
+        return;
+      const fields = {
+        pid: process.pid,
+        write: label,
+        error: error instanceof Error ? error.message : String(error)
+      };
+      if (stopped) {
+        generation.delete(key);
+        options.logger.debug("sidebar bookkeeping write dropped", fields);
+        return;
+      }
+      if (failing.has(key))
+        options.logger.debug("sidebar bookkeeping write failed again", fields);
+      else {
+        failing.add(key);
+        options.logger.warn("sidebar bookkeeping write failed; retrying in the background", fields);
+      }
+      retries.set(key, { label, write });
+      schedule();
+    });
+  };
+  return {
+    enqueue(key, label, write) {
+      sequence += 1;
+      generation.set(key, sequence);
+      retries.delete(key);
+      attempt(key, label, write, sequence);
+    },
+    cancel(key) {
+      generation.delete(key);
+      retries.delete(key);
+      failing.delete(key);
+    },
+    stop() {
+      stopped = !0;
+      if (timer)
+        clearTimeout(timer);
+      timer = void 0;
+      retries.clear();
+    }
+  };
+}
+export function resolveActiveAccount(state) {
+  const activeId = state.activeId;
+  if (state.vaultAccounts !== void 0) {
+    const enabled = state.vaultAccounts.filter((account) => account.enabled), vaultAccount = enabled.find((account) => account.id === activeId) ?? enabled[0];
+    return vaultAccount ? {
+      id: vaultAccount.id,
+      name: vaultAccount.label ?? vaultAccount.id,
+      quota: vaultAccount.quota,
+      killed: vaultAccount.killed
+    } : { id: "vault", name: "vault", quota: null, killed: !1 };
+  }
+  if (activeId && activeId !== "main") {
+    const fallback = state.fallbacks.find((account) => account.enabled && account.id === activeId);
+    if (fallback)
+      return {
+        id: fallback.id,
+        name: fallback.label ?? fallback.id,
+        quota: fallback.quota,
+        killed: fallback.killed
+      };
+  }
+  return {
+    id: "main",
+    name: "main",
+    quota: state.main.quota,
+    killed: state.main.killed
+  };
+}
+export function sidebarQuotaProjection(quota, now = Date.now()) {
+  if (!quota)
+    return;
+  return projectQuota({
+    limits: QUOTA_WINDOW_KEYS.flatMap((label) => {
+      const window = quota[label];
+      return window ? [
+        {
+          kind: "reading",
+          scope: "all",
+          label,
+          usedPercent: window.usedPercent,
+          checkedAt: window.checkedAt ?? quota.checkedAt ?? now,
+          windowMinutes: window.windowMinutes,
+          resetsAt: window.resetsAt
+        }
+      ] : [];
+    }),
+    ...quota.spendControl ? {
+      budget: {
+        ...quota.spendControl,
+        kind: "reading",
+        checkedAt: quota.checkedAt ?? now
+      }
+    } : {}
+  });
+}
+export function getCollapsedQuotaSummary(quota, now = Date.now()) {
+  const primaryUsedPercent = quota?.primary?.usedPercent ?? null, secondaryUsedPercent = quota?.secondary?.usedPercent ?? null, projection = sidebarQuotaProjection(quota, now);
+  return {
+    primaryUsedPercent,
+    secondaryUsedPercent,
+    text: !projection || projection.limits.length === 0 && !projection.budget ? null : formatQuota(projection, { now, form: "compact" })
+  };
+}
+const PACING_MIN_ELAPSED_MS = 300000, PACING_MIN_ELAPSED_FRACTION = 0.01, ON_PACE_DELTA = 1;
+export function computeQuotaPacing(window, windowMs, now) {
+  if (!window.resetsAt)
+    return null;
+  const resetsAt = new Date(window.resetsAt).getTime();
+  if (!Number.isFinite(resetsAt))
+    return null;
+  const start = resetsAt - windowMs, elapsed = now - start;
+  if (elapsed < PACING_MIN_ELAPSED_MS)
+    return null;
+  if (elapsed < windowMs * PACING_MIN_ELAPSED_FRACTION)
+    return null;
+  if (elapsed >= windowMs)
+    return null;
+  const used = window.usedPercent, pacePercent = Math.min(Math.max(elapsed / windowMs * 100, 0), 100), deltaPercent = used - pacePercent, state = Math.abs(deltaPercent) < ON_PACE_DELTA ? "on-pace" : deltaPercent > 0 ? "deficit" : "reserve";
+  let runsOutAt = null;
+  if (used > 0) {
+    const msToFull = elapsed * 100 / used, runOut = start + msToFull;
+    if (runOut < resetsAt)
+      runsOutAt = new Date(runOut).toISOString();
+  }
+  return { pacePercent, deltaPercent, state, runsOutAt };
+}