tokmon 0.22.7 → 0.23.1

package/dist/{bootstrap-ink-OHPQZKGB.js → bootstrap-ink-UD3KDTOB.js}

@@ -19,7 +19,10 @@ import {
   time,
   tokens,
   withTimeout
-} from "./chunk-I4USANOF.js";
+} from "./chunk-PGQK7MOE.js";
+import {
+  glyphs
+} from "./chunk-RF4GGQGM.js";
 import {
   COLOR_PALETTE,
   DEFAULTS,
@@ -34,54 +37,17 @@ import {
   sanitizeTyped,
   saveConfigSync,
   snapshotCacheFile
-} from "./chunk-TNIADJ3W.js";
-import {
-  glyphs
-} from "./chunk-RF4GGQGM.js";
+} from "./chunk-DJPUYMZM.js";
 
 // src/bootstrap-ink.tsx
 import { render } from "ink";
 import { MouseProvider } from "@zenobius/ink-mouse";
 
 // src/app.tsx
-import { useState as useState8, useEffect as useEffect7, useCallback as useCallback4, useRef as useRef6, useMemo as useMemo2 } from "react";
-import { Box as Box11, Text as Text11, useInput, useApp } from "ink";
+import { useState as useState10, useEffect as useEffect9, useCallback as useCallback7, useRef as useRef8, useMemo as useMemo2 } from "react";
+import { Box as Box11, Text as Text12, useInput, useApp } from "ink";
 import { useMouse } from "@zenobius/ink-mouse";
 
-// src/config-sync.ts
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
-  if (Array.isArray(a) || Array.isArray(b)) {
-    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
-    return true;
-  }
-  const ka = Object.keys(a);
-  const kb = Object.keys(b);
-  if (ka.length !== kb.length) return false;
-  for (const k of ka) {
-    if (!Object.prototype.hasOwnProperty.call(b, k)) return false;
-    if (!deepEqual(a[k], b[k])) return false;
-  }
-  return true;
-}
-function reconcileDaemonConfig(previous, daemonConfig, pendingLocalConfig) {
-  if (pendingLocalConfig) {
-    if (deepEqual(daemonConfig, pendingLocalConfig)) {
-      return { config: previous && deepEqual(previous, daemonConfig) ? previous : daemonConfig, pendingLocalConfig: null };
-    }
-    return { config: previous ?? pendingLocalConfig, pendingLocalConfig };
-  }
-  if (previous && deepEqual(previous, daemonConfig)) {
-    return { config: previous, pendingLocalConfig: null };
-  }
-  if (previous?.onboarded === true && daemonConfig.onboarded === false) {
-    return { config: previous, pendingLocalConfig: null };
-  }
-  return { config: daemonConfig, pendingLocalConfig: null };
-}
-
 // src/ui/shared.tsx
 import { appendFileSync } from "fs";
 import { memo, useEffect, useRef, useState } from "react";
@@ -1541,7 +1507,7 @@ function osc8(text, url) {
 import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
 var Footer = memo6(function Footer2({ hasAccounts, paginated, cols }) {
   const inner = cols - 4;
-  const BASE = "by David Ilie (davidilie.com)  \xB7  O=repo  W=web  s=settings  q=quit".length;
+  const BASE = "by David Ilie (davidilie.com)  \xB7  r/R=refresh  O=repo  W=web  s=settings  q=quit".length;
   const optHint = (glyphs().shift === "\u21E7" ? "\u2325" : "opt") + "-click links  ";
   const OPT = IS_APPLE_TERMINAL ? optHint.length : 0;
   const JUMP = "0-9=jump  a/A=cycle  ".length;
@@ -1550,7 +1516,7 @@ var Footer = memo6(function Footer2({ hasAccounts, paginated, cols }) {
   const showJump = hasAccounts && inner >= BASE + (showOpt ? OPT : 0) + JUMP + (paginated ? PAGE : 0);
   const showPage = paginated && inner >= BASE + (showOpt ? OPT : 0) + (showJump ? JUMP : 0) + PAGE;
   if (inner < BASE) {
-    return /* @__PURE__ */ jsx9(Box9, { marginTop: 1, flexWrap: "nowrap", children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, wrap: "truncate-end", children: "O=repo  W=web  s=settings  q=quit" }) });
+    return /* @__PURE__ */ jsx9(Box9, { marginTop: 1, flexWrap: "nowrap", children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, wrap: "truncate-end", children: "r/R=refresh  O=repo  W=web  s=settings  q=quit" }) });
   }
   return /* @__PURE__ */ jsxs9(Box9, { marginTop: 1, flexWrap: "nowrap", children: [
     /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "by " }),
@@ -1560,7 +1526,7 @@ var Footer = memo6(function Footer2({ hasAccounts, paginated, cols }) {
     /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
       ")  ",
       glyphs().middot,
-      "  O=repo  W=web  s=settings  "
+      "  r/R=refresh  O=repo  W=web  s=settings  "
     ] }),
     showOpt && /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: optHint }),
     showJump && /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "0-9=jump  a/A=cycle  " }),
@@ -1570,30 +1536,52 @@ var Footer = memo6(function Footer2({ hasAccounts, paginated, cols }) {
 });
 
 // src/ui/tiny-fallback.tsx
-import { Box as Box10, Text as Text10 } from "ink";
+import { Box as Box10, Text as Text11 } from "ink";
+
+// src/ui/refresh-status.tsx
+import { memo as memo7 } from "react";
+import { Text as Text10 } from "ink";
 import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
-function TinyFallback({ groups, stats, rows, cols }) {
+var RefreshStatusLine = memo7(function RefreshStatusLine2({ status }) {
+  if (status.phase === "idle") return null;
+  if (status.phase === "refreshing") return /* @__PURE__ */ jsx10(Spinner, { label: `${status.message}${glyphs().ellipsis}` });
+  if (status.phase === "success") return /* @__PURE__ */ jsxs10(Text10, { color: "green", children: [
+    glyphs().check,
+    " ",
+    status.message
+  ] });
+  return /* @__PURE__ */ jsxs10(Text10, { color: "red", children: [
+    glyphs().warn,
+    " ",
+    status.message
+  ] });
+});
+
+// src/ui/tiny-fallback.tsx
+import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+function TinyFallback({ groups, stats, rows, cols, refreshStatus }) {
   const maxLines = Math.max(1, rows - 4);
   const visible = groups.slice(0, maxLines);
   const hidden = groups.length - visible.length;
   const w = Math.max(8, cols - 2);
-  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", paddingX: 1, height: rows, overflow: "hidden", children: [
-    /* @__PURE__ */ jsxs10(Text10, { bold: true, color: "greenBright", children: [
+  return /* @__PURE__ */ jsxs11(Box10, { flexDirection: "column", paddingX: 1, height: rows, overflow: "hidden", children: [
+    /* @__PURE__ */ jsxs11(Text11, { bold: true, color: "greenBright", children: [
       glyphs().dotSel,
       " tokmon"
     ] }),
-    groups.length === 0 ? /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+    groups.length === 0 ? /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
       "No providers ",
       glyphs().emDash,
       " s=settings"
-    ] }) : visible.map((g) => /* @__PURE__ */ jsx10(TinyRow, { provider: g.provider, accounts: g.accounts, stats, width: w }, g.provider)),
-    hidden > 0 && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+    ] }) : visible.map((g) => /* @__PURE__ */ jsx11(TinyRow, { provider: g.provider, accounts: g.accounts, stats, width: w }, g.provider)),
+    hidden > 0 && /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
       "+",
       hidden,
       " more (enlarge terminal)"
     ] }),
-    /* @__PURE__ */ jsx10(Box10, { flexGrow: 1 }),
-    /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "s=settings  q=quit" })
+    /* @__PURE__ */ jsx11(RefreshStatusLine, { status: refreshStatus }),
+    /* @__PURE__ */ jsx11(Box10, { flexGrow: 1 }),
+    /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "R=refresh  s=settings  q=quit" })
   ] });
 }
 function TinyRow({ provider, accounts, stats, width }) {
@@ -1604,14 +1592,14 @@ function TinyRow({ provider, accounts, stats, width }) {
   const pctMetric = billings.flatMap((b) => b?.metrics ?? []).find((m) => m.format.kind === "percent");
   const detail = meta.hasUsage ? `${currency(todayCost)} today` : pctMetric ? `${Math.round(pctMetric.used)}%` : "billing";
   const name = truncateName(meta.name, Math.max(4, width - 18));
-  return /* @__PURE__ */ jsxs10(Box10, { width, children: [
-    /* @__PURE__ */ jsxs10(Text10, { color: meta.color, children: [
+  return /* @__PURE__ */ jsxs11(Box10, { width, children: [
+    /* @__PURE__ */ jsxs11(Text11, { color: meta.color, children: [
       glyphs().dot,
       " "
     ] }),
-    /* @__PURE__ */ jsx10(Text10, { bold: true, color: meta.color, children: name }),
-    /* @__PURE__ */ jsx10(Box10, { flexGrow: 1 }),
-    /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: detail })
+    /* @__PURE__ */ jsx11(Text11, { bold: true, color: meta.color, children: name }),
+    /* @__PURE__ */ jsx11(Box10, { flexGrow: 1 }),
+    /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: detail })
   ] });
 }
 
@@ -1635,6 +1623,8 @@ function toWsUrl(baseUrl, token) {
   if (url.protocol !== "ws:" && url.protocol !== "wss:") {
     throw new Error(`unsupported daemon RPC protocol: ${url.protocol}`);
   }
+  url.hash = "";
+  url.searchParams.delete("tokmonToken");
   url.pathname = TOKMON_WS_PATH;
   if (token) url.searchParams.set("wsToken", token);
   return url.toString();
@@ -1821,12 +1811,12 @@ function createDaemonRpcClient(baseUrl, options = {}) {
     };
   };
   return {
-    getConfig: () => run((client) => client[TOKMON_WS_METHODS.getConfig]({})),
-    setConfig: (config) => run((client) => client[TOKMON_WS_METHODS.setConfig](config)),
+    getConfig: () => run((client) => client[TOKMON_WS_METHODS.getConfig]({})).then((state) => state),
+    setConfig: (config) => run((client) => client[TOKMON_WS_METHODS.setConfig](config)).then((state) => state),
     refresh: (scope = "all") => run((client) => client[TOKMON_WS_METHODS.refresh]({ scope })),
     browseFs: (path) => run((client) => client[TOKMON_WS_METHODS.browseFs]({ path })),
-    subscribeSnapshot: (onSnapshot) => subscribe((client) => client[TOKMON_WS_METHODS.snapshot]({}), onSnapshot),
-    subscribeConfig: (onConfig) => subscribe((client) => client[TOKMON_WS_METHODS.config]({}), onConfig),
+    subscribeSnapshot: (onSnapshot) => subscribe((client) => client[TOKMON_WS_METHODS.snapshot]({}).pipe(Stream.map((value) => value)), onSnapshot),
+    subscribeConfig: (onConfig) => subscribe((client) => client[TOKMON_WS_METHODS.config]({}).pipe(Stream.map((value) => value)), onConfig),
     async close() {
       if (closed) return;
       closed = true;
@@ -1883,7 +1873,7 @@ function useDaemon(baseUrl, wsToken) {
     snapshot,
     conn,
     config,
-    setConfig: (next) => requireClient().setConfig(next),
+    setConfig: (next, expectedRevision) => requireClient().setConfig({ config: next, expectedRevision }),
     refresh: (scope) => requireClient().refresh(scope),
     browse: (path) => requireClient().browseFs(path)
   };
@@ -1950,19 +1940,6 @@ function upsert(prev, account, patch) {
   next.set(account.id, { ...cur, account, ...patch });
   return next;
 }
-async function fetchScopeTable(scope, tz) {
-  const tables = await Promise.all(scope.map(async (acc) => {
-    const provider = PROVIDERS[acc.providerId];
-    if (!provider.fetchTable) return null;
-    try {
-      return await provider.fetchTable(acc, tz);
-    } catch {
-      return null;
-    }
-  }));
-  const valid = tables.filter((t) => t !== null);
-  return coalesceTables(valid);
-}
 function sortLabel(entry) {
   if (entry.dir === "up") return `${entry.label} ${glyphs().arrowU}`;
   if (entry.dir === "down") return `${entry.label} ${glyphs().arrowD}`;
@@ -2028,555 +2005,564 @@ function filterTokenRows(rows, q) {
   return rows.filter((r) => r.label.toLowerCase().includes(s) || r.models.some((m) => m.toLowerCase().includes(s)));
 }
 
-// src/ui/keybindings.ts
-function handleKey(input, key, ctx) {
-  const {
-    showPicker,
-    pickerProviders,
-    onboardCursor,
-    setOnboardCursor,
-    toggleOnboard,
-    confirmOnboarding,
-    exit,
-    showSettings,
-    accountForm,
-    setAccountForm,
-    commitAccountForm,
-    cycleFormField,
-    cycleProvider,
-    cycleColor,
-    isPrintable,
-    insertText,
-    tzEdit,
-    setTzEdit,
-    setTzError,
-    updateConfig,
-    setTzCaret,
-    tzValueRef,
-    tzCaretRef,
-    tab,
-    searchMode,
-    setSearchMode,
-    search,
-    setSearch,
-    setSearchCaret,
-    searchValueRef,
-    searchCaretRef,
-    showLoader,
-    configReady,
-    toggleWeb,
-    settingsCursor,
-    settingsTab,
-    setSettingsTab,
-    setShowSettings,
-    cfg,
-    trackedAccountRows,
-    moveAccount,
-    setSettingsCursor,
-    toggleProvider,
-    openEditAccount,
-    openConfigureAccount,
-    deleteAccount,
-    openAddAccount,
-    cycleAccount,
-    setTab,
-    resetView,
-    slots,
-    dashPaginated,
-    dashPageCount,
-    setDashPage,
-    cycleTableProvider,
-    setExpanded,
-    setSort,
-    SORTS_FOR,
-    cycleTableModel: cycleTableModel2,
-    setView,
-    cursor,
-    rowCountRef,
-    rows,
-    setCursor,
-    clampRow
-  } = ctx;
-  if (showPicker) {
-    if (input === "q") {
-      exit();
-      return;
-    }
-    const startIdx = pickerProviders.length;
-    if (key.upArrow) {
-      setOnboardCursor((c) => Math.max(0, c - 1));
-      return;
-    }
-    if (key.downArrow) {
-      setOnboardCursor((c) => Math.min(startIdx, c + 1));
+// src/ui/keybindings-editors.ts
+function handleAccountEditor(input, key, editor, text) {
+  const { form, setForm, commit, cycleField, cycleProvider, cycleColor } = editor;
+  if (!form) return;
+  if (key.escape) {
+    setForm(null);
+    return;
+  }
+  if (key.ctrl && input === "s") {
+    commit();
+    return;
+  }
+  if (key.tab) {
+    cycleField(key.shift ? -1 : 1);
+    return;
+  }
+  if (key.upArrow) {
+    cycleField(-1);
+    return;
+  }
+  if (key.downArrow) {
+    cycleField(1);
+    return;
+  }
+  if (form.field === "provider") {
+    if (key.leftArrow) {
+      cycleProvider(-1);
       return;
     }
-    if (input === " ") {
-      toggleOnboard(onboardCursor);
+    if (key.rightArrow) {
+      cycleProvider(1);
       return;
     }
     if (key.return) {
-      if (onboardCursor === startIdx) confirmOnboarding();
-      else toggleOnboard(onboardCursor);
+      setForm((value) => value && { ...value, field: "name", caret: value.name.length });
       return;
     }
     return;
   }
-  if (showSettings && accountForm) {
-    if (key.escape) {
-      setAccountForm(null);
-      return;
-    }
-    if (key.ctrl && input === "s") {
-      commitAccountForm();
+  if (form.field === "color") {
+    if (key.leftArrow) {
+      cycleColor(-1);
       return;
     }
-    if (key.tab) {
-      cycleFormField(key.shift ? -1 : 1);
+    if (key.rightArrow) {
+      cycleColor(1);
       return;
     }
-    if (key.upArrow) {
-      cycleFormField(-1);
+    if (key.return) {
+      commit();
       return;
     }
-    if (key.downArrow) {
-      cycleFormField(1);
+    return;
+  }
+  const field = form.field;
+  if (key.leftArrow) {
+    setForm((value) => value && { ...value, caret: clampCaret(value.caret - 1, value[field].length) });
+    return;
+  }
+  if (key.rightArrow) {
+    setForm((value) => value && { ...value, caret: clampCaret(value.caret + 1, value[field].length) });
+    return;
+  }
+  if (key.ctrl && input === "a") {
+    setForm((value) => value && { ...value, caret: 0 });
+    return;
+  }
+  if (key.ctrl && input === "e") {
+    setForm((value) => value && { ...value, caret: value[field].length });
+    return;
+  }
+  if (key.return) {
+    if (field === "name" && form.name.trim() === "") {
+      setForm((value) => value && { ...value, error: "Name required", caret: value.name.length });
       return;
     }
-    if (accountForm.field === "provider") {
-      if (key.leftArrow) {
-        cycleProvider(-1);
-        return;
-      }
-      if (key.rightArrow) {
-        cycleProvider(1);
-        return;
-      }
-      if (key.return) {
-        setAccountForm((f) => f && { ...f, field: "name", caret: f.name.length });
-        return;
-      }
-      return;
+    setForm((value) => value && {
+      ...value,
+      field: field === "name" ? "homeDir" : "color",
+      caret: field === "name" ? value.homeDir.length : value.caret
+    });
+    return;
+  }
+  if (key.backspace || key.delete) {
+    setForm((value) => {
+      if (!value || value.field !== "name" && value.field !== "homeDir") return value;
+      const result = spliceBackspace(value[value.field], value.caret);
+      return { ...value, [value.field]: result.value, caret: result.caret, error: null };
+    });
+    return;
+  }
+  if (text.isPrintable(input, key)) {
+    const clean = sanitizeTyped(input);
+    if (clean) text.insert(clean);
+  }
+}
+function handleTimezoneEditor(input, key, editor, text, updateConfig) {
+  const { value, setValue, setError, setCaret, valueRef, caretRef } = editor;
+  if (value === null) return;
+  if (key.escape) {
+    setValue(null);
+    setError(null);
+    return;
+  }
+  if (key.return) {
+    const next = value.trim();
+    if (next === "" || next.toLowerCase() === "system") {
+      updateConfig((config) => ({ ...config, timezone: null }));
+      setValue(null);
+      setError(null);
+    } else if (isValidTimezone(next)) {
+      updateConfig((config) => ({ ...config, timezone: next }));
+      setValue(null);
+      setError(null);
+    } else {
+      setError(`Invalid: ${next}`);
     }
-    if (accountForm.field === "color") {
-      if (key.leftArrow) {
-        cycleColor(-1);
-        return;
-      }
-      if (key.rightArrow) {
-        cycleColor(1);
-        return;
-      }
-      if (key.return) {
-        commitAccountForm();
-        return;
-      }
-      return;
+    return;
+  }
+  if (key.leftArrow) {
+    setCaret((caret) => clampCaret(caret - 1, value.length));
+    return;
+  }
+  if (key.rightArrow) {
+    setCaret((caret) => clampCaret(caret + 1, value.length));
+    return;
+  }
+  if (key.ctrl && input === "a") {
+    setCaret(0);
+    return;
+  }
+  if (key.ctrl && input === "e") {
+    setCaret(value.length);
+    return;
+  }
+  if (key.backspace || key.delete) {
+    const result = spliceBackspace(valueRef.current, caretRef.current);
+    valueRef.current = result.value;
+    caretRef.current = result.caret;
+    setValue(result.value);
+    setCaret(result.caret);
+    setError(null);
+    return;
+  }
+  if (text.isPrintable(input, key)) {
+    const clean = sanitizeTyped(input);
+    if (clean) text.insert(clean);
+  }
+}
+function handleSearchEditor(input, key, table, text) {
+  const { search, setSearch, setSearchMode, setSearchCaret, searchValueRef, searchCaretRef } = table;
+  if (key.return || key.escape) {
+    setSearchMode(false);
+    if (key.escape) {
+      setSearch("");
+      setSearchCaret(0);
     }
-    const tf = accountForm.field;
+    return;
+  }
+  if (key.leftArrow) {
+    setSearchCaret((caret) => clampCaret(caret - 1, search.length));
+    return;
+  }
+  if (key.rightArrow) {
+    setSearchCaret((caret) => clampCaret(caret + 1, search.length));
+    return;
+  }
+  if (key.ctrl && input === "a") {
+    setSearchCaret(0);
+    return;
+  }
+  if (key.ctrl && input === "e") {
+    setSearchCaret(search.length);
+    return;
+  }
+  if (key.backspace || key.delete) {
+    const result = spliceBackspace(searchValueRef.current, searchCaretRef.current);
+    searchValueRef.current = result.value;
+    searchCaretRef.current = result.caret;
+    setSearch(result.value);
+    setSearchCaret(result.caret);
+    return;
+  }
+  if (text.isPrintable(input, key)) {
+    const clean = sanitizeTyped(input);
+    if (clean) text.insert(clean);
+  }
+}
+
+// src/ui/keybindings-settings.ts
+function handleSettings(input, key, ctx) {
+  const {
+    settings,
+    timezoneEditor,
+    textInput,
+    global: { config, updateConfig }
+  } = ctx;
+  const {
+    cursor,
+    tab,
+    setShow,
+    setTab,
+    setCursor,
+    trackedAccounts,
+    moveAccount,
+    toggleProvider,
+    openEditAccount,
+    openConfigureAccount,
+    deleteAccount,
+    openAddAccount
+  } = settings;
+  if (key.escape || input === "s") {
+    setShow(false);
+    return;
+  }
+  const switchTab = (direction) => {
+    const index = SETTINGS_TABS.indexOf(tab);
+    setTab(SETTINGS_TABS[(index + direction + SETTINGS_TABS.length) % SETTINGS_TABS.length]);
+    setCursor(-1);
+    timezoneEditor.setValue(null);
+    timezoneEditor.setError(null);
+  };
+  const rowCount = tab === "general" ? GENERAL_ROWS : tab === "providers" ? PROVIDER_ORDER.length : trackedAccounts.length + 1;
+  if (key.tab) {
+    switchTab(key.shift ? -1 : 1);
+    return;
+  }
+  if (input === "[") {
+    switchTab(-1);
+    return;
+  }
+  if (input === "]") {
+    switchTab(1);
+    return;
+  }
+  if (cursor < 0) {
     if (key.leftArrow) {
-      setAccountForm((f) => f && { ...f, caret: clampCaret(f.caret - 1, f[tf].length) });
+      switchTab(-1);
       return;
     }
     if (key.rightArrow) {
-      setAccountForm((f) => f && { ...f, caret: clampCaret(f.caret + 1, f[tf].length) });
-      return;
-    }
-    if (key.ctrl && input === "a") {
-      setAccountForm((f) => f && { ...f, caret: 0 });
+      switchTab(1);
       return;
     }
-    if (key.ctrl && input === "e") {
-      setAccountForm((f) => f && { ...f, caret: f[tf].length });
-      return;
-    }
-    if (key.return) {
-      if (tf === "name" && accountForm.name.trim() === "") {
-        setAccountForm((f) => f && { ...f, error: "Name required", caret: f.name.length });
-        return;
-      }
-      setAccountForm((f) => f && { ...f, field: tf === "name" ? "homeDir" : "color", caret: tf === "name" ? f.homeDir.length : f.caret });
+    if (key.downArrow || key.return) {
+      setCursor(0);
       return;
     }
-    if (key.backspace || key.delete) {
-      setAccountForm((f) => {
-        if (!f || f.field !== "name" && f.field !== "homeDir") return f;
-        const r = spliceBackspace(f[f.field], f.caret);
-        return { ...f, [f.field]: r.value, caret: r.caret, error: null };
-      });
+    if (key.upArrow) {
+      setCursor(Math.max(0, rowCount - 1));
       return;
     }
-    if (isPrintable(input, key)) {
-      const clean = sanitizeTyped(input);
-      if (clean) insertText(clean);
-    }
     return;
   }
-  if (showSettings && tzEdit !== null) {
-    if (key.escape) {
-      setTzEdit(null);
-      setTzError(null);
-      return;
+  const selected = tab === "accounts" && cursor < trackedAccounts.length ? trackedAccounts[cursor] : null;
+  if (selected?.source === "configured" && selected.explicitIndex !== void 0 && key.shift && (key.upArrow || key.downArrow)) {
+    moveAccount(selected.explicitIndex, key.upArrow ? -1 : 1);
+    return;
+  }
+  if (key.upArrow) {
+    setCursor((current) => Math.max(-1, current - 1));
+    return;
+  }
+  if (key.downArrow) {
+    setCursor((current) => Math.min(rowCount - 1, current + 1));
+    return;
+  }
+  if (tab === "general") {
+    handleGeneralSetting(input, key, ctx);
+    return;
+  }
+  if (tab === "providers") {
+    if (cursor < PROVIDER_ORDER.length && (input === " " || key.return || key.leftArrow || key.rightArrow)) {
+      toggleProvider(PROVIDER_ORDER[cursor]);
     }
+    return;
+  }
+  if (cursor < trackedAccounts.length) {
+    const row = trackedAccounts[cursor];
     if (key.return) {
-      const val = tzEdit.trim();
-      if (val === "" || val.toLowerCase() === "system") {
-        updateConfig((c) => ({ ...c, timezone: null }));
-        setTzEdit(null);
-        setTzError(null);
-      } else if (isValidTimezone(val)) {
-        updateConfig((c) => ({ ...c, timezone: val }));
-        setTzEdit(null);
-        setTzError(null);
+      if (row.source === "configured") {
+        const account = config.accounts.find((candidate) => candidate.id === row.explicitId);
+        if (account) openEditAccount(account);
       } else {
-        setTzError(`Invalid: ${val}`);
+        openConfigureAccount(row);
       }
       return;
     }
-    if (key.leftArrow) {
-      setTzCaret((c) => clampCaret(c - 1, tzEdit.length));
-      return;
-    }
-    if (key.rightArrow) {
-      setTzCaret((c) => clampCaret(c + 1, tzEdit.length));
-      return;
-    }
-    if (key.ctrl && input === "a") {
-      setTzCaret(0);
-      return;
-    }
-    if (key.ctrl && input === "e") {
-      setTzCaret(tzEdit.length);
+    if (row.source === "configured" && row.explicitId && (input === "d" || input === "x")) {
+      deleteAccount(row.explicitId);
       return;
     }
-    if (key.backspace || key.delete) {
-      const r = spliceBackspace(tzValueRef.current, tzCaretRef.current);
-      tzValueRef.current = r.value;
-      tzCaretRef.current = r.caret;
-      setTzEdit(r.value);
-      setTzCaret(r.caret);
-      setTzError(null);
+    if (input === " ") {
+      updateConfig((current) => ({ ...current, activeAccountId: row.id }));
       return;
     }
-    if (isPrintable(input, key)) {
-      const clean = sanitizeTyped(input);
-      if (clean) insertText(clean);
-    }
     return;
   }
-  if (tab === 1 && searchMode) {
-    if (key.return || key.escape) {
-      setSearchMode(false);
-      if (key.escape) {
-        setSearch("");
-        setSearchCaret(0);
-      }
+  if (cursor === trackedAccounts.length && key.return) openAddAccount();
+  function handleGeneralSetting(value, inputKey, context) {
+    const index = context.settings.cursor;
+    if (index === 0) {
+      if (inputKey.leftArrow) updateConfig((current) => ({ ...current, interval: Math.max(1, current.interval - 1) }));
+      if (inputKey.rightArrow) updateConfig((current) => ({ ...current, interval: current.interval + 1 }));
       return;
     }
-    if (key.leftArrow) {
-      setSearchCaret((c) => clampCaret(c - 1, search.length));
+    if (index === 1) {
+      if (inputKey.leftArrow) updateConfig((current) => ({ ...current, billingInterval: Math.max(1, current.billingInterval - 1) }));
+      if (inputKey.rightArrow) updateConfig((current) => ({ ...current, billingInterval: current.billingInterval + 1 }));
       return;
     }
-    if (key.rightArrow) {
-      setSearchCaret((c) => clampCaret(c + 1, search.length));
+    if (index === 2 && (inputKey.leftArrow || inputKey.rightArrow || inputKey.return)) {
+      updateConfig((current) => ({ ...current, clearScreen: !current.clearScreen }));
       return;
     }
-    if (key.ctrl && input === "a") {
-      setSearchCaret(0);
+    if (index === 3 && (inputKey.leftArrow || inputKey.rightArrow || inputKey.return)) {
+      updateConfig((current) => ({ ...current, privacyMode: !current.privacyMode }));
       return;
     }
-    if (key.ctrl && input === "e") {
-      setSearchCaret(search.length);
+    if (index === 4) {
+      if (textInput.isPrintable(value, inputKey)) {
+        const clean = sanitizeTyped(value);
+        if (clean.length === 1) updateConfig((current) => ({ ...current, privacyToggleKey: clean }));
+      }
+      if (inputKey.backspace || inputKey.delete) updateConfig((current) => ({ ...current, privacyToggleKey: "p" }));
       return;
     }
-    if (key.backspace || key.delete) {
-      const r = spliceBackspace(searchValueRef.current, searchCaretRef.current);
-      searchValueRef.current = r.value;
-      searchCaretRef.current = r.caret;
-      setSearch(r.value);
-      setSearchCaret(r.caret);
+    if (index === 5) {
+      if (inputKey.return) {
+        const initial = config.timezone ?? "";
+        timezoneEditor.setValue(initial);
+        timezoneEditor.setCaret(initial.length);
+        timezoneEditor.setError(null);
+      }
+      if (inputKey.leftArrow || inputKey.rightArrow) {
+        updateConfig((current) => ({ ...current, timezone: current.timezone === null ? systemTimezone() : null }));
+      }
       return;
     }
-    if (isPrintable(input, key)) {
-      const clean = sanitizeTyped(input);
-      if (clean) insertText(clean);
+    if (index === 6 && (inputKey.leftArrow || inputKey.rightArrow || inputKey.return)) {
+      updateConfig((current) => ({ ...current, dashboardLayout: current.dashboardLayout === "grid" ? "single" : "grid" }));
+      return;
+    }
+    if (index === 7 && (inputKey.leftArrow || inputKey.rightArrow || inputKey.return)) {
+      updateConfig((current) => ({ ...current, defaultFocus: current.defaultFocus === "all" ? "last" : "all" }));
     }
-    return;
   }
+}
+
+// src/ui/keybindings-navigation.ts
+function handleGlobalCommand(input, ctx) {
+  const { global, table, settings } = ctx;
   if (input === "q") {
-    exit();
-    return;
+    global.exit();
+    return true;
   }
   if (input === "O") {
     openUrl(REPO_URL);
+    return true;
+  }
+  if (input === "W" || input === "w" && table.tab !== 1 && !settings.show) {
+    if (!global.showLoader && global.configReady) void global.toggleWeb();
+    return true;
+  }
+  return false;
+}
+function handleNavigation(input, key, ctx) {
+  const { settings, table, dashboard, global } = ctx;
+  const { config, updateConfig, resetView, slots } = global;
+  if (input === config.privacyToggleKey) {
+    updateConfig((current) => ({ ...current, privacyMode: !current.privacyMode }));
     return;
   }
-  if (input === "W" || input === "w" && tab !== 1 && !showSettings) {
-    if (showLoader || !configReady) return;
-    void toggleWeb();
+  if (input === "s") {
+    settings.setTab("general");
+    settings.setShow(true);
+    settings.setCursor(-1);
     return;
   }
-  if (showSettings) {
-    if (key.escape || input === "s") {
-      setShowSettings(false);
-      return;
-    }
-    const switchSettingsTab = (dir) => {
-      const idx = SETTINGS_TABS.indexOf(settingsTab);
-      setSettingsTab(SETTINGS_TABS[(idx + dir + SETTINGS_TABS.length) % SETTINGS_TABS.length]);
-      setSettingsCursor(-1);
-      setTzEdit(null);
-      setTzError(null);
-    };
-    const rowCount = settingsTab === "general" ? GENERAL_ROWS : settingsTab === "providers" ? PROVIDER_ORDER.length : trackedAccountRows.length + 1;
-    if (key.tab) {
-      switchSettingsTab(key.shift ? -1 : 1);
-      return;
+  if (input === "a") {
+    global.cycleAccount(1);
+    return;
+  }
+  if (input === "A") {
+    global.cycleAccount(-1);
+    return;
+  }
+  if (key.tab) {
+    global.setTab((current) => (current + 1) % TABS.length);
+    resetView();
+    return;
+  }
+  if (input && /^[0-9]$/.test(input) && slots.length > 1) {
+    const target = slots[parseInt(input, 10)];
+    if (target) {
+      updateConfig((current) => ({ ...current, activeAccountId: target.id }));
+      resetView();
     }
-    if (input === "[") {
-      switchSettingsTab(-1);
-      return;
-    }
-    if (input === "]") {
-      switchSettingsTab(1);
-      return;
-    }
-    if (settingsCursor < 0) {
-      if (key.leftArrow) {
-        switchSettingsTab(-1);
-        return;
-      }
-      if (key.rightArrow) {
-        switchSettingsTab(1);
-        return;
-      }
-      if (key.downArrow || key.return) {
-        setSettingsCursor(0);
-        return;
-      }
-      if (key.upArrow) {
-        setSettingsCursor(Math.max(0, rowCount - 1));
-        return;
-      }
-      return;
-    }
-    const selectedAccountRow = settingsTab === "accounts" && settingsCursor >= 0 && settingsCursor < trackedAccountRows.length ? trackedAccountRows[settingsCursor] : null;
-    if (selectedAccountRow?.source === "configured" && selectedAccountRow.explicitIndex !== void 0 && key.shift && (key.upArrow || key.downArrow)) {
-      moveAccount(selectedAccountRow.explicitIndex, key.upArrow ? -1 : 1);
-      return;
-    }
-    if (key.upArrow) {
-      setSettingsCursor((c) => Math.max(-1, c - 1));
-      return;
-    }
-    if (key.downArrow) {
-      setSettingsCursor((c) => Math.min(rowCount - 1, c + 1));
-      return;
-    }
-    if (settingsTab === "general") {
-      if (settingsCursor === 0) {
-        if (key.leftArrow) updateConfig((c) => ({ ...c, interval: Math.max(1, c.interval - 1) }));
-        if (key.rightArrow) updateConfig((c) => ({ ...c, interval: c.interval + 1 }));
-        return;
-      }
-      if (settingsCursor === 1) {
-        if (key.leftArrow) updateConfig((c) => ({ ...c, billingInterval: Math.max(1, c.billingInterval - 1) }));
-        if (key.rightArrow) updateConfig((c) => ({ ...c, billingInterval: c.billingInterval + 1 }));
-        return;
-      }
-      if (settingsCursor === 2 && (key.leftArrow || key.rightArrow || key.return)) {
-        updateConfig((c) => ({ ...c, clearScreen: !c.clearScreen }));
-        return;
-      }
-      if (settingsCursor === 3 && (key.leftArrow || key.rightArrow || key.return)) {
-        updateConfig((c) => ({ ...c, privacyMode: !c.privacyMode }));
-        return;
-      }
-      if (settingsCursor === 4) {
-        if (isPrintable(input, key)) {
-          const clean = sanitizeTyped(input);
-          if (clean.length === 1) updateConfig((c) => ({ ...c, privacyToggleKey: clean }));
-        }
-        if (key.backspace || key.delete) updateConfig((c) => ({ ...c, privacyToggleKey: "p" }));
-        return;
-      }
-      if (settingsCursor === 5) {
-        if (key.return) {
-          const init = cfg.timezone ?? "";
-          setTzEdit(init);
-          setTzCaret(init.length);
-          setTzError(null);
-        }
-        if (key.leftArrow || key.rightArrow) updateConfig((c) => ({ ...c, timezone: c.timezone === null ? systemTimezone() : null }));
-        return;
-      }
-      if (settingsCursor === 6 && (key.leftArrow || key.rightArrow || key.return)) {
-        updateConfig((c) => ({ ...c, dashboardLayout: c.dashboardLayout === "grid" ? "single" : "grid" }));
-        return;
-      }
-      if (settingsCursor === 7 && (key.leftArrow || key.rightArrow || key.return)) {
-        updateConfig((c) => ({ ...c, defaultFocus: c.defaultFocus === "all" ? "last" : "all" }));
-        return;
-      }
-      return;
-    }
-    if (settingsTab === "providers") {
-      if (settingsCursor >= 0 && settingsCursor < PROVIDER_ORDER.length && (input === " " || key.return || key.leftArrow || key.rightArrow)) {
-        toggleProvider(PROVIDER_ORDER[settingsCursor]);
-      }
-      return;
-    }
-    if (settingsTab === "accounts" && settingsCursor >= 0 && settingsCursor < trackedAccountRows.length) {
-      const row = trackedAccountRows[settingsCursor];
-      if (key.return) {
-        if (row.source === "configured") {
-          const acc = cfg.accounts.find((a) => a.id === row.explicitId);
-          if (acc) openEditAccount(acc);
-        } else {
-          openConfigureAccount(row);
-        }
-        return;
-      }
-      if (row.source === "configured" && row.explicitId && (input === "d" || input === "x")) {
-        deleteAccount(row.explicitId);
+    return;
+  }
+  if (table.tab === 0) {
+    if (dashboard.paginated) {
+      if (input === "]" || key.downArrow || key.pageDown) {
+        dashboard.setPage((page) => Math.min(dashboard.pageCount - 1, page + 1));
         return;
       }
-      if (input === " ") {
-        updateConfig((c) => ({ ...c, activeAccountId: row.id }));
+      if (input === "[" || key.upArrow || key.pageUp) {
+        dashboard.setPage((page) => Math.max(0, page - 1));
         return;
       }
-      return;
     }
-    if (settingsTab === "accounts" && settingsCursor === trackedAccountRows.length && key.return) {
-      openAddAccount();
+    if (key.upArrow || key.downArrow || key.pageUp || key.pageDown || input === "G" || input === "g") return;
+  }
+  if (table.tab !== 1) {
+    if (key.leftArrow || key.rightArrow) {
+      global.setTab((current) => (current + 1) % TABS.length);
+      resetView();
     }
     return;
   }
-  if (input === cfg.privacyToggleKey) {
-    updateConfig((c) => ({ ...c, privacyMode: !c.privacyMode }));
+  if (input === "p") {
+    table.cycleProvider(1);
     return;
   }
-  if (input === "s") {
-    setSettingsTab("general");
-    setShowSettings(true);
-    setSettingsCursor(-1);
+  if (input === "P") {
+    table.cycleProvider(-1);
     return;
   }
-  if (input === "a") {
-    cycleAccount(1);
+  if (input === "/") {
+    table.setSearchMode(true);
+    table.setSearchCaret(table.search.length);
     return;
   }
-  if (input === "A") {
-    cycleAccount(-1);
+  if (key.escape) {
+    if (table.search) {
+      table.setSearch("");
+      table.setSearchCaret(0);
+    } else table.setExpanded(-1);
     return;
   }
-  if (key.tab) {
-    setTab((t) => (t + 1) % TABS.length);
+  if (input === "o") {
+    table.setSort((sort) => (sort + 1) % table.sorts.length);
     resetView();
     return;
   }
-  if (input && /^[0-9]$/.test(input) && slots.length > 1) {
-    const target = slots[parseInt(input, 10)];
-    if (target) {
-      updateConfig((c) => ({ ...c, activeAccountId: target.id }));
-      resetView();
-    }
+  if (input === "d") {
+    table.setView(0);
+    resetView();
     return;
   }
-  if (tab === 0) {
-    if (dashPaginated) {
-      if (input === "]" || key.downArrow || key.pageDown) {
-        setDashPage((p) => Math.min(dashPageCount - 1, p + 1));
-        return;
-      }
-      if (input === "[" || key.upArrow || key.pageUp) {
-        setDashPage((p) => Math.max(0, p - 1));
-        return;
-      }
-    }
-    if (key.upArrow || key.downArrow || key.pageUp || key.pageDown || input === "G" || input === "g") return;
+  if (input === "w") {
+    table.setView(1);
+    resetView();
+    return;
   }
-  if (tab === 1) {
-    if (input === "p") {
-      cycleTableProvider(1);
-      return;
-    }
-    if (input === "P") {
-      cycleTableProvider(-1);
-      return;
-    }
-    if (input === "/") {
-      setSearchMode(true);
-      setSearchCaret(search.length);
-      return;
-    }
-    if (key.escape) {
-      if (search) {
-        setSearch("");
-        setSearchCaret(0);
-      } else setExpanded(-1);
-      return;
-    }
-    if (input === "o") {
-      setSort((s) => (s + 1) % SORTS_FOR.length);
-      resetView();
-      return;
-    }
-    if (input === "d") {
-      setView(0);
-      resetView();
-      return;
-    }
-    if (input === "w") {
-      setView(1);
-      resetView();
-      return;
-    }
-    if (input === "m") {
-      cycleTableModel2(1);
-      return;
-    }
-    if (input === "M") {
-      cycleTableModel2(-1);
-      return;
-    }
-    if (key.leftArrow) {
-      setView((v) => (v - 1 + VIEWS.length) % VIEWS.length);
-      resetView();
-      return;
-    }
-    if (key.rightArrow) {
-      setView((v) => (v + 1) % VIEWS.length);
-      resetView();
-      return;
-    }
-    if (key.return) {
-      setExpanded((e) => e === cursor ? -1 : cursor);
-      return;
-    }
-    if (key.upArrow) {
-      setCursor((c) => Math.max(0, c - 1));
-      return;
-    }
-    if (key.downArrow) {
-      setCursor((c) => clampRow(c + 1));
-      return;
-    }
-    if (key.pageDown || input === "G") {
-      setCursor((c) => clampRow(input === "G" ? rowCountRef.current - 1 : c + Math.max(1, rows - 12)));
-      return;
-    }
-    if (key.pageUp || input === "g") {
-      setCursor((c) => input === "g" ? 0 : Math.max(0, c - Math.max(1, rows - 12)));
-      return;
-    }
-  } else {
-    if (key.leftArrow || key.rightArrow) {
-      setTab((t) => (t + 1) % TABS.length);
-      resetView();
-      return;
-    }
+  if (input === "m") {
+    table.cycleModel(1);
+    return;
+  }
+  if (input === "M") {
+    table.cycleModel(-1);
+    return;
+  }
+  if (key.leftArrow) {
+    table.setView((view) => (view - 1 + VIEWS.length) % VIEWS.length);
+    resetView();
+    return;
+  }
+  if (key.rightArrow) {
+    table.setView((view) => (view + 1) % VIEWS.length);
+    resetView();
+    return;
+  }
+  if (key.return) {
+    table.setExpanded((expanded) => expanded === table.cursor ? -1 : table.cursor);
+    return;
+  }
+  if (key.upArrow) {
+    table.setCursor((cursor) => Math.max(0, cursor - 1));
+    return;
+  }
+  if (key.downArrow) {
+    table.setCursor((cursor) => table.clampRow(cursor + 1));
+    return;
+  }
+  if (key.pageDown || input === "G") {
+    table.setCursor((cursor) => table.clampRow(input === "G" ? table.rowCountRef.current - 1 : cursor + Math.max(1, table.rows - 12)));
+    return;
+  }
+  if (key.pageUp || input === "g") {
+    table.setCursor((cursor) => input === "g" ? 0 : Math.max(0, cursor - Math.max(1, table.rows - 12)));
+  }
+}
+
+// src/ui/keybindings.ts
+function isRefreshAllShortcut(input, mode) {
+  return (input === "r" || input === "R") && !mode.unavailable && !mode.showPicker && !mode.editingAccount && !mode.editingTimezone && !mode.editingSearch;
+}
+function handleOnboarding(input, key, ctx) {
+  const { onboarding, global } = ctx;
+  if (input === "q") {
+    global.exit();
+    return;
+  }
+  const confirmIndex = onboarding.providers.length;
+  if (key.upArrow) {
+    onboarding.setCursor((cursor) => Math.max(0, cursor - 1));
+    return;
+  }
+  if (key.downArrow) {
+    onboarding.setCursor((cursor) => Math.min(confirmIndex, cursor + 1));
+    return;
+  }
+  if (input === " ") {
+    onboarding.toggle(onboarding.cursor);
+    return;
+  }
+  if (key.return) {
+    if (onboarding.cursor === confirmIndex) onboarding.confirm();
+    else onboarding.toggle(onboarding.cursor);
+  }
+}
+function handleKey(input, key, ctx) {
+  const editingAccount = ctx.settings.show && ctx.accountEditor.form !== null;
+  const editingTimezone = ctx.settings.show && ctx.timezoneEditor.value !== null;
+  const editingSearch = ctx.table.tab === 1 && ctx.table.searchMode;
+  if (isRefreshAllShortcut(input, {
+    showPicker: ctx.onboarding.show,
+    editingAccount,
+    editingTimezone,
+    editingSearch,
+    unavailable: !ctx.global.configReady
+  })) {
+    ctx.global.refreshAll();
+    return;
+  }
+  if (ctx.onboarding.show) {
+    handleOnboarding(input, key, ctx);
+    return;
   }
+  if (editingAccount) {
+    handleAccountEditor(input, key, ctx.accountEditor, ctx.textInput);
+    return;
+  }
+  if (editingTimezone) {
+    handleTimezoneEditor(input, key, ctx.timezoneEditor, ctx.textInput, ctx.global.updateConfig);
+    return;
+  }
+  if (editingSearch) {
+    handleSearchEditor(input, key, ctx.table, ctx.textInput);
+    return;
+  }
+  if (handleGlobalCommand(input, ctx)) return;
+  if (ctx.settings.show) {
+    handleSettings(input, key, ctx);
+    return;
+  }
+  handleNavigation(input, key, ctx);
 }
 
 // src/ui/hooks/use-terminal-size.ts
@@ -2732,7 +2718,7 @@ function useLoader({ configReady, showPicker, accountsKey, allReady, tooSmall, s
 }
 
 // src/ui/hooks/use-degraded-polling.ts
-import { useState as useState6, useEffect as useEffect6, useRef as useRef5 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect6, useRef as useRef5, useState as useState6 } from "react";
 
 // src/client/seed-cache.ts
 import { readFile } from "fs/promises";
@@ -2751,92 +2737,420 @@ async function loadSeedSnapshot() {
 }
 
 // src/ui/hooks/use-degraded-polling.ts
-function useDegradedPolling({ degraded, configReady, showPicker, accountsKey, accountsRef, interval, billingMs, tz }) {
+function failureMessage(scope, failures) {
+  const detail = failures[0]?.reason;
+  const suffix = detail instanceof Error && detail.message ? `: ${detail.message}` : "";
+  return new Error(`${scope} refresh failed for ${failures.length} source${failures.length === 1 ? "" : "s"}${suffix}`);
+}
+function usageProviders(accounts) {
+  return [...new Set(accounts.filter((account) => PROVIDERS[account.providerId].hasUsage).map((account) => account.providerId))];
+}
+function useDegradedPolling({
+  degraded,
+  configReady,
+  showPicker,
+  accountsKey,
+  accountsRef,
+  interval,
+  billingMs,
+  tz,
+  activeTableProvider,
+  tableVisible
+}) {
   const [statsLocal, setStats] = useState6(/* @__PURE__ */ new Map());
   const [peakLocal, setPeak] = useState6(null);
-  const [error, setError] = useState6(null);
   const [updatedLocal, setUpdated] = useState6(/* @__PURE__ */ new Date());
+  const [tables, setTables] = useState6(/* @__PURE__ */ new Map());
+  const [loadingTables, setLoadingTables] = useState6(/* @__PURE__ */ new Set());
   const seededRef = useRef5(false);
+  const epochRef = useRef5(0);
+  const summaryFlightRef = useRef5(null);
+  const billingFlightRef = useRef5(null);
+  const peakFlightRef = useRef5(null);
+  const tableFlightsRef = useRef5(/* @__PURE__ */ new Map());
+  const allFlightRef = useRef5(null);
+  useEffect6(() => {
+    const epoch = ++epochRef.current;
+    summaryFlightRef.current = null;
+    billingFlightRef.current = null;
+    peakFlightRef.current = null;
+    tableFlightsRef.current.clear();
+    allFlightRef.current = null;
+    setStats(/* @__PURE__ */ new Map());
+    setTables(/* @__PURE__ */ new Map());
+    setLoadingTables(/* @__PURE__ */ new Set());
+    return () => {
+      if (epochRef.current === epoch) epochRef.current++;
+    };
+  }, [accountsKey, tz, degraded]);
   useEffect6(() => {
     if (!degraded) return;
     if (seededRef.current || !configReady || showPicker || accountsRef.current.length === 0) return;
     seededRef.current = true;
-    loadSeedSnapshot().then((snap) => {
+    const epoch = epochRef.current;
+    void loadSeedSnapshot().then((snap) => {
+      if (epoch !== epochRef.current) return;
       setStats((prev) => {
         if (prev.size > 0) return prev;
         const next = new Map(prev);
         for (const acc of accountsRef.current) {
-          const s = snap[acc.id];
-          if (s && (s.dashboard || s.billing)) next.set(acc.id, { account: acc, dashboard: s.dashboard ?? null, billing: s.billing ?? null });
+          const cached = snap[acc.id];
+          if (cached && (cached.dashboard || cached.billing)) {
+            next.set(acc.id, {
+              account: acc,
+              dashboard: cached.dashboard ?? null,
+              billing: cached.billing ?? null
+            });
+          }
         }
         return next;
       });
     });
-  }, [degraded, configReady, showPicker, accountsKey]);
+  }, [degraded, configReady, showPicker, accountsKey, accountsRef]);
+  const runSummary = useCallback3(() => {
+    if (summaryFlightRef.current) return summaryFlightRef.current;
+    const epoch = epochRef.current;
+    const task = (async () => {
+      const targets = accountsRef.current.filter((account) => {
+        const provider = PROVIDERS[account.providerId];
+        return provider.hasUsage && provider.fetchSummary;
+      });
+      const settled = await Promise.allSettled(targets.map(async (account) => {
+        const fetchSummary = PROVIDERS[account.providerId].fetchSummary;
+        if (!fetchSummary) return;
+        const dashboard = await withTimeout(fetchSummary(account, tz));
+        if (epoch === epochRef.current) setStats((prev) => upsert(prev, account, { dashboard }));
+      }));
+      if (epoch !== epochRef.current) return;
+      setUpdated(/* @__PURE__ */ new Date());
+      const failures = settled.filter((result) => result.status === "rejected");
+      if (failures.length > 0) throw failureMessage("summary", failures);
+    })();
+    const owned = task.finally(() => {
+      if (summaryFlightRef.current === owned) summaryFlightRef.current = null;
+    });
+    summaryFlightRef.current = owned;
+    return owned;
+  }, [accountsKey, accountsRef, tz]);
+  const runBilling = useCallback3(() => {
+    if (billingFlightRef.current) return billingFlightRef.current;
+    const epoch = epochRef.current;
+    const task = (async () => {
+      const targets = accountsRef.current.filter((account) => {
+        const provider = PROVIDERS[account.providerId];
+        return provider.hasBilling && provider.fetchBilling;
+      });
+      const settled = await Promise.allSettled(targets.map(async (account) => {
+        const fetchBilling = PROVIDERS[account.providerId].fetchBilling;
+        if (!fetchBilling) return;
+        const billing = await withTimeout(fetchBilling(account, tz));
+        if (epoch === epochRef.current) setStats((prev) => upsert(prev, account, { billing }));
+      }));
+      if (epoch !== epochRef.current) return;
+      const failures = settled.filter((result) => result.status === "rejected");
+      if (failures.length > 0) throw failureMessage("billing", failures);
+    })();
+    const owned = task.finally(() => {
+      if (billingFlightRef.current === owned) billingFlightRef.current = null;
+    });
+    billingFlightRef.current = owned;
+    return owned;
+  }, [accountsKey, accountsRef, tz]);
+  const runPeak = useCallback3(() => {
+    if (peakFlightRef.current) return peakFlightRef.current;
+    if (!accountsRef.current.some((account) => account.providerId === "claude")) return Promise.resolve();
+    const epoch = epochRef.current;
+    const task = withTimeout(fetchPeak()).then((peak) => {
+      if (epoch === epochRef.current && peak) setPeak(peak);
+    });
+    const owned = task.finally(() => {
+      if (peakFlightRef.current === owned) peakFlightRef.current = null;
+    });
+    peakFlightRef.current = owned;
+    return owned;
+  }, [accountsKey, accountsRef]);
+  const runTable = useCallback3((providerId) => {
+    const existing = tableFlightsRef.current.get(providerId);
+    if (existing) return existing;
+    const epoch = epochRef.current;
+    const targets = accountsRef.current.filter((account) => account.providerId === providerId);
+    if (targets.length === 0 || !PROVIDERS[providerId].hasUsage) return Promise.resolve();
+    setLoadingTables((prev) => new Set(prev).add(providerId));
+    const task = (async () => {
+      const settled = await Promise.allSettled(targets.map(async (account) => {
+        const fetchTable = PROVIDERS[account.providerId].fetchTable;
+        return fetchTable ? withTimeout(fetchTable(account, tz)) : null;
+      }));
+      if (epoch !== epochRef.current) return;
+      const valid = settled.flatMap((result) => result.status === "fulfilled" && result.value ? [result.value] : []);
+      if (valid.length > 0) {
+        setTables((prev) => new Map(prev).set(providerId, coalesceTables(valid)));
+      }
+      const failures = settled.filter((result) => result.status === "rejected");
+      if (failures.length > 0) throw failureMessage(`${PROVIDERS[providerId].name} history`, failures);
+    })();
+    const owned = task.finally(() => {
+      if (tableFlightsRef.current.get(providerId) !== owned) return;
+      tableFlightsRef.current.delete(providerId);
+      setLoadingTables((prev) => {
+        if (!prev.has(providerId)) return prev;
+        const next = new Set(prev);
+        next.delete(providerId);
+        return next;
+      });
+    });
+    tableFlightsRef.current.set(providerId, owned);
+    return owned;
+  }, [accountsKey, accountsRef, tz]);
+  const refreshAll = useCallback3(() => {
+    if (allFlightRef.current) return allFlightRef.current;
+    const tasks = [runSummary(), runBilling(), runPeak()];
+    for (const providerId of usageProviders(accountsRef.current)) tasks.push(runTable(providerId));
+    const task = Promise.allSettled(tasks).then((settled) => {
+      const failures = settled.filter((result) => result.status === "rejected");
+      if (failures.length > 0) throw failureMessage("all-data", failures);
+      setUpdated(/* @__PURE__ */ new Date());
+    });
+    const owned = task.finally(() => {
+      if (allFlightRef.current === owned) allFlightRef.current = null;
+    });
+    allFlightRef.current = owned;
+    return owned;
+  }, [accountsRef, runBilling, runPeak, runSummary, runTable]);
   useEffect6(() => {
     if (!degraded || !configReady || showPicker) return;
     let active = true;
     let timer;
-    const load = async () => {
-      try {
-        await Promise.all(accountsRef.current.map(async (acc) => {
-          const provider = PROVIDERS[acc.providerId];
-          if (!provider.hasUsage || !provider.fetchSummary) return;
-          try {
-            const dashboard = await withTimeout(provider.fetchSummary(acc, tz));
-            if (active) setStats((prev) => upsert(prev, acc, { dashboard }));
-          } catch {
-          }
-        }));
-        if (active) {
-          setError(null);
-          setUpdated(/* @__PURE__ */ new Date());
-        }
-      } finally {
-        if (active) timer = setTimeout(load, interval);
-      }
+    const loop = async () => {
+      await runSummary().catch(() => {
+      });
+      if (active) timer = setTimeout(loop, interval);
     };
-    load();
+    void loop();
     return () => {
       active = false;
-      clearTimeout(timer);
+      if (timer) clearTimeout(timer);
     };
-  }, [degraded, interval, tz, configReady, showPicker, accountsKey]);
+  }, [degraded, configReady, showPicker, interval, runSummary]);
   useEffect6(() => {
     if (!degraded || !configReady || showPicker) return;
     let active = true;
     let timer;
-    const load = async () => {
-      try {
-        const peakP = accountsRef.current.some((a) => a.providerId === "claude") ? withTimeout(fetchPeak()).catch(() => null) : Promise.resolve(null);
-        await Promise.all(accountsRef.current.map(async (acc) => {
-          const provider = PROVIDERS[acc.providerId];
-          if (!provider.hasBilling || !provider.fetchBilling) return;
-          try {
-            const billing = await withTimeout(provider.fetchBilling(acc, tz));
-            if (active) setStats((prev) => upsert(prev, acc, { billing }));
-          } catch {
-          }
-        }));
-        const p = await peakP;
-        if (active && p) setPeak(p);
-      } finally {
-        if (active) timer = setTimeout(load, billingMs);
-      }
+    const loop = async () => {
+      await Promise.allSettled([runBilling(), runPeak()]);
+      if (active) timer = setTimeout(loop, billingMs);
+    };
+    void loop();
+    return () => {
+      active = false;
+      if (timer) clearTimeout(timer);
+    };
+  }, [degraded, configReady, showPicker, billingMs, runBilling, runPeak]);
+  useEffect6(() => {
+    if (!degraded || !configReady || showPicker || !tableVisible || !activeTableProvider) return;
+    let active = true;
+    let timer;
+    const loop = async () => {
+      await runTable(activeTableProvider).catch(() => {
+      });
+      if (active) timer = setTimeout(loop, Math.max(interval, 1e4));
     };
-    load();
+    void loop();
     return () => {
       active = false;
-      clearTimeout(timer);
+      if (timer) clearTimeout(timer);
+    };
+  }, [degraded, configReady, showPicker, tableVisible, activeTableProvider, interval, runTable]);
+  return {
+    statsLocal,
+    peakLocal,
+    updatedLocal,
+    tableLocal: activeTableProvider ? tables.get(activeTableProvider) ?? null : null,
+    tableLoading: activeTableProvider ? loadingTables.has(activeTableProvider) : false,
+    refreshAll
+  };
+}
+
+// src/ui/hooks/use-refresh-all.ts
+import { useCallback as useCallback4, useEffect as useEffect7, useRef as useRef6, useState as useState7 } from "react";
+var IDLE = { phase: "idle", message: "" };
+var CONNECTED_REFRESH_TIMEOUT_MS = 10 * 6e4;
+var STATUS_TTL_MS = 4e3;
+function awaitRefreshCompletion(request, timeoutMs = CONNECTED_REFRESH_TIMEOUT_MS) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`refresh is still running after ${Math.round(timeoutMs / 1e3)} seconds; it may finish in the background`));
+    }, timeoutMs);
+    timer.unref?.();
+    Promise.resolve().then(request).then(
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      (cause) => {
+        clearTimeout(timer);
+        reject(cause);
+      }
+    );
+  });
+}
+function errorText(cause) {
+  return cause instanceof Error && cause.message ? cause.message : "refresh failed";
+}
+function useRefreshAll({
+  connected,
+  requestDaemonRefresh,
+  requestDegradedRefresh
+}) {
+  const [status, setStatus] = useState7(IDLE);
+  const flightRef = useRef6(null);
+  const clearTimerRef = useRef6(null);
+  const mountedRef = useRef6(true);
+  useEffect7(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      if (clearTimerRef.current) clearTimeout(clearTimerRef.current);
     };
-  }, [degraded, billingMs, tz, configReady, showPicker, accountsKey]);
-  return { statsLocal, peakLocal, updatedLocal, error };
+  }, []);
+  const refreshAll = useCallback4(() => {
+    if (flightRef.current) return;
+    if (clearTimerRef.current) {
+      clearTimeout(clearTimerRef.current);
+      clearTimerRef.current = null;
+    }
+    setStatus({ phase: "refreshing", message: "Refreshing all data" });
+    const task = connected ? awaitRefreshCompletion(requestDaemonRefresh) : Promise.resolve().then(requestDegradedRefresh);
+    const owned = task.then(() => {
+      if (!mountedRef.current) return;
+      setStatus({
+        phase: "success",
+        message: "All data refreshed"
+      });
+    }).catch((cause) => {
+      if (!mountedRef.current) return;
+      setStatus({ phase: "error", message: `Refresh failed: ${errorText(cause)}` });
+    }).finally(() => {
+      if (flightRef.current === owned) flightRef.current = null;
+      if (!mountedRef.current) return;
+      clearTimerRef.current = setTimeout(() => {
+        clearTimerRef.current = null;
+        if (mountedRef.current) setStatus(IDLE);
+      }, STATUS_TTL_MS);
+      clearTimerRef.current.unref?.();
+    });
+    flightRef.current = owned;
+  }, [connected, requestDaemonRefresh, requestDegradedRefresh]);
+  return { status, refreshAll };
+}
+
+// src/ui/hooks/use-config-state.ts
+import { useCallback as useCallback5, useEffect as useEffect8, useRef as useRef7, useState as useState8 } from "react";
+
+// src/config-sync.ts
+function describeConfigUpdateFailure(cause) {
+  if (cause && typeof cause === "object") {
+    const failure = cause;
+    if (failure.kind === "conflict") {
+      const state = failure.state;
+      const revision = state?.config?.revision;
+      return {
+        message: typeof revision === "number" ? `configuration changed elsewhere (daemon revision ${revision})` : "settings changed elsewhere; reload before saving",
+        conflictState: state?.config && typeof revision === "number" ? state : null
+      };
+    }
+    if (failure.kind === "persistence" && typeof failure.message === "string") {
+      return { message: failure.message, conflictState: null };
+    }
+  }
+  return {
+    message: cause instanceof Error ? cause.message : "config update failed",
+    conflictState: null
+  };
+}
+
+// src/ui/hooks/use-config-state.ts
+function useConfigState({
+  initialConfig,
+  cliInterval,
+  connected,
+  daemon
+}) {
+  const [config, setConfig] = useState8(
+    () => initialConfig ? applyStartup(initialConfig, cliInterval) : null
+  );
+  const [configSaveError, setConfigSaveError] = useState8(null);
+  const configRef = useRef7(config);
+  const pendingRef = useRef7(null);
+  const queuedRef = useRef7(null);
+  configRef.current = config;
+  useEffect8(() => {
+    if (initialConfig) return;
+    void loadConfig().then((next) => setConfig(applyStartup(next, cliInterval)));
+  }, [initialConfig, cliInterval]);
+  const drain = useCallback5(async (first, expectedRevision) => {
+    let candidate = first;
+    let revision = expectedRevision;
+    try {
+      for (; ; ) {
+        const outgoing = { ...candidate, revision };
+        pendingRef.current = { config: outgoing, expectedRevision: revision };
+        const saved = await daemon.setConfig(outgoing, revision);
+        const queued = queuedRef.current;
+        queuedRef.current = null;
+        if (queued) {
+          candidate = queued;
+          revision = saved.config.revision;
+          continue;
+        }
+        pendingRef.current = null;
+        configRef.current = saved.config;
+        setConfig(saved.config);
+        setConfigSaveError(null);
+        return;
+      }
+    } catch (cause) {
+      pendingRef.current = null;
+      queuedRef.current = null;
+      const failure = describeConfigUpdateFailure(cause);
+      if (failure.conflictState) {
+        configRef.current = failure.conflictState.config;
+        setConfig(failure.conflictState.config);
+      }
+      setConfigSaveError(failure.message);
+    }
+  }, [daemon]);
+  const updateConfig = useCallback5((fn) => {
+    const current = configRef.current ?? DEFAULTS;
+    const next = normalizeConfig({ ...fn(current), revision: current.revision });
+    configRef.current = next;
+    setConfig(next);
+    setConfigSaveError(null);
+    if (connected) {
+      if (pendingRef.current) queuedRef.current = next;
+      else void drain(next, current.revision);
+      return;
+    }
+    try {
+      saveConfigSync(next);
+    } catch (cause) {
+      setConfigSaveError(cause instanceof Error ? cause.message : "config could not be saved");
+    }
+  }, [connected, drain]);
+  const daemonConfig = daemon.config?.config;
+  useEffect8(() => {
+    if (!connected || !daemonConfig || pendingRef.current) return;
+    if (daemonConfig.revision < (configRef.current?.revision ?? 0)) return;
+    configRef.current = daemonConfig;
+    setConfig(daemonConfig);
+  }, [connected, daemonConfig]);
+  return { config, configSaveError, updateConfig };
 }
 
 // src/ui/hooks/use-account-form.ts
-import { useState as useState7, useCallback as useCallback3 } from "react";
+import { useState as useState9, useCallback as useCallback6 } from "react";
 function useAccountForm({ cfg, detected, updateConfig, trackedAccountRows, setSettingsCursor }) {
-  const [accountForm, setAccountForm] = useState7(null);
+  const [accountForm, setAccountForm] = useState9(null);
   function openAddAccount(defaults) {
     const providerId = defaults?.providerId ?? (detected[0] ?? "claude");
     setAccountForm({
@@ -2888,7 +3202,7 @@ function useAccountForm({ cfg, detected, updateConfig, trackedAccountRows, setSe
     });
     setAccountForm(null);
   }
-  const cycleFormField = useCallback3((dir) => {
+  const cycleFormField = useCallback6((dir) => {
     setAccountForm((f) => {
       if (!f) return f;
       const i = FORM_FIELDS.indexOf(f.field);
@@ -2897,14 +3211,14 @@ function useAccountForm({ cfg, detected, updateConfig, trackedAccountRows, setSe
       return { ...f, field: next, caret };
     });
   }, []);
-  const cycleProvider = useCallback3((dir) => {
+  const cycleProvider = useCallback6((dir) => {
     setAccountForm((f) => {
       if (!f) return f;
       const i = PROVIDER_ORDER.indexOf(f.providerId);
       return { ...f, providerId: PROVIDER_ORDER[(i + dir + PROVIDER_ORDER.length) % PROVIDER_ORDER.length] };
     });
   }, []);
-  const cycleColor = useCallback3((dir) => {
+  const cycleColor = useCallback6((dir) => {
     setAccountForm((f) => {
       if (!f) return f;
       const i = COLOR_PALETTE.indexOf(f.color);
@@ -2945,39 +3259,42 @@ function useAccountForm({ cfg, detected, updateConfig, trackedAccountRows, setSe
 }
 
 // src/app.tsx
-import { Fragment as Fragment4, jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+import { Fragment as Fragment4, jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
 function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = null, mode = "degraded" }) {
   const connected = mode === "connected" && baseUrl !== null && wsToken !== null;
   const degraded = !connected;
   const daemon = useDaemon(connected ? baseUrl : null, connected ? wsToken : null);
-  const [config, setConfig] = useState8(() => initialConfig ? applyStartup(initialConfig, cliInterval) : null);
-  const [detected, setDetected] = useState8([]);
-  const [tableLocal, setTable] = useState8(null);
-  const [tableLoading, setTableLoading] = useState8(false);
-  const [tab, setTab] = useState8(0);
-  const [view, setView] = useState8(0);
-  const [cursor, setCursor] = useState8(0);
-  const [expanded, setExpanded] = useState8(-1);
-  const [sort, setSort] = useState8(1);
-  const [tableProvider, setTableProvider] = useState8(null);
-  const [tableModel, setTableModel] = useState8(null);
-  const [search, setSearch] = useState8("");
-  const [searchMode, setSearchMode] = useState8(false);
-  const [showSettings, setShowSettings] = useState8(false);
-  const [settingsTab, setSettingsTab] = useState8("general");
-  const [settingsCursor, setSettingsCursor] = useState8(0);
-  const [tzEdit, setTzEdit] = useState8(null);
-  const [tzError, setTzError] = useState8(null);
-  const [tzCaret, setTzCaret] = useState8(0);
-  const [searchCaret, setSearchCaret] = useState8(0);
-  const [onboardSel, setOnboardSel] = useState8(null);
-  const [onboardCursor, setOnboardCursor] = useState8(0);
-  const [dashPage, setDashPage] = useState8(0);
+  const { config, configSaveError, updateConfig } = useConfigState({
+    initialConfig,
+    cliInterval,
+    connected,
+    daemon
+  });
+  const [detected, setDetected] = useState10([]);
+  const [tab, setTab] = useState10(0);
+  const [view, setView] = useState10(0);
+  const [cursor, setCursor] = useState10(0);
+  const [expanded, setExpanded] = useState10(-1);
+  const [sort, setSort] = useState10(1);
+  const [tableProvider, setTableProvider] = useState10(null);
+  const [tableModel, setTableModel] = useState10(null);
+  const [search, setSearch] = useState10("");
+  const [searchMode, setSearchMode] = useState10(false);
+  const [showSettings, setShowSettings] = useState10(false);
+  const [settingsTab, setSettingsTab] = useState10("general");
+  const [settingsCursor, setSettingsCursor] = useState10(0);
+  const [tzEdit, setTzEdit] = useState10(null);
+  const [tzError, setTzError] = useState10(null);
+  const [tzCaret, setTzCaret] = useState10(0);
+  const [searchCaret, setSearchCaret] = useState10(0);
+  const [onboardSel, setOnboardSel] = useState10(null);
+  const [onboardCursor, setOnboardCursor] = useState10(0);
+  const [dashPage, setDashPage] = useState10(0);
   const { exit } = useApp();
   const { cols, rows, resizing, live } = useTerminalSize();
-  const webRef = useRef6(null);
-  const webStartingRef = useRef6(false);
-  useEffect7(() => () => {
+  const webRef = useRef8(null);
+  const webStartingRef = useRef8(false);
+  useEffect9(() => () => {
     void webRef.current?.stop();
   }, []);
   const cfg = config ?? DEFAULTS;
@@ -2988,22 +3305,38 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
   const accounts = useMemo2(() => buildAccounts(cfg, detected), [cfg, detected]);
   const trackedAccountRows = useMemo2(() => getTrackedAccountRows(cfg, detected, accounts), [cfg, detected, accounts]);
   const settingsRowCount = settingsTab === "general" ? GENERAL_ROWS : settingsTab === "providers" ? PROVIDER_ORDER.length : trackedAccountRows.length + 1;
-  const accountsRef = useRef6([]);
+  const accountsRef = useRef8([]);
   accountsRef.current = accounts;
-  const rowCountRef = useRef6(0);
-  const tabRef = useRef6(0);
+  const rowCountRef = useRef8(0);
+  const tabRef = useRef8(0);
   tabRef.current = tab;
-  const dashPageCountRef = useRef6(1);
-  const pendingLocalConfigRef = useRef6(null);
-  const tzValueRef = useRef6("");
-  const tzCaretRef = useRef6(0);
-  const searchValueRef = useRef6("");
-  const searchCaretRef = useRef6(0);
+  const dashPageCountRef = useRef8(1);
+  const tzValueRef = useRef8("");
+  const tzCaretRef = useRef8(0);
+  const searchValueRef = useRef8("");
+  const searchCaretRef = useRef8(0);
   const accountsKey = useMemo2(() => accounts.map(acctKey).join("|"), [accounts]);
+  const allGroups = useMemo2(() => accountsByProvider(accounts), [accounts]);
+  const tableProvs = useMemo2(
+    () => allGroups.map((g) => g.provider).filter((pid) => PROVIDERS[pid].hasUsage),
+    [allGroups]
+  );
+  const effTableProvider = tableProvider && tableProvs.includes(tableProvider) ? tableProvider : tableProvs[0] ?? null;
+  const tableAccounts = useMemo2(
+    () => effTableProvider ? accounts.filter((a) => a.providerId === effTableProvider) : [],
+    [accounts, effTableProvider]
+  );
   const needsOnboarding = configReady && !cfg.onboarded;
   const newProviders = configReady && cfg.onboarded ? PROVIDER_ORDER.filter((p) => !cfg.knownProviders.includes(p) && detected.includes(p)) : [];
   const showPicker = needsOnboarding || newProviders.length > 0;
-  const { statsLocal, peakLocal, updatedLocal, error } = useDegradedPolling({
+  const {
+    statsLocal,
+    peakLocal,
+    updatedLocal,
+    tableLocal,
+    tableLoading,
+    refreshAll: refreshAllDegraded
+  } = useDegradedPolling({
     degraded,
     configReady,
     showPicker,
@@ -3011,9 +3344,22 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
     accountsRef,
     interval,
     billingMs,
-    tz
+    tz,
+    activeTableProvider: effTableProvider,
+    tableVisible: tab === 1
   });
   const snapshot = daemon.snapshot;
+  const daemonRefreshRef = useRef8(daemon.refresh);
+  const degradedRefreshRef = useRef8(refreshAllDegraded);
+  daemonRefreshRef.current = daemon.refresh;
+  degradedRefreshRef.current = refreshAllDegraded;
+  const requestDaemonRefresh = useCallback7(() => daemonRefreshRef.current("all"), []);
+  const requestDegradedRefresh = useCallback7(() => degradedRefreshRef.current(), []);
+  const { status: refreshStatus, refreshAll } = useRefreshAll({
+    connected,
+    requestDaemonRefresh,
+    requestDegradedRefresh
+  });
   const stats = useMemo2(
     () => connected ? toStatsMap(snapshot, accounts) : statsLocal,
     [connected, snapshot, accounts, statsLocal]
@@ -3038,7 +3384,7 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
     [connected, snapshot, updatedLocal]
   );
   const intervalLabel = connected && snapshot?.intervalMs ? Math.round(snapshot.intervalMs / 1e3) : cfg.interval;
-  const readyInputFor = useCallback4((id) => {
+  const readyInputFor = useCallback7((id) => {
     if (connected) {
       const wa = snapshot?.accounts.find((a) => a.id === id);
       if (!wa) return void 0;
@@ -3055,15 +3401,10 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
     () => focusId === null ? accounts : accounts.filter((a) => a.id === focusId),
     [accounts, focusId]
   );
-  const allGroups = useMemo2(() => accountsByProvider(accounts), [accounts]);
   const groups = useMemo2(
     () => focusId === null ? allGroups : accountsByProvider(visibleAccounts),
     [allGroups, visibleAccounts, focusId]
   );
-  const tableProvs = useMemo2(
-    () => allGroups.map((g) => g.provider).filter((pid) => PROVIDERS[pid].hasUsage),
-    [allGroups]
-  );
   const TOO_SMALL = cols < 40 || rows < 12;
   const allReady = accounts.length > 0 && accounts.every((a) => accountReady(readyInputFor(a.id), a.providerId));
   const { gridBudget } = useMemo2(() => computeChrome(slots, cols, rows), [slots, cols, rows]);
@@ -3102,11 +3443,6 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
     }
   };
   const { handlePasteData, isPasteInput } = usePaste(insertText);
-  const effTableProvider = tableProvider && tableProvs.includes(tableProvider) ? tableProvider : tableProvs[0] ?? null;
-  const tableAccounts = useMemo2(
-    () => effTableProvider ? accounts.filter((a) => a.providerId === effTableProvider) : [],
-    [accounts, effTableProvider]
-  );
   const SORTS_FOR = SORTS;
   const tableAccountIds = useMemo2(() => tableAccounts.map((a) => a.id), [tableAccounts]);
   const table = useMemo2(
@@ -3131,67 +3467,36 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
     detected: detected.includes(pid),
     enabled: onboardEnabled.includes(pid)
   }));
-  useEffect7(() => {
-    if (!initialConfig) loadConfig().then((c) => setConfig(applyStartup(c, cliInterval)));
-    detectProviders().then(setDetected);
+  useEffect9(() => {
+    void detectProviders().then(setDetected);
   }, []);
   const tableKey = useMemo2(
     () => `${effTableProvider}|${tableAccounts.map(acctKey).join(",")}|${tz}`,
     [effTableProvider, tableAccounts, tz]
   );
-  useEffect7(() => {
-    setTable(null);
+  useEffect9(() => {
     setCursor(0);
     setExpanded(-1);
     setTableModel(null);
     setSort(1);
-    setTableLoading(false);
   }, [tableKey]);
-  useEffect7(() => {
-    if (!degraded || tab !== 1 || !effTableProvider) return;
-    let active = true;
-    let timer;
-    const fetchOnce = async () => {
-      try {
-        const r = await withTimeout(fetchScopeTable(tableAccounts, tz));
-        if (active) setTable(r);
-      } catch {
-      }
-    };
-    const run = async () => {
-      setTableLoading(true);
-      await fetchOnce();
-      if (!active) return;
-      setTableLoading(false);
-      const loop = async () => {
-        await fetchOnce();
-        if (active) timer = setTimeout(loop, Math.max(interval, 1e4));
-      };
-      timer = setTimeout(loop, Math.max(interval, 1e4));
-    };
-    run();
-    return () => {
-      active = false;
-      clearTimeout(timer);
-    };
-  }, [degraded, tab, tableKey, interval]);
-  useEffect7(() => {
+  useEffect9(() => {
     setCursor(0);
     setExpanded(-1);
   }, [search, tableModel]);
-  useEffect7(() => {
+  useEffect9(() => {
     setDashPage((p) => Math.min(p, dashPageCount - 1));
   }, [dashPageCount]);
-  useEffect7(() => {
+  useEffect9(() => {
     setSettingsCursor((c) => Math.max(-1, Math.min(c, settingsRowCount - 1)));
   }, [settingsRowCount]);
-  const resetView = useCallback4(() => {
+  const resetView = useCallback7(() => {
     setCursor(0);
     setExpanded(-1);
   }, []);
   const clampRow = (n) => Math.max(0, Math.min(rowCountRef.current - 1, n));
   const mouse = useMouse();
-  useEffect7(() => {
+  useEffect9(() => {
     if (!IS_TTY) return;
     mouse.enable();
     if (process.stdout.isTTY) {
@@ -3219,31 +3524,6 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
       process.stdin.off("data", onData);
     };
   }, []);
-  const updateConfig = useCallback4((fn) => {
-    setConfig((prev) => {
-      const next = normalizeConfig(fn(prev ?? DEFAULTS));
-      pendingLocalConfigRef.current = connected ? next : null;
-      saveConfigSync(next);
-      if (connected) {
-        void daemon.setConfig(next).then((saved) => {
-          if (pendingLocalConfigRef.current && reconcileDaemonConfig(next, saved, pendingLocalConfigRef.current).pendingLocalConfig === null) {
-            pendingLocalConfigRef.current = null;
-          }
-        }).catch(() => {
-        });
-      }
-      return next;
-    });
-  }, [connected, daemon]);
-  const daemonConfig = daemon.config;
-  useEffect7(() => {
-    if (!connected || !daemonConfig) return;
-    setConfig((prev) => {
-      const reconciled = reconcileDaemonConfig(prev, daemonConfig, pendingLocalConfigRef.current);
-      pendingLocalConfigRef.current = reconciled.pendingLocalConfig;
-      return reconciled.config;
-    });
-  }, [connected, daemonConfig]);
   function toggleOnboard(i) {
     if (i < 0 || i >= pickerProviders.length) return;
     const pid = pickerProviders[i];
@@ -3280,13 +3560,13 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
     setOnboardSel(null);
     setOnboardCursor(0);
   }
-  const cycleAccount = useCallback4((dir) => {
+  const cycleAccount = useCallback7((dir) => {
     if (slots.length <= 1) return;
     const next = (activeSlotIdx + dir + slots.length) % slots.length;
     updateConfig((c) => ({ ...c, activeAccountId: slots[next].id }));
     resetView();
   }, [slots, activeSlotIdx, updateConfig, resetView]);
-  const cycleTableProvider = useCallback4((dir) => {
+  const cycleTableProvider = useCallback7((dir) => {
     if (tableProvs.length <= 1) return;
     const cur = effTableProvider ? tableProvs.indexOf(effTableProvider) : 0;
     const nextProv = tableProvs[(cur + dir + tableProvs.length) % tableProvs.length];
@@ -3318,30 +3598,30 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
       return;
     }
     if (webRef.current) {
-      openUrl(webRef.current.url);
+      openUrl(webRef.current.browserUrl);
       return;
     }
     if (webStartingRef.current) return;
     webStartingRef.current = true;
     try {
-      const { startWebServer } = await import("./server-GA2FKYDQ.js");
+      const { startWebServer } = await import("./server-4CDZMLH6.js");
       const ctrl = await startWebServer({ config: cfg, log: false });
       webRef.current = ctrl;
-      openUrl(ctrl.url);
+      openUrl(ctrl.browserUrl);
     } catch {
     } finally {
       webStartingRef.current = false;
     }
   }
-  const onTabSelect = useCallback4((i) => {
+  const onTabSelect = useCallback7((i) => {
     setTab(i);
     resetView();
   }, [resetView]);
-  const onStripSelect = useCallback4((i) => {
+  const onStripSelect = useCallback7((i) => {
     updateConfig((c) => ({ ...c, activeAccountId: slots[i].id }));
     resetView();
   }, [slots, updateConfig, resetView]);
-  const onProviderSelect = useCallback4((p) => {
+  const onProviderSelect = useCallback7((p) => {
     setTableProvider(p);
     setCursor(0);
     setExpanded(-1);
@@ -3350,7 +3630,7 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
     setSearchCaret(0);
     setSearchMode(false);
   }, []);
-  const onRowClickToken = useCallback4((idx) => {
+  const onRowClickToken = useCallback7((idx) => {
     if (idx === cursor) setExpanded((e) => e === idx ? -1 : idx);
     else setCursor(idx);
   }, [cursor]);
@@ -3359,10 +3639,10 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
     [tab, table, view]
   );
   const tokenModelOptions = useMemo2(() => tableModelOptions(rawTokenRows), [rawTokenRows]);
-  useEffect7(() => {
+  useEffect9(() => {
     if (tableModel && !tokenModelOptions.includes(tableModel)) setTableModel(null);
   }, [tableModel, tokenModelOptions]);
-  const cycleTableModelFilter = useCallback4((dir) => {
+  const cycleTableModelFilter = useCallback7((dir) => {
     setTableModel((cur) => cycleTableModel(cur, tokenModelOptions, dir));
     resetView();
   }, [tokenModelOptions, resetView]);
@@ -3372,77 +3652,86 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
     [tab, rawTokenRows, activeTableModel, search, sort]
   );
   useInput((input, key) => handleKey(input, key, {
-    showPicker,
-    pickerProviders,
-    onboardCursor,
-    setOnboardCursor,
-    toggleOnboard,
-    confirmOnboarding,
-    exit,
-    showSettings,
-    accountForm,
-    setAccountForm,
-    commitAccountForm,
-    cycleFormField,
-    cycleProvider,
-    cycleColor,
-    isPrintable,
-    insertText,
-    tzEdit,
-    setTzEdit,
-    setTzError,
-    updateConfig,
-    setTzCaret,
-    tzValueRef,
-    tzCaretRef,
-    tab,
-    searchMode,
-    setSearchMode,
-    search,
-    setSearch,
-    setSearchCaret,
-    searchValueRef,
-    searchCaretRef,
-    showLoader,
-    configReady,
-    toggleWeb,
-    settingsCursor,
-    settingsTab,
-    setSettingsTab,
-    setShowSettings,
-    cfg,
-    trackedAccountRows,
-    moveAccount,
-    setSettingsCursor,
-    toggleProvider,
-    openEditAccount,
-    openConfigureAccount,
-    deleteAccount,
-    openAddAccount,
-    cycleAccount,
-    setTab,
-    resetView,
-    slots,
-    dashPaginated,
-    dashPageCount,
-    setDashPage,
-    cycleTableProvider,
-    setExpanded,
-    setSort,
-    SORTS_FOR,
-    cycleTableModel: cycleTableModelFilter,
-    setView,
-    cursor,
-    rowCountRef,
-    rows,
-    setCursor,
-    clampRow
+    onboarding: {
+      show: showPicker,
+      providers: pickerProviders,
+      cursor: onboardCursor,
+      setCursor: setOnboardCursor,
+      toggle: toggleOnboard,
+      confirm: confirmOnboarding
+    },
+    accountEditor: {
+      form: accountForm,
+      setForm: setAccountForm,
+      commit: commitAccountForm,
+      cycleField: cycleFormField,
+      cycleProvider,
+      cycleColor
+    },
+    timezoneEditor: {
+      value: tzEdit,
+      setValue: setTzEdit,
+      setError: setTzError,
+      setCaret: setTzCaret,
+      valueRef: tzValueRef,
+      caretRef: tzCaretRef
+    },
+    textInput: { isPrintable, insert: insertText },
+    settings: {
+      show: showSettings,
+      setShow: setShowSettings,
+      cursor: settingsCursor,
+      tab: settingsTab,
+      setTab: setSettingsTab,
+      setCursor: setSettingsCursor,
+      trackedAccounts: trackedAccountRows,
+      moveAccount,
+      toggleProvider,
+      openEditAccount,
+      openConfigureAccount,
+      deleteAccount,
+      openAddAccount
+    },
+    table: {
+      tab,
+      searchMode,
+      setSearchMode,
+      search,
+      setSearch,
+      setSearchCaret,
+      searchValueRef,
+      searchCaretRef,
+      cycleProvider: cycleTableProvider,
+      setExpanded,
+      setSort,
+      sorts: SORTS_FOR,
+      cycleModel: cycleTableModelFilter,
+      setView,
+      cursor,
+      rowCountRef,
+      rows,
+      setCursor,
+      clampRow
+    },
+    dashboard: { paginated: dashPaginated, pageCount: dashPageCount, setPage: setDashPage },
+    global: {
+      exit,
+      showLoader,
+      configReady,
+      toggleWeb,
+      config: cfg,
+      updateConfig,
+      cycleAccount,
+      setTab,
+      resetView,
+      slots,
+      refreshAll
+    }
   }), { isActive: IS_TTY });
-  if (error) return /* @__PURE__ */ jsx11(Box11, { padding: 1, children: /* @__PURE__ */ jsx11(Text11, { color: "red", children: error }) });
-  if (!config) return /* @__PURE__ */ jsx11(Box11, { padding: 1, children: /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Loading..." }) });
-  if (resizing) return /* @__PURE__ */ jsx11(ResizingView, { cols: live.cols, rows: live.rows });
+  if (!config) return /* @__PURE__ */ jsx12(Box11, { padding: 1, children: /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "Loading..." }) });
+  if (resizing) return /* @__PURE__ */ jsx12(ResizingView, { cols: live.cols, rows: live.rows });
   if (showPicker) {
-    return /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", paddingX: 2, paddingY: 1, height: rows, children: /* @__PURE__ */ jsx11(
+    return /* @__PURE__ */ jsx12(Box11, { flexDirection: "column", paddingX: 2, paddingY: 1, height: rows, children: /* @__PURE__ */ jsx12(
       Onboarding,
       {
         items: onboardItems,
@@ -3455,20 +3744,20 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
     ) });
   }
   if (showLoader) {
-    return /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", paddingX: 2, paddingY: 1, height: rows, overflow: "hidden", children: /* @__PURE__ */ jsx11(LoadingView, { groups: allGroups, stats, cols, rows, readyInput: readyInputFor, privacyMode: cfg.privacyMode }) });
+    return /* @__PURE__ */ jsx12(Box11, { flexDirection: "column", paddingX: 2, paddingY: 1, height: rows, overflow: "hidden", children: /* @__PURE__ */ jsx12(LoadingView, { groups: allGroups, stats, cols, rows, readyInput: readyInputFor, privacyMode: cfg.privacyMode }) });
   }
   if (TOO_SMALL && !showSettings) {
-    return /* @__PURE__ */ jsx11(TinyFallback, { groups, stats, rows, cols });
+    return /* @__PURE__ */ jsx12(TinyFallback, { groups, stats, rows, cols, refreshStatus });
   }
   rowCountRef.current = tokenRows.length;
-  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", paddingX: 2, paddingY: 1, height: rows, overflow: "hidden", children: [
-    /* @__PURE__ */ jsxs11(Box11, { justifyContent: "space-between", children: [
-      /* @__PURE__ */ jsxs11(Box11, { children: [
-        /* @__PURE__ */ jsxs11(Text11, { bold: true, color: "greenBright", children: [
+  return /* @__PURE__ */ jsxs12(Box11, { flexDirection: "column", paddingX: 2, paddingY: 1, height: rows, overflow: "hidden", children: [
+    /* @__PURE__ */ jsxs12(Box11, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs12(Box11, { children: [
+        /* @__PURE__ */ jsxs12(Text12, { bold: true, color: "greenBright", children: [
           glyphs().dotSel,
           " tokmon"
         ] }),
-        /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+        /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
           "  ",
           glyphs().middot,
           "  every ",
@@ -3476,31 +3765,37 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
           "s"
         ] })
       ] }),
-      /* @__PURE__ */ jsxs11(Box11, { children: [
-        peak && /* @__PURE__ */ jsxs11(Fragment4, { children: [
-          /* @__PURE__ */ jsx11(PeakBadge, { peak }),
-          /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs12(Box11, { children: [
+        peak && /* @__PURE__ */ jsxs12(Fragment4, { children: [
+          /* @__PURE__ */ jsx12(PeakBadge, { peak }),
+          /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
             "  ",
             glyphs().middot,
             "  "
           ] })
         ] }),
-        /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: time(updated, tz) })
+        /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: time(updated, tz) })
       ] })
     ] }),
-    degraded && /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+    degraded && /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
       glyphs().warn,
       " degraded ",
       glyphs().middot,
       " background service unavailable, running in-process"
     ] }),
-    connected && daemon.conn !== "live" && /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+    connected && daemon.conn !== "live" && /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
       glyphs().warn,
       " reconnecting ",
       glyphs().middot,
       " showing last known data"
     ] }),
-    showSettings ? /* @__PURE__ */ jsx11(
+    configSaveError && /* @__PURE__ */ jsxs12(Text12, { color: "red", children: [
+      glyphs().warn,
+      " ",
+      configSaveError
+    ] }),
+    /* @__PURE__ */ jsx12(RefreshStatusLine, { status: refreshStatus }),
+    showSettings ? /* @__PURE__ */ jsx12(
       SettingsView,
       {
         config: cfg,
@@ -3515,20 +3810,20 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
         trackedAccounts: trackedAccountRows,
         accountIdentities
       }
-    ) : /* @__PURE__ */ jsxs11(Fragment4, { children: [
-      /* @__PURE__ */ jsxs11(Box11, { marginTop: 1, marginBottom: 1, children: [
-        /* @__PURE__ */ jsx11(TabBar, { tabs: TABS, active: tab, onSelect: onTabSelect }),
-        /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+    ) : /* @__PURE__ */ jsxs12(Fragment4, { children: [
+      /* @__PURE__ */ jsxs12(Box11, { marginTop: 1, marginBottom: 1, children: [
+        /* @__PURE__ */ jsx12(TabBar, { tabs: TABS, active: tab, onSelect: onTabSelect }),
+        /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
           "  Tab/",
           glyphs().arrowL,
           glyphs().arrowR
         ] })
       ] }),
-      tab === 0 && /* @__PURE__ */ jsxs11(Fragment4, { children: [
-        /* @__PURE__ */ jsx11(DashboardView, { groups, stats, cols, budget: gridBudget, focusId, layout: cfg.dashboardLayout, page: dashPage, privacyMode: cfg.privacyMode }),
-        slots.length > 1 && /* @__PURE__ */ jsxs11(Box11, { marginTop: 1, children: [
-          /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "focus  " }),
-          /* @__PURE__ */ jsx11(
+      tab === 0 && /* @__PURE__ */ jsxs12(Fragment4, { children: [
+        /* @__PURE__ */ jsx12(DashboardView, { groups, stats, cols, budget: gridBudget, focusId, layout: cfg.dashboardLayout, page: dashPage, privacyMode: cfg.privacyMode }),
+        slots.length > 1 && /* @__PURE__ */ jsxs12(Box11, { marginTop: 1, children: [
+          /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "focus  " }),
+          /* @__PURE__ */ jsx12(
             AccountStrip,
             {
               slots,
@@ -3537,12 +3832,12 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
             }
           )
         ] }),
-        /* @__PURE__ */ jsx11(TotalsRow, { groups, stats, cols })
+        /* @__PURE__ */ jsx12(TotalsRow, { groups, stats, cols })
       ] }),
-      tab === 1 && /* @__PURE__ */ jsxs11(Fragment4, { children: [
-        tableProvs.length > 0 && /* @__PURE__ */ jsx11(TableProviderBar, { providers: tableProvs, active: effTableProvider, onSelect: onProviderSelect }),
-        /* @__PURE__ */ jsx11(Box11, { height: 1 }),
-        /* @__PURE__ */ jsx11(
+      tab === 1 && /* @__PURE__ */ jsxs12(Fragment4, { children: [
+        tableProvs.length > 0 && /* @__PURE__ */ jsx12(TableProviderBar, { providers: tableProvs, active: effTableProvider, onSelect: onProviderSelect }),
+        /* @__PURE__ */ jsx12(Box11, { height: 1 }),
+        /* @__PURE__ */ jsx12(
           ControlBar,
           {
             views: VIEWS,
@@ -3556,12 +3851,12 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
             showModel: true
           }
         ),
-        /* @__PURE__ */ jsx11(Box11, { height: 1 }),
-        !effTableProvider ? /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+        /* @__PURE__ */ jsx12(Box11, { height: 1 }),
+        !effTableProvider ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
           "No providers enabled ",
           glyphs().emDash,
           " press s to pick providers."
-        ] }) : tableLoading && !table ? /* @__PURE__ */ jsx11(Spinner, { label: "Loading history" }) : /* @__PURE__ */ jsx11(
+        ] }) : tableLoading && !table ? /* @__PURE__ */ jsx12(Spinner, { label: "Loading history" }) : /* @__PURE__ */ jsx12(
           TokenTable,
           {
             rows: tokenRows,
@@ -3574,12 +3869,12 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, wsToken = n
         )
       ] })
     ] }),
-    (tab === 0 || showSettings) && /* @__PURE__ */ jsx11(Footer, { hasAccounts: slots.length > 1, paginated: tab === 0 && dashPaginated, cols })
+    (tab === 0 || showSettings) && /* @__PURE__ */ jsx12(Footer, { hasAccounts: slots.length > 1, paginated: tab === 0 && dashPaginated, cols })
   ] });
 }
 
 // src/bootstrap-ink.tsx
-import { jsx as jsx12 } from "react/jsx-runtime";
+import { jsx as jsx13 } from "react/jsx-runtime";
 function enterAltScreen() {
   process.stdout.write("\x1B[?1049h\x1B[H");
 }
@@ -3608,7 +3903,7 @@ async function bootstrapInk({ interval, config, daemon, mode }) {
     if (altScreen) leaveAltScreen();
   });
   const { waitUntilExit } = render(
-    /* @__PURE__ */ jsx12(MouseProvider, { children: /* @__PURE__ */ jsx12(
+    /* @__PURE__ */ jsx13(MouseProvider, { children: /* @__PURE__ */ jsx13(
       App,
       {
         interval,