@arbidocs/react 0.5.84 → 0.5.86

package/dist/index.cjs

@@ -176,8 +176,8 @@ function useStartTaskQuery() {
   };
   const lookUpThread = async (messageId, attempts, known) => {
     let conversationId;
-    for (let attempt = 0; attempt < attempts && !conversationId; attempt += 1) {
-      if (attempt > 0) await new Promise((r) => setTimeout(r, THREAD_LOOKUP_DELAY_MS));
+    for (let attempt2 = 0; attempt2 < attempts && !conversationId; attempt2 += 1) {
+      if (attempt2 > 0) await new Promise((r) => setTimeout(r, THREAD_LOOKUP_DELAY_MS));
       try {
         conversationId = await threadOf(messageId, known);
       } catch (error) {
@@ -1797,9 +1797,9 @@ function useWorkspaceProcessing(workspaceId) {
   }, []);
   React.useEffect(() => {
     if (!workspaceId) return;
-    const store = chunkQ6U7ALNV_cjs.useArbiWsStore.getState();
+    const store3 = chunkQ6U7ALNV_cjs.useArbiWsStore.getState();
     const documents2 = chunkQ6U7ALNV_cjs.getCachedDocuments(queryClient, workspaceId) ?? [];
-    store.settleTasks(documents2);
+    store3.settleTasks(documents2);
     const listed = new Set(documents2.map((d) => d.external_id));
     const now = Date.now();
     for (const task of Object.values(chunkQ6U7ALNV_cjs.useArbiWsStore.getState().tasks)) {
@@ -1809,7 +1809,7 @@ function useWorkspaceProcessing(workspaceId) {
       const age = since == null ? null : now - since;
       const stale = age != null && age > STALE_TASK_MS;
       const orphan = documents2.length > 0 && !listed.has(task.doc_ext_id) && age != null && age > ORPHAN_TASK_MS;
-      if (stale || orphan) store.clearTask(task.doc_ext_id);
+      if (stale || orphan) store3.clearTask(task.doc_ext_id);
     }
   }, [workspaceId, queryClient]);
   React.useEffect(() => {
@@ -1854,25 +1854,25 @@ function useWorkspaceProcessing(workspaceId) {
   }, [workspaceId, snapshot]);
 }
 function applyOptimisticDocumentEdit(qc, updates) {
-  const byId = new Map(updates.map((update) => [update.external_id, update]));
+  const byId = new Map(updates.map((update2) => [update2.external_id, update2]));
   const previous = [];
   chunkQ6U7ALNV_cjs.patchDocuments(qc, (old) => {
     let changed = false;
     const next = old.map((doc) => {
-      const update = byId.get(doc.external_id);
-      if (!update) return doc;
+      const update2 = byId.get(doc.external_id);
+      if (!update2) return doc;
       changed = true;
       previous.push(doc);
-      return { ...doc, ...update };
+      return { ...doc, ...update2 };
     });
     return changed ? next : old;
   });
-  const previousOwn = updates.map((update) => {
+  const previousOwn = updates.map((update2) => {
     const own = qc.getQueryData(
-      chunkU4PWVSCT_cjs.arbiQueryKeys.document(update.external_id)
+      chunkU4PWVSCT_cjs.arbiQueryKeys.document(update2.external_id)
     );
-    if (own) chunkQ6U7ALNV_cjs.setCachedDocument(qc, { ...own, ...update });
-    return [update.external_id, own];
+    if (own) chunkQ6U7ALNV_cjs.setCachedDocument(qc, { ...own, ...update2 });
+    return [update2.external_id, own];
   });
   return { optimistic: true, previous, previousOwn };
 }
@@ -2202,11 +2202,11 @@ function useUpdateDocTag() {
   );
 }
 function queueProcessing(documents2) {
-  const store = chunkQ6U7ALNV_cjs.useArbiWsStore.getState();
-  const previous = documents2.map(({ docId }) => [docId, store.tasks[docId]]);
+  const store3 = chunkQ6U7ALNV_cjs.useArbiWsStore.getState();
+  const previous = documents2.map(({ docId }) => [docId, store3.tasks[docId]]);
   const now = Date.now();
   for (const doc of documents2)
-    store.putTask({
+    store3.putTask({
       doc_ext_id: doc.docId,
       workspace_ext_id: doc.workspaceId,
       file_name: doc.fileName,
@@ -3983,14 +3983,14 @@ function watchPendingDocIds(queryClient) {
   if (watched.has(queryClient)) return;
   watched.add(queryClient);
   const cache = queryClient.getMutationCache();
-  const update = () => {
+  const update2 = () => {
     const ids = new Set(
       cache.findAll({ predicate: PENDING_SYNC_PREDICATE }).flatMap((m) => docIdsFromVariables(kindOf(m.options.mutationKey), m.state.variables))
     );
     if (!sameSet(usePendingDocIds.getState().ids, ids)) usePendingDocIds.setState({ ids });
   };
-  update();
-  cache.subscribe(update);
+  update2();
+  cache.subscribe(update2);
 }
 function useDocumentPendingSync(docId) {
   const queryClient = reactQuery.useQueryClient();
@@ -4029,23 +4029,23 @@ function promisify(request) {
     request.onerror = () => reject(request.error);
   });
 }
-async function withStore(mode, run) {
+async function withStore(mode, run2) {
   const db = await openDB();
-  const store = db.transaction(STORE, mode).objectStore(STORE);
-  return promisify(run(store));
+  const store3 = db.transaction(STORE, mode).objectStore(STORE);
+  return promisify(run2(store3));
 }
 async function putOfflineDocument(record) {
-  await withStore("readwrite", (store) => store.put(record));
+  await withStore("readwrite", (store3) => store3.put(record));
 }
 async function getOfflineDocument(docExtId) {
-  const record = await withStore("readonly", (store) => store.get(docExtId));
+  const record = await withStore("readonly", (store3) => store3.get(docExtId));
   return record;
 }
 async function deleteOfflineDocument(docExtId) {
-  await withStore("readwrite", (store) => store.delete(docExtId));
+  await withStore("readwrite", (store3) => store3.delete(docExtId));
 }
 async function listOfflineDocumentIds() {
-  const keys = await withStore("readonly", (store) => store.getAllKeys());
+  const keys = await withStore("readonly", (store3) => store3.getAllKeys());
   return keys;
 }
 async function requestPersistentStorage() {
@@ -5420,7 +5420,7 @@ function useAttachRun(conversationId, responseId) {
     if (!conversationId || !responseId) return;
     let disposed = false;
     let controller = new AbortController();
-    let retryTimer;
+    let retryTimer2;
     let reconnects = 0;
     const runStartedAt = session.getState().messageTimers[`${conversationId}:${responseId}`]?.startTime;
     session.setConversationGenerating(conversationId, true, null);
@@ -5445,7 +5445,7 @@ function useAttachRun(conversationId, responseId) {
       if (isMessageRunning(queryClient, conversationId, responseId) && reconnects < MAX_RECONNECTS) {
         reconnects += 1;
         markLoading();
-        retryTimer = setTimeout(connect, RECONNECT_DELAY_MS);
+        retryTimer2 = setTimeout(connect, RECONNECT_DELAY_MS);
         return;
       }
       settle(false);
@@ -5531,7 +5531,7 @@ function useAttachRun(conversationId, responseId) {
     const stop = () => {
       if (disposed) return;
       disposed = true;
-      clearTimeout(retryTimer);
+      clearTimeout(retryTimer2);
       window.removeEventListener("online", reconnectWhenOnline);
       controller.abort();
       settle(true);
@@ -5540,7 +5540,7 @@ function useAttachRun(conversationId, responseId) {
     return () => {
       unregister();
       disposed = true;
-      clearTimeout(retryTimer);
+      clearTimeout(retryTimer2);
       window.removeEventListener("online", reconnectWhenOnline);
       controller.abort();
       settle(false);
@@ -6342,20 +6342,20 @@ function useConversationSettings() {
   React.useEffect(() => {
     if (isFullConfig(activeConfig)) session.setChatModelName(resolveConfigModel(activeConfig));
   }, [activeConfig, configToLoad]);
-  const update = useUpdateConversation();
-  const pending = update.isPending ? update.variables?.patch : void 0;
+  const update2 = useUpdateConversation();
+  const pending = update2.isPending ? update2.variables?.patch : void 0;
   const saveTitle = React.useCallback(() => {
     const trimmed = title.trim();
     if (!conversationId || !isOwner || !trimmed || trimmed.length > TITLE_MAX) return;
     if (trimmed === conversation?.title) return;
-    update.mutate({ conversationId, patch: { title: trimmed } });
-  }, [conversationId, isOwner, title, conversation?.title, update]);
+    update2.mutate({ conversationId, patch: { title: trimmed } });
+  }, [conversationId, isOwner, title, conversation?.title, update2]);
   const setShared = React.useCallback(
     (shared) => {
       if (!conversationId || !isOwner || isShared === shared) return;
-      update.mutate({ conversationId, patch: { shared } });
+      update2.mutate({ conversationId, patch: { shared } });
     },
-    [conversationId, isOwner, isShared, update]
+    [conversationId, isOwner, isShared, update2]
   );
   const share = React.useCallback(() => setShared(true), [setShared]);
   const unshare = React.useCallback(() => setShared(false), [setShared]);
@@ -6783,7 +6783,7 @@ function useOnlineSync() {
     reactQuery.onlineManager.setOnline(computeOnline(wsStatus, signedIn2, workOffline, wsEverConnected.current));
   }, [wsStatus, signedIn2, workOffline]);
   React.useEffect(() => {
-    const update = () => reactQuery.onlineManager.setOnline(
+    const update2 = () => reactQuery.onlineManager.setOnline(
       computeOnline(
         chunkQ6U7ALNV_cjs.useArbiWsStore.getState().status,
         signedInRef.current,
@@ -6791,11 +6791,11 @@ function useOnlineSync() {
         wsEverConnected.current
       )
     );
-    window.addEventListener("online", update);
-    window.addEventListener("offline", update);
+    window.addEventListener("online", update2);
+    window.addEventListener("offline", update2);
     return () => {
-      window.removeEventListener("online", update);
-      window.removeEventListener("offline", update);
+      window.removeEventListener("online", update2);
+      window.removeEventListener("offline", update2);
     };
   }, [session]);
 }
@@ -6815,8 +6815,8 @@ function useReconnect() {
 // src/websocket/reconnect.ts
 var INITIAL_RECONNECT_DELAY_MS = 1e3;
 var MAX_RECONNECT_DELAY_MS = 3e4;
-function nextReconnectDelay(attempt) {
-  return Math.min(INITIAL_RECONNECT_DELAY_MS * 2 ** Math.max(0, attempt), MAX_RECONNECT_DELAY_MS);
+function nextReconnectDelay(attempt2) {
+  return Math.min(INITIAL_RECONNECT_DELAY_MS * 2 ** Math.max(0, attempt2), MAX_RECONNECT_DELAY_MS);
 }
 function resolveSocketBaseUrl(configured, origin) {
   return /^https?:\/\//.test(configured) || !origin ? configured : origin;
@@ -7101,13 +7101,13 @@ function useUpdateMailMessage() {
     mutationFn: ({
       accountId,
       messageId,
-      update
+      update: update2
     }) => mailJson(
       client.fetch,
       `${accountPath(accountId)}/messages/${encodeURIComponent(messageId)}`,
       {
         method: "PATCH",
-        body: JSON.stringify(update)
+        body: JSON.stringify(update2)
       }
     )
   });
@@ -7429,15 +7429,15 @@ function ArbiWebSocketProvider({
         }
       }
     };
-    let retryTimer = null;
-    let attempt = 0;
+    let retryTimer2 = null;
+    let attempt2 = 0;
     const scheduleRestart = () => {
-      if (cancelled || evicted || retryTimer) return;
+      if (cancelled || evicted || retryTimer2) return;
       setStatus("disconnected");
-      const delay = nextReconnectDelay(attempt);
-      attempt += 1;
-      retryTimer = setTimeout(() => {
-        retryTimer = null;
+      const delay = nextReconnectDelay(attempt2);
+      attempt2 += 1;
+      retryTimer2 = setTimeout(() => {
+        retryTimer2 = null;
         void start();
       }, delay);
     };
@@ -7468,7 +7468,7 @@ function ArbiWebSocketProvider({
           onMessage,
           onReconnecting: () => setStatus("reconnecting"),
           onReconnected: () => {
-            attempt = 0;
+            attempt2 = 0;
             setStatus("connected");
           },
           // Evicted (a newer session of the same user, or the server took this connection over for a
@@ -7490,7 +7490,7 @@ function ArbiWebSocketProvider({
           return;
         }
         conn = c;
-        attempt = 0;
+        attempt2 = 0;
         setStatus("connected");
       } catch {
         if (!info.signal.aborted) scheduleRestart();
@@ -7500,7 +7500,7 @@ function ArbiWebSocketProvider({
     void start();
     return () => {
       cancelled = true;
-      if (retryTimer) clearTimeout(retryTimer);
+      if (retryTimer2) clearTimeout(retryTimer2);
       conn?.close();
       reset();
     };
@@ -7575,10 +7575,10 @@ function createWorkspaceSwitch({
   queryClient
 }) {
   const switchWorkspace = (target) => {
-    const run = runSwitch(target);
-    switching.add(run);
-    void run.finally(() => switching.delete(run));
-    return run;
+    const run2 = runSwitch(target);
+    switching.add(run2);
+    void run2.finally(() => switching.delete(run2));
+    return run2;
   };
   const runSwitch = async (target) => {
     const { workspaceId: previousId, workspaceStatus } = session.getState();
@@ -8245,7 +8245,7 @@ function useFactsSearch(options = {}) {
   const workspaceId = options.workspaceId ?? (arbi.hasWorkspace ? arbi.getWorkspaceId() : null);
   const [kept, setKept] = chunk2Y2WOIHH_cjs.useTransientView(FACTS_SEARCH_VIEW, EMPTY2);
   const searchFacts = useSearchFacts(workspaceId);
-  const run = React.useRef(0);
+  const run2 = React.useRef(0);
   const foreign = !!kept.workspaceId && !!workspaceId && kept.workspaceId !== workspaceId;
   const state = foreign ? EMPTY2 : kept;
   const patch = React.useCallback(
@@ -8260,18 +8260,18 @@ function useFactsSearch(options = {}) {
   const search = React.useCallback(async () => {
     const q = query.trim();
     if (!q) return;
-    const mine = ++run.current;
+    const mine = ++run2.current;
     try {
       const res = await searchFacts.mutateAsync({ query: q, search_mode: mode, limit });
-      if (run.current !== mine) return;
+      if (run2.current !== mine) return;
       patch({ hits: res.facts, lastQuery: q });
     } catch (error) {
-      if (run.current !== mine) return;
+      if (run2.current !== mine) return;
       throw error;
     }
   }, [query, searchFacts, mode, limit, patch]);
   const clear = React.useCallback(() => {
-    run.current++;
+    run2.current++;
     patch({ query: "", hits: null });
   }, [patch]);
   return {
@@ -8489,26 +8489,26 @@ var DEFAULT_LIMIT = 50;
 var pad = (n) => String(n).padStart(2, "0");
 function asDay(value) {
   if (typeof value !== "string" || value.length < 10) return null;
-  const day = /* @__PURE__ */ new Date(`${value.slice(0, 10)}T00:00:00Z`);
-  return Number.isNaN(day.getTime()) ? null : day;
+  const day2 = /* @__PURE__ */ new Date(`${value.slice(0, 10)}T00:00:00Z`);
+  return Number.isNaN(day2.getTime()) ? null : day2;
 }
-function isoWeek(day) {
-  const d = new Date(day);
+function isoWeek(day2) {
+  const d = new Date(day2);
   const weekday = d.getUTCDay() || 7;
   d.setUTCDate(d.getUTCDate() + 4 - weekday);
   const yearStart = Date.UTC(d.getUTCFullYear(), 0, 1);
   return [d.getUTCFullYear(), Math.ceil(((d.getTime() - yearStart) / 864e5 + 1) / 7)];
 }
-function bucketOf(value, bucket) {
-  const day = asDay(value);
-  if (!day) return null;
-  const y = day.getUTCFullYear();
-  const m = day.getUTCMonth() + 1;
-  switch (bucket) {
+function bucketOf(value, bucket2) {
+  const day2 = asDay(value);
+  if (!day2) return null;
+  const y = day2.getUTCFullYear();
+  const m = day2.getUTCMonth() + 1;
+  switch (bucket2) {
     case "day":
-      return `${y}-${pad(m)}-${pad(day.getUTCDate())}`;
+      return `${y}-${pad(m)}-${pad(day2.getUTCDate())}`;
     case "week": {
-      const [wy, w] = isoWeek(day);
+      const [wy, w] = isoWeek(day2);
       return `${wy}-W${pad(w)}`;
     }
     case "quarter":
@@ -8519,12 +8519,12 @@ function bucketOf(value, bucket) {
       return `${y}-${pad(m)}`;
   }
 }
-function bucketStart(key, bucket) {
+function bucketStart(key, bucket2) {
   const parts = key.match(/^(\d{4})(?:-(W|Q)?(\d{1,2}))?(?:-(\d{2}))?$/);
   if (!parts) return null;
   const year = Number(parts[1]);
   const n = Number(parts[3] ?? 1);
-  switch (bucket) {
+  switch (bucket2) {
     case "day":
       return asDay(key);
     case "week": {
@@ -8541,32 +8541,32 @@ function bucketStart(key, bucket) {
       return new Date(Date.UTC(year, n - 1, 1));
   }
 }
-function nextBucket(day, bucket) {
-  const d = new Date(day);
-  if (bucket === "day") d.setUTCDate(d.getUTCDate() + 1);
-  else if (bucket === "week") d.setUTCDate(d.getUTCDate() + 7);
-  else if (bucket === "month") d.setUTCMonth(d.getUTCMonth() + 1);
-  else if (bucket === "quarter") d.setUTCMonth(d.getUTCMonth() + 3);
+function nextBucket(day2, bucket2) {
+  const d = new Date(day2);
+  if (bucket2 === "day") d.setUTCDate(d.getUTCDate() + 1);
+  else if (bucket2 === "week") d.setUTCDate(d.getUTCDate() + 7);
+  else if (bucket2 === "month") d.setUTCMonth(d.getUTCMonth() + 1);
+  else if (bucket2 === "quarter") d.setUTCMonth(d.getUTCMonth() + 3);
   else d.setUTCFullYear(d.getUTCFullYear() + 1);
   return d;
 }
-function bucketRange(first, last, bucket, max = 500) {
-  const start = bucketStart(first, bucket);
-  const end = bucketStart(last, bucket);
+function bucketRange(first, last, bucket2, max = 500) {
+  const start = bucketStart(first, bucket2);
+  const end = bucketStart(last, bucket2);
   if (!start || !end || start > end) return null;
   const keys = [];
-  for (let d = start; d <= end && keys.length <= max; d = nextBucket(d, bucket)) {
-    keys.push(bucketOf(d.toISOString(), bucket));
+  for (let d = start; d <= end && keys.length <= max; d = nextBucket(d, bucket2)) {
+    keys.push(bucketOf(d.toISOString(), bucket2));
   }
   return keys.length > max ? null : keys;
 }
 var isEmpty = (value) => value === null || value === void 0 || value === "" || Array.isArray(value) && !value.length;
-function groupKeys(value, field, bucket) {
+function groupKeys(value, field, bucket2) {
   if (isEmpty(value)) return [""];
   if (Array.isArray(value)) {
-    return [...new Set(value.map((v) => groupKeys(v, field, bucket)[0]))];
+    return [...new Set(value.map((v) => groupKeys(v, field, bucket2)[0]))];
   }
-  if (field.type === "date") return [bucketOf(value, bucket) ?? ""];
+  if (field.type === "date") return [bucketOf(value, bucket2) ?? ""];
   if (typeof value === "boolean") return [value ? "Yes" : "No"];
   return [String(value)];
 }
@@ -8661,7 +8661,7 @@ function aggregateDataset(dataset, query) {
   const split = query.splitBy ? byId.get(query.splitBy) : void 0;
   const op = query.measure?.op ?? "count";
   const valueField = query.measure?.field ? byId.get(query.measure.field) : void 0;
-  const bucket = query.bucket ?? "month";
+  const bucket2 = query.bucket ?? "month";
   const fields = aggregateFields(dataset.fields, query);
   if (op !== "count" && valueField?.type !== "number") {
     throw new Error(`${op} needs a number field`);
@@ -8669,8 +8669,8 @@ function aggregateDataset(dataset, query) {
   const rows = filterRows(dataset.rows, dataset.fields, query.filters);
   const cells = /* @__PURE__ */ new Map();
   for (const row of rows) {
-    const groups = group ? groupKeys(row[group.id], group, bucket) : ["All"];
-    const splits = split ? groupKeys(row[split.id], split, bucket) : [""];
+    const groups = group ? groupKeys(row[group.id], group, bucket2) : ["All"];
+    const splits = split ? groupKeys(row[split.id], split, bucket2) : [""];
     const value = valueField ? row[valueField.id] ?? null : 1;
     for (const g of groups) {
       const bySplit = cells.get(g) ?? /* @__PURE__ */ new Map();
@@ -8716,12 +8716,12 @@ function aggregateDataset(dataset, query) {
   }
   return { fields, rows: out, totalRows: rows.length, truncated: keys.length > limit };
 }
-function fillTimeGaps(dataset, bucket) {
+function fillTimeGaps(dataset, bucket2) {
   const keyId = AGGREGATE_FIELDS.key;
   const keys = [...new Set(dataset.rows.map((r) => String(r[keyId] ?? "")))].filter(Boolean);
   if (keys.length < 2) return dataset;
   const sorted = [...keys].sort();
-  const range = bucketRange(sorted[0], sorted[sorted.length - 1], bucket);
+  const range = bucketRange(sorted[0], sorted[sorted.length - 1], bucket2);
   if (!range || range.length === keys.length) return dataset;
   const hasSeries = dataset.fields.some((f) => f.id === AGGREGATE_FIELDS.series);
   const seriesLabels = hasSeries ? [...new Set(dataset.rows.map((r) => String(r[AGGREGATE_FIELDS.series])))] : [null];
@@ -9263,8 +9263,8 @@ var DEFAULT_USAGE_SOURCE_LABELS = {
 var monthsBackOf = (params) => String(params.period ?? "0") === "1" ? 1 : 0;
 function usageRows(usage, project, modelLabel = (g) => MODEL_GROUP_LABELS[g] ?? g) {
   return (usage.daily ?? []).flatMap(
-    (day) => Object.entries(day.model_groups ?? {}).map(([group, mg]) => ({
-      day: day.date,
+    (day2) => Object.entries(day2.model_groups ?? {}).map(([group, mg]) => ({
+      day: day2.date,
       project,
       model: modelLabel(group),
       spend: mg.spend ?? 0,
@@ -9528,18 +9528,18 @@ function useDashboardStore() {
   const { dashboards } = chunkVGMMK5OM_cjs.useArbiHost();
   return (dashboards?.useStore ?? useDatabaseDashboardStore)();
 }
-function useSavedDashboards(store) {
+function useSavedDashboards(store3) {
   return reactQuery.useQuery({
-    queryKey: chunkU4PWVSCT_cjs.arbiQueryKeys.dashboards(store.scope ?? ""),
-    queryFn: () => store.list(),
-    enabled: store.scope !== null
+    queryKey: chunkU4PWVSCT_cjs.arbiQueryKeys.dashboards(store3.scope ?? ""),
+    queryFn: () => store3.list(),
+    enabled: store3.scope !== null
   });
 }
-function useSaveDashboard(store) {
+function useSaveDashboard(store3) {
   const queryClient = reactQuery.useQueryClient();
-  const key = chunkU4PWVSCT_cjs.arbiQueryKeys.dashboards(store.scope ?? "");
+  const key = chunkU4PWVSCT_cjs.arbiQueryKeys.dashboards(store3.scope ?? "");
   return reactQuery.useMutation({
-    mutationFn: (dashboard) => store.save(dashboard),
+    mutationFn: (dashboard) => store3.save(dashboard),
     onSuccess: (saved) => {
       queryClient.setQueryData(
         key,
@@ -9549,11 +9549,11 @@ function useSaveDashboard(store) {
     }
   });
 }
-function useDeleteDashboard(store) {
+function useDeleteDashboard(store3) {
   const queryClient = reactQuery.useQueryClient();
-  const key = chunkU4PWVSCT_cjs.arbiQueryKeys.dashboards(store.scope ?? "");
+  const key = chunkU4PWVSCT_cjs.arbiQueryKeys.dashboards(store3.scope ?? "");
   return reactQuery.useMutation({
-    mutationFn: (id) => store.remove(id),
+    mutationFn: (id) => store3.remove(id),
     onSuccess: (_void, id) => {
       queryClient.setQueryData(key, (old = []) => old.filter((d) => d.id !== id));
       void queryClient.invalidateQueries({ queryKey: chunkU4PWVSCT_cjs.arbiQueryKeys.databaseRows() });
@@ -9656,8 +9656,8 @@ function isClientError(error) {
   }
   return false;
 }
-function retryDelay(attempt) {
-  return Math.min(1e3 * 2 ** attempt, 3e4) + Math.random() * 500;
+function retryDelay(attempt2) {
+  return Math.min(1e3 * 2 ** attempt2, 3e4) + Math.random() * 500;
 }
 function shouldRetryQuery(failureCount, error) {
   return failureCount < 2 && !isClientError(error) && !client.isAbortError(error);
@@ -9698,6 +9698,14 @@ function createArbiQueryClient({
   });
   return { queryClient, persistOptions: persist ? createArbiQueryPersistOptions() : null };
 }
+
+// src/offline-store/network.ts
+function isNetworkFailure(error) {
+  return error instanceof TypeError && /fetch|network|load failed|internet/i.test(error.message);
+}
+function isBrowserOffline() {
+  return typeof navigator !== "undefined" && navigator.onLine === false;
+}
 function useFilteredProjects(filters, options) {
   const arbi = chunkVGMMK5OM_cjs.useArbi();
   return reactQuery.useQuery({
@@ -10915,7 +10923,7 @@ function useIdentityVerificationFlow(api, {
   React.useEffect(() => {
     if (status && lastVerified.current === void 0) lastVerified.current = status.verified;
   }, [status]);
-  const run = React.useCallback(
+  const run2 = React.useCallback(
     async (kind, fallback, fn) => {
       setBusy(kind);
       setProblem(null);
@@ -10936,7 +10944,7 @@ function useIdentityVerificationFlow(api, {
   const startVerifyRef = React.useRef(async () => {
   });
   const refresh = React.useCallback(async () => {
-    const next = await run(
+    const next = await run2(
       "refresh",
       "Could not read the verification result",
       () => apiRef.current.refresh()
@@ -10948,7 +10956,7 @@ function useIdentityVerificationFlow(api, {
     const nextStep = next.state === "declined" ? "result" : identityStepFor(next);
     if (nextStep === "verify" && isOpenRef.current) void startVerifyRef.current();
     else setStep(nextStep);
-  }, [run, apply]);
+  }, [run2, apply]);
   const refreshedOnLoad = React.useRef(false);
   React.useEffect(() => {
     if (refreshedOnLoad.current || !status) return;
@@ -10958,7 +10966,7 @@ function useIdentityVerificationFlow(api, {
   const startVerify = React.useCallback(async () => {
     setStep("verify");
     setEmbedFailed(false);
-    const url = await run(
+    const url = await run2(
       "start",
       "Could not start identity verification",
       () => apiRef.current.startSession()
@@ -10968,7 +10976,7 @@ function useIdentityVerificationFlow(api, {
       return;
     }
     setStep("pay");
-  }, [run]);
+  }, [run2]);
   startVerifyRef.current = startVerify;
   React.useEffect(() => {
     if (!isOpen || step !== "verify" || !sessionUrl || !container || embedFailed) return;
@@ -11023,7 +11031,7 @@ function useIdentityVerificationFlow(api, {
   }, []);
   closeRef.current = close;
   const pay = React.useCallback(async () => {
-    const result = await run(
+    const result = await run2(
       "pay",
       "Payment could not be completed",
       () => apiRef.current.purchase()
@@ -11036,10 +11044,10 @@ function useIdentityVerificationFlow(api, {
     setPaymentUrl(null);
     void query.refetch();
     void startVerify();
-  }, [run, query, startVerify]);
+  }, [run2, query, startVerify]);
   const acceptName = React.useCallback(async () => {
     const offered = status;
-    const next = await run(
+    const next = await run2(
       "accept",
       "Could not change your name",
       () => apiRef.current.acceptName()
@@ -11052,15 +11060,15 @@ function useIdentityVerificationFlow(api, {
         familyName: offered.document_family_name ?? null
       });
     }
-  }, [run, apply, status, onNameAccepted]);
+  }, [run2, apply, status, onNameAccepted]);
   const remove = React.useCallback(async () => {
-    const next = await run(
+    const next = await run2(
       "remove",
       "Could not remove the verification",
       () => apiRef.current.remove()
     );
     if (next) apply(next);
-  }, [run, apply]);
+  }, [run2, apply]);
   const price = React.useMemo(() => status ? formatPrice(status) : null, [status, formatPrice]);
   return {
     status,
@@ -11115,6 +11123,1221 @@ async function downloadRecoveryFile(params) {
   });
   chunkTAVS54EN_cjs.downloadBlob(new Blob([file.html], { type: "text/html" }), file.filename);
 }
+async function documentMailAttachment(arbi, doc, maxBytes, version) {
+  const older = version && version !== (doc.current_version ?? 1) ? version : null;
+  if (!reactQuery.onlineManager.isOnline() && !older) return offlineDocumentAttachment(doc, maxBytes);
+  const failed = (cause) => new Error(`Could not download ${chunkPXWKJI4K_cjs.getDocumentTitle(doc, "the document")}`, { cause });
+  const response = await arbi.documents.download(doc.external_id, older ?? void 0).catch((error) => {
+    throw failed(error);
+  });
+  if (!response.ok) throw failed();
+  const blob = await response.blob();
+  if (blob.size > maxBytes) throw new Error("Document exceeds the email attachment limit");
+  const fileName = older ? doc.versions?.find((v) => v.n === older)?.file_name ?? doc.file_name : doc.file_name;
+  return fileAttachment(
+    new File([blob], fileName || chunkPXWKJI4K_cjs.getDocumentTitle(doc, "document"), { type: blob.type })
+  );
+}
+async function offlineDocumentAttachment(doc, maxBytes) {
+  const title = chunkPXWKJI4K_cjs.getDocumentTitle(doc, "This document");
+  const record = await getOfflineDocument(doc.external_id);
+  const isPdf = /\.pdf$/i.test(doc.file_name ?? "");
+  if (!record || record.kind === "pdf" && !isPdf)
+    throw new Error(
+      `${title} isn't available offline. Make it available offline first, or attach it when you're back online.`
+    );
+  const blob = await loadOfflineDocument(doc.external_id);
+  if (!blob) throw new Error(`${title} isn't available offline.`);
+  if (blob.size > maxBytes) throw new Error("Document exceeds the email attachment limit");
+  return fileAttachment(
+    new File([blob], doc.file_name || chunkPXWKJI4K_cjs.getDocumentTitle(doc, "document"), { type: blob.type })
+  );
+}
+var OfflineMailLockedError = class extends Error {
+  constructor() {
+    super("Sign in to open the mail saved on this device");
+    this.name = "OfflineMailLockedError";
+  }
+};
+var sealer = client.createOfflineSealer("arbi-offline-mail-v1", {
+  locked: () => new OfflineMailLockedError()
+});
+var forgetOfflineMailKeys = sealer.forget;
+var sealBytes = sealer.sealBytes;
+var openBytes = sealer.openBytes;
+var sealJson = sealer.sealJson;
+var openJson = sealer.openJson;
+var blind = sealer.blind;
+
+// src/offline-store/store.ts
+var DB_VERSION2 = 1;
+var RECORDS = "records";
+var META = "meta";
+function promisify2(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+function createRecordStore(dbName) {
+  let dbPromise = null;
+  function openDB2() {
+    if (dbPromise) return dbPromise;
+    dbPromise = new Promise((resolve, reject) => {
+      const request = indexedDB.open(dbName, DB_VERSION2);
+      request.onerror = () => {
+        dbPromise = null;
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        const db = request.result;
+        db.onversionchange = () => {
+          db.close();
+          dbPromise = null;
+        };
+        resolve(db);
+      };
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(RECORDS)) {
+          const records = db.createObjectStore(RECORDS, { keyPath: "key" });
+          records.createIndex("bucket", "bucket");
+          records.createIndex("kind", "kind");
+        }
+        if (!db.objectStoreNames.contains(META)) db.createObjectStore(META, { keyPath: "key" });
+      };
+    });
+    return dbPromise;
+  }
+  async function run2(store3, mode, fn) {
+    const db = await openDB2();
+    return promisify2(fn(db.transaction(store3, mode).objectStore(store3)));
+  }
+  async function scan(pick) {
+    const db = await openDB2();
+    const store3 = db.transaction(RECORDS, "readonly").objectStore(RECORDS);
+    return new Promise((resolve, reject) => {
+      const out = [];
+      const cursor = store3.openCursor();
+      cursor.onerror = () => reject(cursor.error);
+      cursor.onsuccess = () => {
+        const c = cursor.result;
+        if (!c) return resolve(out);
+        out.push(pick(c.value));
+        c.continue();
+      };
+    });
+  }
+  const self = {
+    dbName,
+    async putRecord(record) {
+      await run2(RECORDS, "readwrite", (s) => s.put(record));
+    },
+    async getRecord(key) {
+      return await run2(RECORDS, "readonly", (s) => s.get(key));
+    },
+    async hasRecord(key) {
+      return await run2(RECORDS, "readonly", (s) => s.count(key)) > 0;
+    },
+    async deleteRecords(keys) {
+      if (keys.length === 0) return;
+      const db = await openDB2();
+      const tx = db.transaction(RECORDS, "readwrite");
+      const store3 = tx.objectStore(RECORDS);
+      for (const key of keys) store3.delete(key);
+      await new Promise((resolve, reject) => {
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+        tx.onabort = () => reject(tx.error);
+      });
+    },
+    async recordsInBucket(bucket2) {
+      return await run2(
+        RECORDS,
+        "readonly",
+        (s) => s.index("bucket").getAll(bucket2)
+      );
+    },
+    async recordsOfKind(kind) {
+      return await run2(
+        RECORDS,
+        "readonly",
+        (s) => s.index("kind").getAll(kind)
+      );
+    },
+    allRecordSizes() {
+      return scan(({ key, kind, size }) => ({ key, kind, size }));
+    },
+    allRecordAccess() {
+      return scan(({ key, kind, lastAccess }) => ({ key, kind, lastAccess }));
+    },
+    async touchRecord(key) {
+      const record = await self.getRecord(key);
+      if (record) await self.putRecord({ ...record, lastAccess: Date.now() });
+    },
+    async getMeta(key) {
+      const row = await run2(META, "readonly", (s) => s.get(key));
+      return row?.value;
+    },
+    async setMeta(key, value) {
+      await run2(META, "readwrite", (s) => s.put({ key, value }));
+    },
+    async deleteDatabase() {
+      const db = await dbPromise?.catch(() => null);
+      db?.close();
+      dbPromise = null;
+      await new Promise((resolve, reject) => {
+        const request = indexedDB.deleteDatabase(dbName);
+        request.onsuccess = () => resolve();
+        request.onerror = () => reject(request.error);
+        request.onblocked = () => {
+        };
+      });
+    }
+  };
+  return self;
+}
+
+// src/mail/offline/store.ts
+var OFFLINE_MAIL_DB = "arbi-offline-mail";
+var store = createRecordStore(OFFLINE_MAIL_DB);
+var putRecord = store.putRecord;
+var getRecord = store.getRecord;
+var hasRecord = store.hasRecord;
+var deleteRecords = store.deleteRecords;
+var recordsInBucket = store.recordsInBucket;
+var recordsOfKind = store.recordsOfKind;
+var allRecordSizes = store.allRecordSizes;
+var touchRecord = store.touchRecord;
+var getMeta = store.getMeta;
+var setMeta = store.setMeta;
+var deleteOfflineMailDatabase = store.deleteDatabase;
+
+// src/mail/offline/mailbox.ts
+var keyOf = {
+  accounts: () => blind("accounts"),
+  policy: () => blind("policy"),
+  folders: (accountId) => blind("folders", accountId),
+  header: (accountId, folderId, messageId) => blind("header", accountId, folderId, messageId),
+  body: (accountId, messageId) => blind("body", accountId, messageId),
+  attachment: (accountId, messageId, attachmentId) => blind("attachment", accountId, messageId, attachmentId)
+};
+var bucketOf2 = {
+  global: () => blind("bucket", "global"),
+  folder: (accountId, folderId) => blind("bucket", "folder", accountId, folderId),
+  account: (accountId) => blind("bucket", "account", accountId)
+};
+async function put(kind, key, bucket2, data, sortAt = Date.now()) {
+  const now = Date.now();
+  await putRecord({ key, kind, bucket: bucket2, sortAt, size: data.byteLength, lastAccess: now, data });
+}
+async function readJson(record) {
+  if (!record) return void 0;
+  try {
+    return await openJson(record.data);
+  } catch {
+    return void 0;
+  }
+}
+var receivedAt = (m) => m.received_at ? Date.parse(m.received_at) || 0 : 0;
+async function saveAccounts(accounts) {
+  await put("accounts", await keyOf.accounts(), await bucketOf2.global(), await sealJson(accounts));
+}
+async function loadAccounts() {
+  return readJson(await getRecord(await keyOf.accounts()));
+}
+async function savePolicy(policy) {
+  await put("policy", await keyOf.policy(), await bucketOf2.global(), await sealJson(policy));
+}
+async function loadPolicy() {
+  return readJson(await getRecord(await keyOf.policy()));
+}
+async function saveFolders(accountId, folders) {
+  await put(
+    "folders",
+    await keyOf.folders(accountId),
+    await bucketOf2.account(accountId),
+    await sealJson(folders)
+  );
+}
+async function loadFolders(accountId) {
+  return readJson(await getRecord(await keyOf.folders(accountId)));
+}
+function toHeader(message) {
+  return {
+    ...message,
+    text: "",
+    html: void 0,
+    delivery: void 0,
+    attachments: message.attachments.map((a) => ({ ...a, content_base64: null }))
+  };
+}
+async function saveHeader(accountId, folderId, message) {
+  await put(
+    "header",
+    await keyOf.header(accountId, folderId, message.id),
+    await bucketOf2.folder(accountId, folderId),
+    await sealJson(toHeader(message)),
+    receivedAt(message)
+  );
+}
+async function loadHeaders(accountId, folderId) {
+  const records = await recordsInBucket(await bucketOf2.folder(accountId, folderId));
+  const out = [];
+  for (const record of records) {
+    if (record.kind !== "header") continue;
+    const message = await readJson(record);
+    if (message) out.push({ key: record.key, sortAt: record.sortAt, message });
+  }
+  return out.sort((a, b) => b.sortAt - a.sortAt);
+}
+async function hasFolder(accountId) {
+  return hasRecord(await keyOf.folders(accountId));
+}
+async function saveBody(accountId, message) {
+  const stripped = {
+    ...message,
+    attachments: message.attachments.map((a) => ({ ...a, content_base64: null }))
+  };
+  await put(
+    "body",
+    await keyOf.body(accountId, message.id),
+    await bucketOf2.account(accountId),
+    await sealJson(stripped),
+    receivedAt(message)
+  );
+}
+async function hasBody(accountId, messageId) {
+  return hasRecord(await keyOf.body(accountId, messageId));
+}
+async function loadBody(accountId, messageId) {
+  return readJson(await getRecord(await keyOf.body(accountId, messageId)));
+}
+async function saveAttachment(accountId, messageId, attachmentId, bytes) {
+  await put(
+    "attachment",
+    await keyOf.attachment(accountId, messageId, attachmentId),
+    await bucketOf2.account(accountId),
+    await sealBytes(bytes)
+  );
+}
+async function hasAttachment(accountId, messageId, attachmentId) {
+  return hasRecord(await keyOf.attachment(accountId, messageId, attachmentId));
+}
+async function loadAttachment(accountId, messageId, attachmentId) {
+  const key = await keyOf.attachment(accountId, messageId, attachmentId);
+  const record = await getRecord(key);
+  if (!record) return void 0;
+  try {
+    const bytes = await openBytes(record.data);
+    void touchRecord(key);
+    return bytes;
+  } catch {
+    return void 0;
+  }
+}
+async function removeKeys(keys) {
+  await deleteRecords(keys);
+}
+function bodyText(body) {
+  const html = body.text ? "" : (body.html ?? "").replace(/<[^>]*>/g, " ");
+  return `${body.text} ${html} ${body.attachments.map((a) => a.name).join(" ")}`;
+}
+var folded = (value) => value.toLocaleLowerCase().normalize("NFKD");
+async function searchFolder(accountId, folderId, query) {
+  const words = folded(query).split(/\s+/).filter(Boolean);
+  const headers = await loadHeaders(accountId, folderId);
+  if (words.length === 0) return headers.map((h) => h.message);
+  const out = [];
+  for (const { message } of headers) {
+    const people = [...message.sender, ...message.to, ...message.cc].map((p) => `${p.name ?? ""} ${p.email}`).join(" ");
+    let haystack = folded(`${message.subject} ${people} ${message.preview}`);
+    if (!words.every((w) => haystack.includes(w))) {
+      const body = await loadBody(accountId, message.id);
+      if (body) haystack += " " + folded(bodyText(body));
+    }
+    if (words.every((w) => haystack.includes(w))) out.push(message);
+  }
+  return out;
+}
+
+// src/mail/offline/settings.ts
+var DEFAULT_OFFLINE_MAIL_SETTINGS = {
+  enabled: false,
+  scope: "90d",
+  attachmentCapMb: 25,
+  quotaMb: 1024
+};
+var SCOPE_DAYS = {
+  "30d": 30,
+  "90d": 90,
+  "365d": 365,
+  all: null
+};
+var STORAGE_PREFIX = "arbi-offline-mail-settings:";
+function getOfflineMailSettings(userExtId) {
+  if (!userExtId) return DEFAULT_OFFLINE_MAIL_SETTINGS;
+  const key = STORAGE_PREFIX + userExtId;
+  try {
+    const raw = localStorage.getItem(key);
+    return raw ? { ...DEFAULT_OFFLINE_MAIL_SETTINGS, ...JSON.parse(raw) } : DEFAULT_OFFLINE_MAIL_SETTINGS;
+  } catch {
+    return DEFAULT_OFFLINE_MAIL_SETTINGS;
+  }
+}
+function setOfflineMailSettings(userExtId, patch) {
+  const next = { ...getOfflineMailSettings(userExtId), ...patch };
+  if (userExtId) {
+    try {
+      localStorage.setItem(STORAGE_PREFIX + userExtId, JSON.stringify(next));
+    } catch {
+    }
+  }
+  notifyOfflineMailChange("settings");
+  return next;
+}
+var listeners = /* @__PURE__ */ new Set();
+var CHANNEL = "arbi-offline-mail";
+var channel = null;
+function getChannel() {
+  if (channel || typeof BroadcastChannel === "undefined") return channel;
+  channel = new BroadcastChannel(CHANNEL);
+  channel.onmessage = (event) => {
+    for (const listener of listeners) listener(event.data);
+  };
+  return channel;
+}
+function notifyOfflineMailChange(change) {
+  for (const listener of listeners) listener(change);
+  try {
+    getChannel()?.postMessage(change);
+  } catch {
+  }
+}
+function onOfflineMailChange(listener) {
+  getChannel();
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+// src/mail/offline/drafts.ts
+var keyFor = (id) => blind("draft", id);
+async function saveLocalDraft(accountId, compose, id = crypto.randomUUID()) {
+  const draft = { id, accountId, compose, updatedAt: Date.now() };
+  await putRecord({
+    key: await keyFor(id),
+    kind: "draft",
+    bucket: await blind("bucket", "drafts", accountId),
+    sortAt: draft.updatedAt,
+    size: 0,
+    lastAccess: draft.updatedAt,
+    data: await sealJson(draft)
+  });
+  notifyOfflineMailChange("drafts");
+  return draft;
+}
+async function listLocalDrafts(accountId) {
+  const drafts = [];
+  for (const record of await recordsOfKind("draft")) {
+    try {
+      const draft = await openJson(record.data);
+      if (!accountId || draft.accountId === accountId) drafts.push(draft);
+    } catch {
+    }
+  }
+  return drafts.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+async function deleteLocalDraft(id) {
+  await deleteRecords([await keyFor(id)]);
+  notifyOfflineMailChange("drafts");
+}
+async function syncLocalDrafts(save) {
+  let uploaded = 0;
+  for (const draft of await listLocalDrafts()) {
+    if (draft.error) continue;
+    try {
+      await save(draft);
+      await deleteLocalDraft(draft.id);
+      uploaded++;
+    } catch (error) {
+      const status = error.status;
+      if (isNetworkFailure(error) || status === void 0 || status === 401 || status >= 500) break;
+      await putRecord({
+        key: await keyFor(draft.id),
+        kind: "draft",
+        bucket: await blind("bucket", "drafts", draft.accountId),
+        sortAt: draft.updatedAt,
+        size: 0,
+        lastAccess: Date.now(),
+        data: await sealJson({
+          ...draft,
+          error: error instanceof Error ? error.message : "The server refused this draft"
+        })
+      });
+      notifyOfflineMailChange("drafts");
+    }
+  }
+  return uploaded;
+}
+
+// src/mail/offline/outbox.ts
+var bucket = () => blind("bucket", "outbox");
+var keyFor2 = (id) => blind("outbox", id);
+function outboxProblem(compose) {
+  const missing = compose.attachments.find((a) => a.content_base64 == null);
+  if (missing)
+    return `${missing.name} isn't saved on this device, so it can't be sent offline. Remove it or send once you're back online.`;
+  return null;
+}
+var seqCounter = 0;
+async function write(item) {
+  await putRecord({
+    key: await keyFor2(item.id),
+    kind: "outbox",
+    bucket: await bucket(),
+    sortAt: item.seq,
+    size: 0,
+    lastAccess: Date.now(),
+    data: await sealJson(item)
+  });
+}
+async function listOutbox() {
+  const records = await recordsInBucket(await bucket());
+  const items = [];
+  for (const record of records) {
+    try {
+      items.push(await openJson(record.data));
+    } catch {
+    }
+  }
+  return items.sort((a, b) => a.seq - b.seq);
+}
+async function enqueueOutbox(input) {
+  const problem = outboxProblem(input.compose);
+  if (problem) throw new Error(problem);
+  const now = Date.now();
+  seqCounter = Math.max(seqCounter + 1, now * 1e3);
+  const item = {
+    id: crypto.randomUUID(),
+    requestId: input.requestId,
+    account: input.account,
+    compose: input.compose,
+    secure: input.secure,
+    securePayload: input.securePayload,
+    status: "queued",
+    attempts: 0,
+    createdAt: now,
+    seq: seqCounter
+  };
+  await write(item);
+  notifyOfflineMailChange("outbox");
+  return item;
+}
+async function update(item, patch) {
+  const next = { ...item, ...patch };
+  await write(next);
+  notifyOfflineMailChange("outbox");
+  return next;
+}
+async function deleteOutboxItem(id) {
+  await deleteRecords([await keyFor2(id)]);
+  notifyOfflineMailChange("outbox");
+}
+async function retryOutboxItem(id) {
+  const item = (await listOutbox()).find((i) => i.id === id);
+  if (item && item.status === "failed")
+    await update(item, { status: "queued", error: void 0, inDoubt: item.inDoubt });
+}
+var IN_DOUBT_MESSAGE = "The mail server didn't confirm this message. It may already have been sent: check Sent before sending it again.";
+function classify(error) {
+  if (isNetworkFailure(error)) return { kind: "offline" };
+  const status = error?.status;
+  const detail = error instanceof Error ? error.message : "The message could not be sent";
+  if (status === void 0) return { kind: "failed", error: detail, inDoubt: false };
+  if (status === 409) return { kind: "failed", error: IN_DOUBT_MESSAGE, inDoubt: true };
+  if (status >= 500) return { kind: "failed", error: IN_DOUBT_MESSAGE, inDoubt: true };
+  return { kind: "failed", error: detail, inDoubt: false };
+}
+async function prepared(item, sender) {
+  if (!item.secure || item.securePayload !== void 0) return item;
+  return update(item, { securePayload: await sender.prepareSecure(item) });
+}
+async function attempt(item, sender) {
+  try {
+    const result = await sender.send(item);
+    return { kind: "sent", serverId: result?.id };
+  } catch (error) {
+    const outcome = classify(error);
+    if (error.status === 401) {
+      try {
+        await sender.unlock(item.account);
+        const result = await sender.send(item);
+        return { kind: "sent", serverId: result?.id };
+      } catch (retryError) {
+        return classify(retryError);
+      }
+    }
+    return outcome;
+  }
+}
+async function flushOutboxOnce(sender, isOnline) {
+  const result = { sent: 0, failed: 0, interrupted: false };
+  const unlocked2 = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    if (!isOnline()) {
+      result.interrupted = true;
+      break;
+    }
+    const next = (await listOutbox()).find((i) => i.status === "queued" || i.status === "sending");
+    if (!next) break;
+    let item = await update(next, { status: "sending", attempts: next.attempts + 1 });
+    try {
+      item = await prepared(item, sender);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Could not encrypt the message";
+      await update(item, { status: "failed", error: message });
+      result.failed++;
+      continue;
+    }
+    if (!unlocked2.has(item.account.id)) {
+      await sender.unlock(item.account).catch(() => {
+      });
+      unlocked2.add(item.account.id);
+    }
+    const outcome = await attempt(item, sender);
+    if (outcome.kind === "sent") {
+      item = await update(item, {
+        status: "sent",
+        sentAt: Date.now(),
+        error: void 0,
+        inDoubt: false
+      });
+      result.sent++;
+    } else if (outcome.kind === "offline") {
+      await update(item, { status: "queued" });
+      result.interrupted = true;
+      break;
+    } else {
+      await update(item, {
+        status: "failed",
+        error: outcome.error,
+        inDoubt: item.inDoubt || outcome.inDoubt
+      });
+      result.failed++;
+    }
+  }
+  return result;
+}
+async function purgeSentOutbox(olderThanMs = 0) {
+  const cutoff = Date.now() - olderThanMs;
+  const done = (await listOutbox()).filter((i) => i.status === "sent" && (i.sentAt ?? 0) <= cutoff);
+  if (done.length === 0) return;
+  await deleteRecords(await Promise.all(done.map((i) => keyFor2(i.id))));
+  notifyOfflineMailChange("outbox");
+}
+var STATUS_KEY = "status";
+var FULL_SYNC_EVERY_MS = 60 * 60 * 1e3;
+var MAX_PAGES = 200;
+async function getOfflineMailStatus() {
+  return await getMeta(STATUS_KEY) ?? { messages: 0, bytes: 0, skipped: [] };
+}
+var MB = 1024 * 1024;
+var time = (m) => m.received_at ? Date.parse(m.received_at) || 0 : 0;
+var sameHeader = (a, b) => JSON.stringify(toHeader(a)) === JSON.stringify(toHeader(b));
+var Budget = class {
+  constructor(used, quota) {
+    this.used = used;
+    this.quota = quota;
+  }
+  used;
+  quota;
+  get full() {
+    return this.used >= this.quota;
+  }
+  take(bytes) {
+    this.used += bytes;
+  }
+};
+async function saveMessageContent(transport, account, header, settings, budget) {
+  const message = await transport.message(account, header.id);
+  await saveBody(account.id, message);
+  budget.take((message.text?.length ?? 0) + (message.html?.length ?? 0));
+  let attachmentBytes = 0;
+  for (const attachment of message.attachments) {
+    if (budget.full) return;
+    if (attachmentBytes + attachment.size > settings.attachmentCapMb * MB) continue;
+    if (await hasAttachment(account.id, message.id, attachment.id)) continue;
+    const bytes = attachment.content_base64 ? Uint8Array.from(atob(attachment.content_base64), (c) => c.charCodeAt(0)) : await transport.attachment(account, message.id, attachment.id);
+    await saveAttachment(account.id, message.id, attachment.id, bytes);
+    attachmentBytes += bytes.byteLength;
+    budget.take(bytes.byteLength);
+  }
+}
+async function syncFolder(transport, account, folder, settings, windowStart, full, budget) {
+  const saved = new Map(
+    (await loadHeaders(account.id, folder.id)).map((h) => [h.message.id, h])
+  );
+  const seen = /* @__PURE__ */ new Set();
+  let oldestSeen = Infinity;
+  let cursor = null;
+  let reachedEnd = false;
+  for (let page = 0; page < MAX_PAGES; page++) {
+    const result = await transport.messages(account, folder.id, cursor);
+    let anythingNew = false;
+    let outOfScope = false;
+    for (const message of result.messages) {
+      const at = time(message);
+      if (at && at < windowStart) {
+        outOfScope = true;
+        break;
+      }
+      seen.add(message.id);
+      if (at) oldestSeen = Math.min(oldestSeen, at);
+      const previous = saved.get(message.id)?.message;
+      if (!previous || !sameHeader(previous, message)) {
+        await saveHeader(account.id, folder.id, message);
+        anythingNew = true;
+      }
+      if (!budget.full && !await hasBody(account.id, message.id)) {
+        try {
+          await saveMessageContent(transport, account, message, settings, budget);
+          anythingNew = true;
+        } catch (error) {
+          client.logger.warn("[offline-mail] could not save a message body", error);
+        }
+      }
+    }
+    cursor = result.next_cursor ?? null;
+    if (outOfScope || !cursor) {
+      reachedEnd = true;
+      break;
+    }
+    if (!full && !anythingNew) break;
+  }
+  const stale = [...saved.values()].filter(
+    (h) => !seen.has(h.message.id) && (reachedEnd || h.sortAt >= oldestSeen)
+  );
+  await removeKeys(stale.map((h) => h.key));
+}
+async function collectGarbage(accounts) {
+  for (const account of accounts) {
+    const folders = await loadFolders(account.id) ?? [];
+    const expected = /* @__PURE__ */ new Set([await keyOf.folders(account.id)]);
+    for (const folder of folders) {
+      for (const { message } of await loadHeaders(account.id, folder.id)) {
+        expected.add(await keyOf.body(account.id, message.id));
+        for (const attachment of message.attachments)
+          expected.add(await keyOf.attachment(account.id, message.id, attachment.id));
+      }
+    }
+    const orphans = (await recordsInBucket(await bucketOf2.account(account.id))).filter((r) => (r.kind === "body" || r.kind === "attachment") && !expected.has(r.key)).map((r) => r.key);
+    await removeKeys(orphans);
+  }
+}
+async function forgetAccount(accountId) {
+  for (const folder of await loadFolders(accountId) ?? []) {
+    const records2 = await recordsInBucket(await bucketOf2.folder(accountId, folder.id));
+    await removeKeys(records2.map((r) => r.key));
+  }
+  const records = await recordsInBucket(await bucketOf2.account(accountId));
+  await removeKeys(records.filter((r) => r.kind !== "draft").map((r) => r.key));
+}
+async function enforceQuota(quotaBytes) {
+  let used = (await allRecordSizes()).reduce((n, r) => n + r.size, 0);
+  if (used <= quotaBytes) return used;
+  for (const kind of ["attachment", "body"]) {
+    const records = (await recordsOfKind(kind)).sort(
+      (a, b) => kind === "attachment" ? a.lastAccess - b.lastAccess : a.sortAt - b.sortAt
+    );
+    const evict = [];
+    for (const record of records) {
+      if (used <= quotaBytes) break;
+      evict.push(record.key);
+      used -= record.size;
+    }
+    await removeKeys(evict);
+    if (used <= quotaBytes) break;
+  }
+  return used;
+}
+async function syncMailbox(transport, settings, options = {}) {
+  const now = options.now ?? Date.now();
+  const previous = await getOfflineMailStatus();
+  const full = options.full || !previous.lastFullSyncAt || now - previous.lastFullSyncAt > FULL_SYNC_EVERY_MS;
+  const days = SCOPE_DAYS[settings.scope];
+  const windowStart = days === null ? 0 : now - days * 24 * 60 * 60 * 1e3;
+  const quota = settings.quotaMb * MB;
+  const skipped = [];
+  let error;
+  try {
+    await savePolicy(await transport.policy());
+    const accounts = await transport.accounts();
+    const before = await loadAccounts() ?? [];
+    await saveAccounts(accounts);
+    for (const gone of before.filter((b) => !accounts.some((a) => a.id === b.id)))
+      await forgetAccount(gone.id);
+    const budget = new Budget(
+      (await allRecordSizes()).reduce((n, r) => n + r.size, 0),
+      quota
+    );
+    for (const account of accounts) {
+      if (account.needs_reconsent) {
+        skipped.push(account.email);
+        continue;
+      }
+      try {
+        await transport.unlock(account);
+        const folders = await transport.folders(account);
+        const oldFolders = await loadFolders(account.id) ?? [];
+        await saveFolders(account.id, folders);
+        for (const gone of oldFolders.filter((o) => !folders.some((f) => f.id === o.id))) {
+          const records = await recordsInBucket(await bucketOf2.folder(account.id, gone.id));
+          await removeKeys(records.map((r) => r.key));
+        }
+        for (const folder of folders)
+          await syncFolder(transport, account, folder, settings, windowStart, full, budget);
+        notifyOfflineMailChange("mailbox");
+      } catch (accountError) {
+        if (accountError.status === void 0) throw accountError;
+        client.logger.warn("[offline-mail] account sync failed", accountError);
+        skipped.push(account.email);
+      }
+    }
+    if (full) await collectGarbage(accounts);
+  } catch (syncError) {
+    error = syncError.status === void 0 ? "The connection dropped during sync. It will continue when you are back online." : syncError instanceof Error ? syncError.message : "Sync failed";
+  }
+  const bytes = await enforceQuota(quota);
+  const messages = (await recordsOfKind("header")).length;
+  const status = {
+    lastSyncedAt: error ? previous.lastSyncedAt : now,
+    lastFullSyncAt: !error && full ? now : previous.lastFullSyncAt,
+    messages,
+    bytes,
+    error,
+    skipped
+  };
+  await setMeta(STATUS_KEY, status);
+  notifyOfflineMailChange("status");
+  return status;
+}
+
+// src/mail/offline/live.ts
+var OUTBOX_FOLDER = "outbox";
+function sessionUser(arbi) {
+  return arbi.session?.getState().user?.external_id ?? null;
+}
+function hasLiveSession(arbi) {
+  return !!arbi.session?.getState().serverSessionKey;
+}
+function canReachMail(arbi) {
+  return reactQuery.onlineManager.isOnline() && hasLiveSession(arbi);
+}
+var unlocked = { nativeUnlocked: true };
+function mailCall(arbi, path, init = {}) {
+  return mailJson((p, i) => arbi.mail.fetch(p, i, unlocked), path, init);
+}
+function liveTransport(arbi) {
+  const unlock = async (account) => {
+    if (!hasLiveSession(arbi))
+      throw Object.assign(new Error("Sign in to unlock your mailbox"), { status: 401 });
+    await arbi.mail.unlockAccount(account);
+  };
+  return {
+    policy: () => mailCall(arbi, "/policy"),
+    accounts: () => mailCall(arbi, "/accounts"),
+    unlock,
+    folders: (account) => mailCall(arbi, `${accountPath(account.id)}/folders`),
+    messages: (account, folderId, cursor) => mailCall(
+      arbi,
+      `${accountPath(account.id)}/messages?${new URLSearchParams({
+        folder_id: folderId,
+        q: "",
+        limit: "100",
+        ...cursor ? { cursor } : {}
+      })}`
+    ),
+    message: async (account, messageId) => {
+      const path = `${accountPath(account.id)}/messages/${encodeURIComponent(messageId)}`;
+      try {
+        return await mailCall(arbi, path);
+      } catch (error) {
+        if (error.status !== 401 || account.provider !== "native")
+          throw error;
+        if (hasLiveSession(arbi)) await arbi.mail.unlockNative();
+        return mailCall(arbi, path);
+      }
+    },
+    attachment: async (account, messageId, attachmentId) => {
+      const response = await arbi.mail.fetch(
+        `${accountPath(account.id)}/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}`,
+        {},
+        unlocked
+      );
+      return new Uint8Array(await response.arrayBuffer());
+    }
+  };
+}
+function liveSender(arbi) {
+  const transport = liveTransport(arbi);
+  return {
+    prepareSecure: async (item) => {
+      if (item.account.provider !== "native")
+        throw new Error("Choose your native inbox to send securely");
+      return arbi.secureMail.prepare(item.compose, item.account, item.requestId);
+    },
+    unlock: async (account) => {
+      if (account.provider !== "native") await transport.unlock(account);
+    },
+    send: (item) => item.secure ? mailJson((p, i) => arbi.mail.fetch(p, i), "/secure/send", {
+      method: "POST",
+      body: JSON.stringify(item.securePayload)
+    }) : mailJson(
+      (p, i) => arbi.mail.fetch(p, i),
+      `${accountPath(item.account.id)}/send`,
+      {
+        method: "POST",
+        body: JSON.stringify({ ...item.compose, request_id: item.requestId })
+      }
+    )
+  };
+}
+var localLocks = /* @__PURE__ */ new Set();
+async function exclusive(name, fn) {
+  if (typeof navigator !== "undefined" && navigator.locks?.request) {
+    return navigator.locks.request(name, { ifAvailable: true }, async (lock) => {
+      if (!lock) return false;
+      await fn();
+      return true;
+    });
+  }
+  if (localLocks.has(name)) return false;
+  localLocks.add(name);
+  try {
+    await fn();
+    return true;
+  } finally {
+    localLocks.delete(name);
+  }
+}
+var retryTimer = null;
+async function flushOutbox(context) {
+  const { arbi, queryClient, openOutbox } = context;
+  if (!canReachMail(arbi)) return;
+  const ran = await exclusive("arbi-mail-outbox", async () => {
+    const result = await flushOutboxOnce(liveSender(arbi), () => reactQuery.onlineManager.isOnline());
+    if (result.sent > 0) void queryClient.invalidateQueries({ queryKey: chunkU4PWVSCT_cjs.mailQueryKeys.all() });
+    const remaining = (await listOutbox()).filter((i) => i.status !== "sent");
+    if (result.failed > 0) {
+      chunkDZUBZ45Y_cjs.notify.error(
+        result.failed === 1 ? "A message in your Outbox couldn't be sent" : `${result.failed} messages in your Outbox couldn't be sent`,
+        {
+          description: "Open the Outbox to see why, then retry, edit or delete it.",
+          ...openOutbox && { action: { label: "Open Outbox", onClick: openOutbox } }
+        }
+      );
+    } else if (result.sent > 0 && remaining.length === 0) {
+      chunkDZUBZ45Y_cjs.notify.success(
+        result.sent === 1 ? "Your Outbox message was sent" : `${result.sent} Outbox messages sent`
+      );
+    }
+    setTimeout(() => void purgeSentOutbox(3e4), 31e3);
+  });
+  if (!ran) {
+    if (retryTimer) clearTimeout(retryTimer);
+    retryTimer = setTimeout(() => void flushOutbox(context), 3e3);
+  }
+}
+async function uploadOfflineDrafts({
+  arbi,
+  queryClient
+}) {
+  if (!canReachMail(arbi)) return;
+  await exclusive("arbi-mail-drafts", async () => {
+    const uploaded = await syncLocalDrafts(
+      ({ accountId, compose }) => mailJson(
+        (p, i) => arbi.mail.fetch(p, i),
+        `${accountPath(accountId)}/drafts`,
+        {
+          method: "POST",
+          body: JSON.stringify(compose)
+        }
+      )
+    );
+    if (uploaded > 0) {
+      void queryClient.invalidateQueries({ queryKey: chunkU4PWVSCT_cjs.mailQueryKeys.allMessages() });
+      chunkDZUBZ45Y_cjs.notify.success(
+        uploaded === 1 ? "Your offline draft was saved to Drafts" : `${uploaded} offline drafts were saved to Drafts`
+      );
+    }
+  });
+}
+var syncing = false;
+function isMailSyncRunning() {
+  return syncing;
+}
+async function syncOfflineMailbox({ arbi }, options = {}) {
+  const settings = getOfflineMailSettings(sessionUser(arbi));
+  if (!settings.enabled || !canReachMail(arbi)) return;
+  await exclusive("arbi-mail-sync", async () => {
+    syncing = true;
+    notifyOfflineMailChange("status");
+    try {
+      await syncMailbox(liveTransport(arbi), settings, options);
+    } catch (error) {
+      client.logger.error("[offline-mail] sync failed", error);
+    } finally {
+      syncing = false;
+      notifyOfflineMailChange("status");
+    }
+  });
+}
+
+// src/mail/offline/reads.ts
+var NOT_SAVED_HINT = 'Turn on "Keep my mailbox available offline" in Mail settings to read mail without a connection.';
+async function onlineFirst(online, offline, unavailable) {
+  if (reactQuery.onlineManager.isOnline()) {
+    try {
+      return await online();
+    } catch (error) {
+      if (!isNetworkFailure(error)) throw error;
+    }
+  }
+  const saved = await offline().catch(() => void 0);
+  if (saved !== void 0) return saved;
+  throw new MailOfflineUnavailableError(unavailable);
+}
+function offlineMailReads(getArbi, { keepsMail = () => true } = {}) {
+  const call = (path) => mailJson((p, i) => getArbi().mail.fetch(p, i), path);
+  const storeEnabled = () => getOfflineMailSettings(sessionUser(getArbi())).enabled;
+  const remember = (write2) => {
+    if (!keepsMail()) return;
+    write2().catch((error) => client.logger.warn("[offline-mail] could not save for offline use", error));
+  };
+  return {
+    getPolicy: () => onlineFirst(
+      async () => {
+        const policy = await call("/policy");
+        remember(() => savePolicy(policy));
+        return policy;
+      },
+      loadPolicy,
+      "You're offline. Mail opens here once you've used it online on this device."
+    ),
+    listAccounts: () => onlineFirst(
+      async () => {
+        const accounts = await call("/accounts");
+        remember(() => saveAccounts(accounts));
+        return accounts;
+      },
+      loadAccounts,
+      "You're offline. Your mail accounts appear here once you've opened Mail online on this device."
+    ),
+    listFolders: (account) => onlineFirst(
+      async () => {
+        const folders = await call(`${accountPath(account.id)}/folders`);
+        if (storeEnabled()) remember(() => saveFolders(account.id, folders));
+        return folders;
+      },
+      () => loadFolders(account.id),
+      `You're offline and this mailbox isn't saved on this device. ${NOT_SAVED_HINT}`
+    ),
+    listMessages: (account, folderId, query, cursor) => onlineFirst(
+      async () => {
+        const page = await call(
+          `${accountPath(account.id)}/messages?${new URLSearchParams({ folder_id: folderId, q: query, ...cursor ? { cursor } : {} })}`
+        );
+        if (storeEnabled() && !query)
+          remember(async () => {
+            for (const message of page.messages) await saveHeader(account.id, folderId, message);
+          });
+        return page;
+      },
+      async () => {
+        if (!await hasFolder(account.id)) return void 0;
+        return { messages: await searchFolder(account.id, folderId, query), fromDevice: true };
+      },
+      `You're offline and this folder isn't saved on this device. ${NOT_SAVED_HINT}`
+    ),
+    getMessage: (account, messageId) => onlineFirst(
+      async () => {
+        const message = await call(
+          `${accountPath(account.id)}/messages/${encodeURIComponent(messageId)}`
+        );
+        if (storeEnabled()) remember(() => saveBody(account.id, message));
+        return message;
+      },
+      () => loadBody(account.id, messageId),
+      storeEnabled() ? "You're offline and this message hasn't been saved on this device yet." : `You're offline. ${NOT_SAVED_HINT}`
+    )
+  };
+}
+
+// src/mail/offline/wipe.ts
+var OWNER_KEY2 = "owner";
+async function wipeOfflineMail() {
+  forgetOfflineMailKeys();
+  await deleteOfflineMailDatabase();
+  notifyOfflineMailChange("wiped");
+}
+async function claimOfflineMail(userExtId) {
+  const owner = await getMeta(OWNER_KEY2);
+  if (owner && owner !== userExtId) await wipeOfflineMail();
+  await setMeta(OWNER_KEY2, userExtId);
+}
+
+// src/mail/offline/runtime.ts
+var SYNC_INTERVAL_MS = 5 * 60 * 1e3;
+var NEW_MAIL_DEBOUNCE_MS = 5e3;
+function useOfflineMailRuntime({ openOutbox } = {}) {
+  const { user, status, serverSessionKey } = chunk2Y2WOIHH_cjs.useArbiSession();
+  const userExtId = user?.external_id;
+  const authenticated = status === "signed-in";
+  const mailEnabled = chunkLUDIYWT7_cjs.useFeature("mail");
+  const entitled = chunkLUDIYWT7_cjs.useIsEntitled("mail");
+  const hasSession = !!serverSessionKey;
+  const active = authenticated && mailEnabled && entitled && !!userExtId;
+  const queryClient = reactQuery.useQueryClient();
+  const arbi = chunkVGMMK5OM_cjs.useArbi();
+  const latest = React.useRef({ arbi, queryClient, openOutbox });
+  latest.current = { arbi, queryClient, openOutbox };
+  React.useEffect(() => {
+    if (!active || !userExtId) return;
+    claimOfflineMail(userExtId).catch(
+      (error) => client.logger.warn("[offline-mail] could not bind the store", error)
+    );
+  }, [active, userExtId]);
+  React.useEffect(() => {
+    if (!active || !hasSession) return;
+    const context = () => latest.current;
+    const catchUp = async () => {
+      await flushOutbox(context());
+      await uploadOfflineDrafts(context());
+      await syncOfflineMailbox(context());
+    };
+    const run2 = () => {
+      catchUp().catch((error) => client.logger.warn("[offline-mail] catch-up failed", error));
+    };
+    run2();
+    let wasOnline = reactQuery.onlineManager.isOnline();
+    const offOnline = reactQuery.onlineManager.subscribe((online) => {
+      if (online && !wasOnline) run2();
+      wasOnline = online;
+    });
+    const interval = setInterval(() => {
+      if (document.visibilityState === "visible") void syncOfflineMailbox(context());
+    }, SYNC_INTERVAL_MS);
+    const enabled = () => getOfflineMailSettings(sessionUser(context().arbi)).enabled;
+    let newMailTimer = null;
+    const offCache = queryClient.getQueryCache().subscribe((event) => {
+      if (event.type !== "updated" || event.action.type !== "invalidate") return;
+      if (!chunkU4PWVSCT_cjs.isUnderQueryKey(event.query.queryKey, chunkU4PWVSCT_cjs.mailQueryKeys.all()) || !enabled()) return;
+      if (newMailTimer) clearTimeout(newMailTimer);
+      newMailTimer = setTimeout(() => void syncOfflineMailbox(context()), NEW_MAIL_DEBOUNCE_MS);
+    });
+    const offSettings = onOfflineMailChange((change) => {
+      if (change === "settings" && enabled()) void syncOfflineMailbox(context(), { full: true });
+      if (change === "outbox") void flushOutbox(context());
+      if (change === "drafts") void uploadOfflineDrafts(context());
+    });
+    return () => {
+      offOnline();
+      clearInterval(interval);
+      if (newMailTimer) clearTimeout(newMailTimer);
+      offCache();
+      offSettings();
+    };
+  }, [active, hasSession, queryClient]);
+}
+function useStoreValue(load, initial, changes) {
+  const [value, setValue] = React.useState(initial);
+  const key = changes.join(",");
+  React.useEffect(() => {
+    let alive = true;
+    const read = () => load().then((next) => alive && setValue(next)).catch((error) => client.logger.warn("[offline-mail] read failed", error));
+    void read();
+    const off = onOfflineMailChange((change) => {
+      if (change === "wiped") setValue(initial);
+      if (change === "wiped" || key.split(",").includes(change)) void read();
+    });
+    return () => {
+      alive = false;
+      off();
+    };
+  }, [key, load, initial]);
+  return value;
+}
+function useOfflineMailSettings() {
+  const userExtId = chunk2Y2WOIHH_cjs.useArbiSession().user?.external_id;
+  const subscribe = React.useCallback(
+    (onChange) => onOfflineMailChange((change) => {
+      if (change === "settings") onChange();
+    }),
+    []
+  );
+  const raw = React.useSyncExternalStore(
+    subscribe,
+    () => JSON.stringify([userExtId, getOfflineMailSettings(userExtId)])
+  );
+  const settings = React.useMemo(() => JSON.parse(raw)[1], [raw]);
+  const update2 = React.useCallback(
+    (patch) => void setOfflineMailSettings(userExtId, patch),
+    [userExtId]
+  );
+  return [settings, update2];
+}
+var EMPTY_STATUS = { messages: 0, bytes: 0, skipped: [] };
+function useOfflineMailStatus() {
+  const status = useStoreValue(getOfflineMailStatus, EMPTY_STATUS, ["status", "mailbox"]);
+  const [syncing2, setSyncing] = React.useState(isMailSyncRunning);
+  React.useEffect(
+    () => onOfflineMailChange((change) => {
+      if (change === "status") setSyncing(isMailSyncRunning());
+    }),
+    []
+  );
+  return { ...status, syncing: syncing2 };
+}
+var NO_ITEMS = [];
+function useOutbox(enabled = true) {
+  const load = React.useCallback(() => enabled ? listOutbox() : Promise.resolve(NO_ITEMS), [enabled]);
+  return useStoreValue(load, NO_ITEMS, ["outbox"]);
+}
+var NO_DRAFTS = [];
+function useLocalDrafts(accountId) {
+  const load = React.useCallback(
+    () => accountId ? listLocalDrafts(accountId) : Promise.resolve(NO_DRAFTS),
+    [accountId]
+  );
+  return useStoreValue(load, NO_DRAFTS, ["drafts"]);
+}
+function useFlushOutbox() {
+  const arbi = chunkVGMMK5OM_cjs.useArbi();
+  const queryClient = reactQuery.useQueryClient();
+  return React.useCallback(() => flushOutbox({ arbi, queryClient }), [arbi, queryClient]);
+}
+function useSyncOfflineMailbox() {
+  const arbi = chunkVGMMK5OM_cjs.useArbi();
+  return React.useCallback((options) => syncOfflineMailbox({ arbi }, options), [arbi]);
+}
+
+// src/mail/offline/confirm-sign-out.ts
+async function confirmLosingOfflineMail(confirm) {
+  const [outbox, drafts] = await Promise.all([
+    listOutbox().catch(() => []),
+    listLocalDrafts().catch(() => [])
+  ]);
+  const unsent = outbox.filter((item) => item.status !== "sent").length;
+  if (unsent === 0 && drafts.length === 0) return true;
+  const parts = [
+    unsent > 0 ? `${unsent} unsent ${unsent === 1 ? "message" : "messages"} in your Outbox` : "",
+    drafts.length > 0 ? `${drafts.length} ${drafts.length === 1 ? "draft" : "drafts"} saved only on this device` : ""
+  ].filter(Boolean);
+  return confirm({
+    message: `You have ${parts.join(" and ")}. Signing out deletes ${unsent + drafts.length === 1 ? "it" : "them"} from this device. Reconnect first to send and save them.`,
+    title: "Sign out and delete unsent mail?"
+  });
+}
 function useConnectorMutation(mutationFn) {
   const qc = reactQuery.useQueryClient();
   return reactQuery.useMutation({
@@ -11582,9 +12805,9 @@ function useDeleteCalendar() {
 function useCreateEvent() {
   const arbi = chunkVGMMK5OM_cjs.useArbi();
   const qc = reactQuery.useQueryClient();
-  const { write, networkMode } = useOfflineWrite();
+  const { write: write2, networkMode } = useOfflineWrite();
   return reactQuery.useMutation({
-    mutationFn: (body) => write({ kind: "create", body }, () => arbi.calendar.createEvent(body)),
+    mutationFn: (body) => write2({ kind: "create", body }, () => arbi.calendar.createEvent(body)),
     networkMode,
     onSuccess: () => {
       void invalidateCalendarEvents(qc);
@@ -11594,9 +12817,9 @@ function useCreateEvent() {
 function useUpdateEvent() {
   const arbi = chunkVGMMK5OM_cjs.useArbi();
   const qc = reactQuery.useQueryClient();
-  const { write, networkMode } = useOfflineWrite();
+  const { write: write2, networkMode } = useOfflineWrite();
   return reactQuery.useMutation({
-    mutationFn: ({ target, body }) => write({ kind: "update", target, body }, () => arbi.calendar.updateEvent(target, body)),
+    mutationFn: ({ target, body }) => write2({ kind: "update", target, body }, () => arbi.calendar.updateEvent(target, body)),
     networkMode,
     onSuccess: () => {
       void invalidateCalendarEvents(qc);
@@ -11606,9 +12829,9 @@ function useUpdateEvent() {
 function useDeleteEvent() {
   const arbi = chunkVGMMK5OM_cjs.useArbi();
   const qc = reactQuery.useQueryClient();
-  const { write, networkMode } = useOfflineWrite();
+  const { write: write2, networkMode } = useOfflineWrite();
   return reactQuery.useMutation({
-    mutationFn: (target) => write({ kind: "delete", target }, () => arbi.calendar.deleteEvent(target)),
+    mutationFn: (target) => write2({ kind: "delete", target }, () => arbi.calendar.deleteEvent(target)),
     networkMode,
     onSuccess: () => {
       void invalidateCalendarEvents(qc);
@@ -11628,9 +12851,9 @@ function useMoveEvent() {
 function useRespondToEvent() {
   const arbi = chunkVGMMK5OM_cjs.useArbi();
   const qc = reactQuery.useQueryClient();
-  const { write, networkMode } = useOfflineWrite();
+  const { write: write2, networkMode } = useOfflineWrite();
   return reactQuery.useMutation({
-    mutationFn: (params) => write({ kind: "respond", params }, () => arbi.calendar.respond(params)),
+    mutationFn: (params) => write2({ kind: "respond", params }, () => arbi.calendar.respond(params)),
     networkMode,
     onSuccess: () => {
       void invalidateCalendarEvents(qc);
@@ -11870,7 +13093,7 @@ function useSyncAccountsOnOpen(enabled = true) {
   const arbi = chunkVGMMK5OM_cjs.useArbi();
   const { data: accounts } = useCalendarAccounts(enabled);
   const qc = reactQuery.useQueryClient();
-  const [syncing, setSyncing] = React.useState(false);
+  const [syncing2, setSyncing] = React.useState(false);
   React.useEffect(() => {
     if (!enabled || !accounts?.length) return;
     const due = accounts.filter((a) => !syncedThisSession.has(a.id));
@@ -11882,7 +13105,7 @@ function useSyncAccountsOnOpen(enabled = true) {
       void invalidateAccounts(qc);
     });
   }, [enabled, accounts, arbi, qc]);
-  return { syncing };
+  return { syncing: syncing2 };
 }
 function useBookingPages(enabled = true) {
   const arbi = chunkVGMMK5OM_cjs.useArbi();
@@ -11910,6 +13133,349 @@ function useDeleteBookingPage() {
     onSuccess: () => qc.invalidateQueries({ queryKey: chunkU4PWVSCT_cjs.calendarQueryKeys.bookingPages() })
   });
 }
+
+// src/offline-store/wipe.ts
+async function wipeStore(sealer3, store3) {
+  sealer3.forget();
+  await store3.deleteDatabase();
+}
+
+// src/calendar/offline/outbox.ts
+var OFFLINE_CALENDAR_DB = "arbi-offline-calendar";
+var CACHE_LIMIT = 200;
+var OfflineCalendarLockedError = class extends Error {
+  constructor() {
+    super("Sign in to open the calendar saved on this device");
+    this.name = "OfflineCalendarLockedError";
+  }
+};
+var store2 = createRecordStore(OFFLINE_CALENDAR_DB);
+var sealer2 = client.createOfflineSealer("arbi-offline-calendar-v1", {
+  locked: () => new OfflineCalendarLockedError()
+});
+function isCalendarOffline() {
+  return isBrowserOffline();
+}
+function isCalendarNetworkError(error) {
+  if (isNetworkFailure(error)) return true;
+  const status = error?.status;
+  return typeof status !== "number" && isBrowserOffline();
+}
+var cacheBucket = () => sealer2.blind("bucket", "cache");
+var cacheKey = (key) => sealer2.blind("cache", key);
+async function writeCalendarCache(key, data) {
+  const sealed = await sealer2.sealJson({ key, data });
+  const now = Date.now();
+  await store2.putRecord({
+    key: await cacheKey(key),
+    kind: "cache",
+    bucket: await cacheBucket(),
+    sortAt: now,
+    size: sealed.length,
+    lastAccess: now,
+    data: sealed
+  });
+  await evictCache();
+}
+async function readCalendarCache(key) {
+  try {
+    const blindKey = await cacheKey(key);
+    const record = await store2.getRecord(blindKey);
+    if (!record) return null;
+    const opened = await sealer2.openJson(record.data);
+    if (opened.key !== key) return null;
+    await store2.putRecord({ ...record, lastAccess: Date.now() });
+    return opened.data;
+  } catch {
+    return null;
+  }
+}
+async function evictCache() {
+  const rows = (await store2.allRecordAccess()).filter((r) => r.kind === "cache");
+  if (rows.length <= CACHE_LIMIT) return;
+  rows.sort((a, b) => a.lastAccess - b.lastAccess);
+  await store2.deleteRecords(rows.slice(0, rows.length - CACHE_LIMIT).map((r) => r.key));
+}
+var outboxBucket = () => sealer2.blind("bucket", "outbox");
+var outboxKey = (requestId) => sealer2.blind("outbox", requestId);
+var seqCounter2 = 0;
+async function writeItem(item) {
+  const sealed = await sealer2.sealJson(item);
+  await store2.putRecord({
+    key: await outboxKey(item.requestId),
+    kind: "outbox",
+    bucket: await outboxBucket(),
+    sortAt: item.seq,
+    size: sealed.length,
+    lastAccess: Date.now(),
+    data: sealed
+  });
+}
+async function readItems() {
+  const records = await store2.recordsInBucket(await outboxBucket());
+  const items = [];
+  for (const record of records) {
+    try {
+      items.push(await sealer2.openJson(record.data));
+    } catch {
+    }
+  }
+  return items.sort((a, b) => a.seq - b.seq);
+}
+function newRequestId() {
+  return typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+async function enqueueCalendarWrite(op) {
+  const now = Date.now();
+  seqCounter2 = Math.max(seqCounter2 + 1, now * 1e3);
+  const item = {
+    requestId: newRequestId(),
+    op,
+    state: "queued",
+    attempts: 0,
+    createdAt: now,
+    seq: seqCounter2
+  };
+  await writeItem(item);
+  notify2("enqueued");
+  return { requestId: item.requestId };
+}
+async function listCalendarOutbox() {
+  try {
+    return (await readItems()).map(({ requestId, op, state, inDoubt, error }) => ({
+      requestId,
+      op,
+      state,
+      inDoubt,
+      error
+    }));
+  } catch {
+    return [];
+  }
+}
+function classify2(error) {
+  if (isCalendarNetworkError(error)) return "offline";
+  const status = error?.status;
+  if (typeof status === "number" && status >= 500) return "retry";
+  return "failed";
+}
+function run(exec, item) {
+  const op = item.op;
+  switch (op.kind) {
+    case "create":
+      return exec.create(op.body, item.requestId);
+    case "update":
+      return exec.update(op.target, op.body, item.requestId);
+    case "delete":
+      return exec.delete(op.target, item.requestId);
+    case "respond":
+      return exec.respond(op.params, item.requestId);
+  }
+}
+var replaying = null;
+function replayCalendarOutbox(exec) {
+  if (replaying) return replaying;
+  const locks = typeof navigator !== "undefined" ? navigator.locks : void 0;
+  const run2 = locks?.request ? locks.request(
+    "arbi-calendar-outbox-replay",
+    () => replayOnce(exec)
+  ) : replayOnce(exec);
+  const current = run2.finally(() => {
+    replaying = null;
+  });
+  replaying = current;
+  return current;
+}
+async function replayOnce(exec) {
+  const result = { sent: 0, failed: 0, inDoubt: 0 };
+  for (const queued of await readItems()) {
+    if (queued.state !== "queued" && queued.state !== "sending") continue;
+    if (isCalendarOffline()) break;
+    let item = {
+      ...queued,
+      inDoubt: queued.inDoubt || queued.state === "sending"
+    };
+    if (item.op.kind === "create" && item.inDoubt && exec.findCreated) {
+      let found = false;
+      try {
+        found = await exec.findCreated(item.requestId, item.op.body);
+      } catch (error) {
+        if (classify2(error) === "offline") break;
+      }
+      if (found) {
+        await store2.deleteRecords([await outboxKey(item.requestId)]);
+        result.sent++;
+        continue;
+      }
+    }
+    item = { ...item, state: "sending", attempts: item.attempts + 1 };
+    await writeItem(item);
+    let outcome;
+    let message;
+    try {
+      await run(exec, item);
+      outcome = "sent";
+    } catch (error) {
+      outcome = classify2(error);
+      message = error instanceof Error ? error.message : "The change could not be saved";
+    }
+    if (outcome === "sent") {
+      await store2.deleteRecords([await outboxKey(item.requestId)]);
+      result.sent++;
+      continue;
+    }
+    if (outcome === "failed") {
+      await writeItem({ ...item, state: "failed", error: message });
+      result.failed++;
+      continue;
+    }
+    const inDoubt = item.inDoubt || item.op.kind === "create";
+    await writeItem({ ...item, state: "queued", inDoubt, error: message });
+    if (inDoubt) result.inDoubt++;
+    if (outcome === "offline") break;
+  }
+  notify2();
+  return result;
+}
+var listeners2 = /* @__PURE__ */ new Set();
+function notify2(change = "changed") {
+  for (const l of listeners2) l(change);
+}
+function onCalendarOutboxChange(listener) {
+  listeners2.add(listener);
+  return () => listeners2.delete(listener);
+}
+async function wipeCalendarOffline() {
+  await wipeStore(sealer2, store2);
+  notify2();
+}
+async function claimCalendarOffline(userExtId) {
+  const owner = await store2.getMeta("owner");
+  if (owner && owner !== userExtId) await wipeCalendarOffline();
+  await store2.setMeta("owner", userExtId);
+}
+
+// src/calendar/offline/support.ts
+var calendarOfflineSupport = {
+  async read(key, fetch2) {
+    const cacheKey2 = JSON.stringify(key);
+    if (!isCalendarOffline()) {
+      try {
+        const data = await fetch2();
+        void writeCalendarCache(cacheKey2, data).catch(() => {
+        });
+        return data;
+      } catch (err) {
+        if (!isCalendarNetworkError(err)) throw err;
+      }
+    }
+    const cached = await readCalendarCache(cacheKey2).catch(
+      () => null
+    );
+    if (cached != null) return cached;
+    throw new browser.ArbiApiError("You are offline and this view is not saved on this device");
+  },
+  async write(op, send) {
+    if (!isCalendarOffline()) return send();
+    const { requestId } = await enqueueCalendarWrite(op);
+    return { queued: true, requestId };
+  },
+  pending: listCalendarOutbox,
+  subscribe: (listener) => onCalendarOutboxChange(() => listener())
+};
+var day = (date, offset) => {
+  const t = /* @__PURE__ */ new Date(`${date}T00:00:00Z`);
+  t.setUTCDate(t.getUTCDate() + offset);
+  return t.toISOString();
+};
+var calendarOutboxExecutor = (arbi) => ({
+  create: (body) => arbi.calendar.createEvent(body),
+  update: (target, body) => arbi.calendar.updateEvent(target, body),
+  delete: (target) => arbi.calendar.deleteEvent(target),
+  respond: (params) => arbi.calendar.respond(params),
+  /** No server dedupe: an in-doubt create counts as made if an event with its title and start exists. */
+  async findCreated(_requestId, body) {
+    const { title, start } = body;
+    const date = (start?.date_time ?? start?.date ?? "").slice(0, 10);
+    if (!title || !/^\d{4}-\d{2}-\d{2}$/.test(date)) return false;
+    const events = await arbi.calendar.listEvents({
+      start: day(date, -1),
+      end: day(date, 2)
+    });
+    return events.some(
+      (e) => e.title === title && (start?.date_time ? (e.start.date_time ?? "").slice(0, 16) === start.date_time.slice(0, 16) : e.start.date === start?.date)
+    );
+  }
+});
+var SYNC_CHANNEL = "arbi-calendar-outbox";
+function refreshCalendarQueries(queryClient) {
+  void queryClient.invalidateQueries({ queryKey: chunkU4PWVSCT_cjs.calendarQueryKeys.all() });
+}
+async function replay(arbi, queryClient) {
+  const result = await replayCalendarOutbox(calendarOutboxExecutor(arbi));
+  if (result.sent || result.failed) {
+    refreshCalendarQueries(queryClient);
+    try {
+      const channel2 = new BroadcastChannel(SYNC_CHANNEL);
+      channel2.postMessage("synced");
+      channel2.close();
+    } catch {
+    }
+  }
+  if (result.failed)
+    chunkDZUBZ45Y_cjs.notify.error(
+      result.failed === 1 ? "A calendar change made offline could not be saved" : `${result.failed} calendar changes made offline could not be saved`
+    );
+}
+function useCalendarOfflineRuntime() {
+  const { status, serverSessionKey, user } = chunk2Y2WOIHH_cjs.useArbiSession();
+  const userExtId = user?.external_id;
+  const authenticated = status === "signed-in";
+  const hasSession = !!serverSessionKey;
+  const arbi = chunkVGMMK5OM_cjs.useArbi();
+  const ready = authenticated && hasSession && arbi.isLoggedIn;
+  const queryClient = reactQuery.useQueryClient();
+  React.useEffect(() => {
+    if (!authenticated || !userExtId) return;
+    claimCalendarOffline(userExtId).catch(
+      (error) => client.logger.warn("[offline-calendar] could not bind the store", error)
+    );
+  }, [authenticated, userExtId]);
+  React.useEffect(() => {
+    if (!ready) return;
+    const run2 = () => {
+      if (!reactQuery.onlineManager.isOnline()) return;
+      replay(arbi, queryClient).catch(
+        (error) => client.logger.warn("[offline-calendar] replay failed", error)
+      );
+    };
+    run2();
+    let wasOnline = reactQuery.onlineManager.isOnline();
+    const offOnline = reactQuery.onlineManager.subscribe((online) => {
+      if (online && !wasOnline) run2();
+      wasOnline = online;
+    });
+    let queued = null;
+    const offOutbox = onCalendarOutboxChange((change) => {
+      if (change !== "enqueued") return;
+      if (queued) clearTimeout(queued);
+      queued = setTimeout(run2, 2e3);
+    });
+    let channel2 = null;
+    try {
+      channel2 = new BroadcastChannel(SYNC_CHANNEL);
+      channel2.onmessage = () => refreshCalendarQueries(queryClient);
+    } catch {
+      channel2 = null;
+    }
+    return () => {
+      channel2?.close();
+      offOnline();
+      offOutbox();
+      if (queued) clearTimeout(queued);
+    };
+  }, [ready, arbi, queryClient]);
+}
 function useWorkspaceDocs(workspaceId) {
   const { data: docs = [], isLoading, isError } = chunkQ6U7ALNV_cjs.useDocuments(workspaceId);
   const docIds = React.useMemo(
@@ -11938,7 +13504,7 @@ function useAiTask() {
     artifactsRef.current = /* @__PURE__ */ new Map();
     bufferRef.current = "";
   }, []);
-  const run = React.useCallback(
+  const run2 = React.useCallback(
     async (question, docIds, opts) => {
       setStatus("running");
       setText("");
@@ -12006,7 +13572,7 @@ function useAiTask() {
     error,
     responseId,
     artifacts,
-    run,
+    run: run2,
     reset,
     isRunning: status === "running",
     isDone: status === "done"
@@ -12444,13 +14010,13 @@ function useSemanticSearch(docIds = [], options = {}) {
         chunkAXKHDLBB_cjs.clearSearchSession(void 0, session);
         return;
       }
-      const run = session.getState().run + 1;
+      const run2 = session.getState().run + 1;
       const searched = workspaceId ?? session.getState().workspaceId ?? void 0;
       session.setState((s) => ({
         query: trimmed,
         status: "running",
         error: null,
-        run,
+        run: run2,
         workspaceId: workspaceId ?? s.workspaceId
       }));
       try {
@@ -12460,10 +14026,10 @@ function useSemanticSearch(docIds = [], options = {}) {
           ...model ? { model } : {},
           ...searched ? { workspaceId: searched } : {}
         });
-        if (session.getState().run !== run) return;
+        if (session.getState().run !== run2) return;
         session.setState({ results: browser.searchChunks(result), searched: true, status: "done" });
       } catch (error) {
-        if (session.getState().run !== run) return;
+        if (session.getState().run !== run2) return;
         session.setState({
           status: "error",
           error: error instanceof Error ? error.message : "Search failed"
@@ -12666,7 +14232,7 @@ var CitationRendererComponent = ({
   useCitationState,
   onCloseCitation,
   onDismissCitation,
-  notify: notify2,
+  notify: notify3,
   docTitles
 }) => {
   const chunkMap = React.useMemo(() => {
@@ -12710,7 +14276,7 @@ var CitationRendererComponent = ({
       useCitationState,
       onCloseCitation,
       onDismissCitation,
-      notify: notify2
+      notify: notify3
     }),
     [
       citations,
@@ -12723,7 +14289,7 @@ var CitationRendererComponent = ({
       useCitationState,
       onCloseCitation,
       onDismissCitation,
-      notify2
+      notify3
     ]
   );
   return /* @__PURE__ */ jsxRuntime.jsx(CitationAnchorContext.Provider, { value: anchorContext, children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: chunkS6A6FSG7_cjs.cn("citation-container", className), "data-testid": "citation-renderer", children: renderMarkdown({
@@ -12782,7 +14348,7 @@ var CitationPopover = ({
   useCitationState,
   onCloseCitation,
   onDismissCitation,
-  notify: notify2,
+  notify: notify3,
   children
 }) => {
   const { activeCitationKey, viewingPassageId, isOnConversationPage } = useCitationState();
@@ -12856,11 +14422,11 @@ var CitationPopover = ({
     const source = [firstTitle, firstPage != null ? `p.${firstPage}` : null].filter(Boolean).join(", ");
     try {
       await navigator.clipboard.writeText(source ? `\u201C${firstText}\u201D (${source})` : firstText);
-      notify2?.("Citation copied", "success");
+      notify3?.("Citation copied", "success");
     } catch {
-      notify2?.("Could not copy the citation", "error");
+      notify3?.("Could not copy the citation", "error");
     }
-  }, [firstText, firstTitle, firstPage, notify2]);
+  }, [firstText, firstTitle, firstPage, notify3]);
   const items = isStreaming || chunks.length === 0 ? [] : [
     {
       id: "open",
@@ -14573,12 +16139,12 @@ function annotateThread(messages, accessors, runWindowMs = RUN_WINDOW_MS) {
   return messages.map((message, i) => {
     const next = messages[i + 1];
     const prev = messages[i - 1];
-    const day = dayKey(createdAt(message));
-    const continuesIntoNext = !!next && senderId(next) === senderId(message) && dayKey(createdAt(next)) === day && Date.parse(createdAt(next)) - Date.parse(createdAt(message)) < runWindowMs;
+    const day2 = dayKey(createdAt(message));
+    const continuesIntoNext = !!next && senderId(next) === senderId(message) && dayKey(createdAt(next)) === day2 && Date.parse(createdAt(next)) - Date.parse(createdAt(message)) < runWindowMs;
     return {
       message,
       isLastOfRun: !continuesIntoNext,
-      isFirstOfDay: !prev || dayKey(createdAt(prev)) !== day
+      isFirstOfDay: !prev || dayKey(createdAt(prev)) !== day2
     };
   });
 }
@@ -17639,6 +19205,7 @@ exports.MIN_NARRATION_DWELL_MS = MIN_NARRATION_DWELL_MS;
 exports.MODEL_GROUP_LABELS = MODEL_GROUP_LABELS;
 exports.MailOfflineUnavailableError = MailOfflineUnavailableError;
 exports.MessageArtifactCard = MessageArtifactCard;
+exports.OUTBOX_FOLDER = OUTBOX_FOLDER;
 exports.PENDING_SYNC_PREDICATE = PENDING_SYNC_PREDICATE;
 exports.POLL_EVERY_MS = POLL_EVERY_MS;
 exports.PhotoCapture = PhotoCapture;
@@ -17693,6 +19260,7 @@ exports.cachedAssistantMode = cachedAssistantMode;
 exports.cachedMentionCandidates = cachedMentionCandidates;
 exports.cachedQuotaUsedUp = cachedQuotaUsedUp;
 exports.calendarNotificationMeta = calendarNotificationMeta;
+exports.calendarOfflineSupport = calendarOfflineSupport;
 exports.callNotificationMeta = callNotificationMeta;
 exports.captureFrameAsBlob = captureFrameAsBlob;
 exports.claimOfflineQueue = claimOfflineQueue;
@@ -17701,6 +19269,7 @@ exports.clearUserInputRequest = clearUserInputRequest;
 exports.commitFinalMessage = commitFinalMessage;
 exports.completeQueuedUserMessageByContent = completeQueuedUserMessageByContent;
 exports.computeOnline = computeOnline;
+exports.confirmLosingOfflineMail = confirmLosingOfflineMail;
 exports.connectOAuthCalendarAccount = connectOAuthCalendarAccount;
 exports.connectorErrorStatus = connectorErrorStatus;
 exports.connectorReturnTo = connectorReturnTo;
@@ -17721,6 +19290,8 @@ exports.cropImage = cropImage;
 exports.dayKey = dayKey;
 exports.defaultMailAlias = defaultMailAlias;
 exports.defineRowsSource = defineRowsSource;
+exports.deleteLocalDraft = deleteLocalDraft;
+exports.deleteOutboxItem = deleteOutboxItem;
 exports.deploymentUserMeta = deploymentUserMeta;
 exports.describeActivity = describeActivity;
 exports.describeCalendarNotification = describeCalendarNotification;
@@ -17730,8 +19301,10 @@ exports.disconnectAttachedRun = disconnectAttachedRun;
 exports.documentActivityMeta = documentActivityMeta;
 exports.documentActivityPhrase = documentActivityPhrase;
 exports.documentDisplayName = documentDisplayName;
+exports.documentMailAttachment = documentMailAttachment;
 exports.docxMentionMeta = docxMentionMeta;
 exports.downloadRecoveryFile = downloadRecoveryFile;
+exports.enqueueOutbox = enqueueOutbox;
 exports.ensureAssistantMessageLoading = ensureAssistantMessageLoading;
 exports.extractZipFile = extractZipFile;
 exports.fallbackFileName = fallbackFileName;
@@ -17769,6 +19342,7 @@ exports.isDeploymentAdmin = isDeploymentAdmin;
 exports.isDeploymentUserNotification = isDeploymentUserNotification;
 exports.isFullConfig = isFullConfig;
 exports.isMessageRunning = isMessageRunning;
+exports.isNetworkFailure = isNetworkFailure;
 exports.isNotificationRow = isNotificationRow;
 exports.isOrphanedUserMessage = isOrphanedUserMessage;
 exports.isQueuedCalendarWrite = isQueuedCalendarWrite;
@@ -17782,6 +19356,7 @@ exports.isWorkspaceArchivedError = isWorkspaceArchivedError;
 exports.isWorkspaceNotificationType = isWorkspaceNotificationType;
 exports.isZipFile = isZipFile;
 exports.loadOfflineDocument = loadOfflineDocument;
+exports.loadOfflineMailAttachment = loadAttachment;
 exports.mailDraftIdFromContent = mailDraftIdFromContent;
 exports.mailJson = mailJson;
 exports.markMessageAsFailed = markMessageAsFailed;
@@ -17790,6 +19365,7 @@ exports.migrateLegacyThreadDocuments = migrateLegacyThreadDocuments;
 exports.mountDiditVerification = mountDiditVerification;
 exports.nextAliasSuggestion = nextAliasSuggestion;
 exports.notificationUserName = notificationUserName;
+exports.offlineMailReads = offlineMailReads;
 exports.openAccessRequest = openAccessRequest;
 exports.parseActivityContent = parseActivityContent;
 exports.parseDashboardSpec = parseDashboardSpec;
@@ -17812,8 +19388,10 @@ exports.resetMessageContent = resetMessageContent;
 exports.resolveActiveWorkspace = resolveActiveWorkspace;
 exports.resolveConfigModel = resolveConfigModel;
 exports.resolveReplyTarget = resolveReplyTarget;
+exports.retryOutboxItem = retryOutboxItem;
 exports.rollbackOptimisticDocumentEdit = rollbackOptimisticDocumentEdit;
 exports.safePortalUrl = safePortalUrl;
+exports.saveLocalDraft = saveLocalDraft;
 exports.serializeDashboardSpec = serializeDashboardSpec;
 exports.serverNotificationBellEntry = serverNotificationBellEntry;
 exports.setMessageContent = setMessageContent;
@@ -17876,6 +19454,7 @@ exports.useCalendarEvent = useCalendarEvent;
 exports.useCalendarEventByUid = useCalendarEventByUid;
 exports.useCalendarEvents = useCalendarEvents;
 exports.useCalendarInvitations = useCalendarInvitations;
+exports.useCalendarOfflineRuntime = useCalendarOfflineRuntime;
 exports.useCalendarOutbox = useCalendarOutbox;
 exports.useCalendarOverlays = useCalendarOverlays;
 exports.useCalendarSettings = useCalendarSettings;
@@ -17996,6 +19575,7 @@ exports.useFetchCalendarEvent = useFetchCalendarEvent;
 exports.useFilteredProjects = useFilteredProjects;
 exports.useFinaliseTranslation = useFinaliseTranslation;
 exports.useFindTime = useFindTime;
+exports.useFlushOutbox = useFlushOutbox;
 exports.useFollowThread = useFollowThread;
 exports.useFreeBusy = useFreeBusy;
 exports.useGenerateAgentAvatar = useGenerateAgentAvatar;
@@ -18019,6 +19599,7 @@ exports.useIsWorkspaceOwner = useIsWorkspaceOwner;
 exports.useKeepDocumentsOffline = useKeepDocumentsOffline;
 exports.useLinkContact = useLinkContact;
 exports.useLinkMentions = useLinkMentions;
+exports.useLocalDrafts = useLocalDrafts;
 exports.useMailAccounts = useMailAccounts;
 exports.useMailAttachmentText = useMailAttachmentText;
 exports.useMailCache = useMailCache;
@@ -18049,8 +19630,12 @@ exports.useNotificationPreferences = useNotificationPreferences;
 exports.useNotifications = useNotifications;
 exports.useNotifyConversation = useNotifyConversation;
 exports.useOfflineDocumentIds = useOfflineDocumentIds;
+exports.useOfflineMailRuntime = useOfflineMailRuntime;
+exports.useOfflineMailSettings = useOfflineMailSettings;
+exports.useOfflineMailStatus = useOfflineMailStatus;
 exports.useOpenSelectedWorkspace = useOpenSelectedWorkspace;
 exports.useOpenViewerDocumentId = useOpenViewerDocumentId;
+exports.useOutbox = useOutbox;
 exports.usePanelDataset = usePanelDataset;
 exports.usePassageQuotes = usePassageQuotes;
 exports.usePasswordChange = usePasswordChange;
@@ -18135,6 +19720,7 @@ exports.useSupportTickets = useSupportTickets;
 exports.useSwitchWorkspace = useSwitchWorkspace;
 exports.useSyncAccountsOnOpen = useSyncAccountsOnOpen;
 exports.useSyncCalendarAccount = useSyncCalendarAccount;
+exports.useSyncOfflineMailbox = useSyncOfflineMailbox;
 exports.useTerminateSession = useTerminateSession;
 exports.useThinkingContent = useThinkingContent;
 exports.useThreadDocument = useThreadDocument;
@@ -18185,7 +19771,9 @@ exports.userDisplayName = userDisplayName;
 exports.userInitials = userInitials;
 exports.viewsOfTable = viewsOfTable;
 exports.waitForResponseId = waitForResponseId;
+exports.wipeCalendarOffline = wipeCalendarOffline;
 exports.wipeOfflineDocuments = wipeOfflineDocuments;
+exports.wipeOfflineMail = wipeOfflineMail;
 exports.withRelativePath = withRelativePath;
 exports.workflowStepOf = workflowStepOf;
 exports.workspaceHouseTemplateId = workspaceHouseTemplateId;