@arbidocs/react 0.5.110 → 0.5.112

package/dist/mail/offline/mailbox.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mail/offline/mailbox.ts"],
+  "sourcesContent": ["/**\n * Typed, encrypted reads and writes of mailbox data in the offline store: accounts, folders,\n * message headers (what a folder list shows), bodies (the opened message) and attachment bytes.\n *\n * Headers and bodies are separate records so a folder list decrypts only small headers; bodies are\n * decrypted when a message is opened or searched.\n */\n\nimport type { MailAccount, MailFolder, MailMessage, MailPolicy } from '../types'\nimport { blind, openBytes, openJson, sealBytes, sealJson } from './crypto'\nimport {\n  deleteRecords,\n  getRecord,\n  hasRecord,\n  putRecord,\n  recordsInBucket,\n  touchRecord,\n  type RecordKind,\n  type StoredRecord,\n} from './store'\n\nexport const keyOf = {\n  accounts: () => blind('accounts'),\n  policy: () => blind('policy'),\n  folders: (accountId: string) => blind('folders', accountId),\n  header: (accountId: string, folderId: string, messageId: string) =>\n    blind('header', accountId, folderId, messageId),\n  body: (accountId: string, messageId: string) => blind('body', accountId, messageId),\n  attachment: (accountId: string, messageId: string, attachmentId: string) =>\n    blind('attachment', accountId, messageId, attachmentId),\n}\n\nexport const bucketOf = {\n  global: () => blind('bucket', 'global'),\n  folder: (accountId: string, folderId: string) => blind('bucket', 'folder', accountId, folderId),\n  account: (accountId: string) => blind('bucket', 'account', accountId),\n}\n\nasync function put(\n  kind: RecordKind,\n  key: string,\n  bucket: string,\n  data: Uint8Array,\n  sortAt = Date.now()\n): Promise<void> {\n  const now = Date.now()\n  await putRecord({ key, kind, bucket, sortAt, size: data.byteLength, lastAccess: now, data })\n}\n\nasync function readJson<T>(record: StoredRecord | undefined): Promise<T | undefined> {\n  if (!record) return undefined\n  try {\n    return await openJson<T>(record.data)\n  } catch {\n    // Sealed under another identity (a different account wrote it) or damaged: treat as absent.\n    return undefined\n  }\n}\n\nconst receivedAt = (m: MailMessage) => (m.received_at ? Date.parse(m.received_at) || 0 : 0)\n\nexport async function saveAccounts(accounts: MailAccount[]): Promise<void> {\n  await put('accounts', await keyOf.accounts(), await bucketOf.global(), await sealJson(accounts))\n}\n\nexport async function loadAccounts(): Promise<MailAccount[] | undefined> {\n  return readJson<MailAccount[]>(await getRecord(await keyOf.accounts()))\n}\n\nexport async function savePolicy(policy: MailPolicy): Promise<void> {\n  await put('policy', await keyOf.policy(), await bucketOf.global(), await sealJson(policy))\n}\n\nexport async function loadPolicy(): Promise<MailPolicy | undefined> {\n  return readJson<MailPolicy>(await getRecord(await keyOf.policy()))\n}\n\nexport async function saveFolders(accountId: string, folders: MailFolder[]): Promise<void> {\n  await put(\n    'folders',\n    await keyOf.folders(accountId),\n    await bucketOf.account(accountId),\n    await sealJson(folders)\n  )\n}\n\nexport async function loadFolders(accountId: string): Promise<MailFolder[] | undefined> {\n  return readJson<MailFolder[]>(await getRecord(await keyOf.folders(accountId)))\n}\n\n/** A list row: the message without its body text/html or attachment bytes. */\nexport function toHeader(message: MailMessage): MailMessage {\n  return {\n    ...message,\n    text: '',\n    html: undefined,\n    delivery: undefined,\n    attachments: message.attachments.map((a) => ({ ...a, content_base64: null })),\n  }\n}\n\nexport interface StoredHeader {\n  key: string\n  sortAt: number\n  message: MailMessage\n}\n\nexport async function saveHeader(\n  accountId: string,\n  folderId: string,\n  message: MailMessage\n): Promise<void> {\n  await put(\n    'header',\n    await keyOf.header(accountId, folderId, message.id),\n    await bucketOf.folder(accountId, folderId),\n    await sealJson(toHeader(message)),\n    receivedAt(message)\n  )\n}\n\n/** A folder's saved headers, newest first. */\nexport async function loadHeaders(accountId: string, folderId: string): Promise<StoredHeader[]> {\n  const records = await recordsInBucket(await bucketOf.folder(accountId, folderId))\n  const out: StoredHeader[] = []\n  for (const record of records) {\n    if (record.kind !== 'header') continue\n    const message = await readJson<MailMessage>(record)\n    if (message) out.push({ key: record.key, sortAt: record.sortAt, message })\n  }\n  return out.sort((a, b) => b.sortAt - a.sortAt)\n}\n\n/** Whether a folder has ever been saved on this device (so \"empty\" means empty, not \"not saved\"). */\nexport async function hasFolder(accountId: string): Promise<boolean> {\n  return hasRecord(await keyOf.folders(accountId))\n}\n\nexport async function saveBody(accountId: string, message: MailMessage): Promise<void> {\n  const stripped: MailMessage = {\n    ...message,\n    attachments: message.attachments.map((a) => ({ ...a, content_base64: null })),\n  }\n  await put(\n    'body',\n    await keyOf.body(accountId, message.id),\n    await bucketOf.account(accountId),\n    await sealJson(stripped),\n    receivedAt(message)\n  )\n}\n\nexport async function hasBody(accountId: string, messageId: string): Promise<boolean> {\n  return hasRecord(await keyOf.body(accountId, messageId))\n}\n\nexport async function loadBody(\n  accountId: string,\n  messageId: string\n): Promise<MailMessage | undefined> {\n  return readJson<MailMessage>(await getRecord(await keyOf.body(accountId, messageId)))\n}\n\nexport async function saveAttachment(\n  accountId: string,\n  messageId: string,\n  attachmentId: string,\n  bytes: Uint8Array,\n  /** When its message was received (ms), so it leaves the device with it. */\n  sortAt?: number\n): Promise<void> {\n  await put(\n    'attachment',\n    await keyOf.attachment(accountId, messageId, attachmentId),\n    await bucketOf.account(accountId),\n    await sealBytes(bytes),\n    sortAt || undefined\n  )\n}\n\nexport async function hasAttachment(\n  accountId: string,\n  messageId: string,\n  attachmentId: string\n): Promise<boolean> {\n  return hasRecord(await keyOf.attachment(accountId, messageId, attachmentId))\n}\n\n/** An attachment's bytes, or undefined when it wasn't saved (too large, or evicted). */\nexport async function loadAttachment(\n  accountId: string,\n  messageId: string,\n  attachmentId: string\n): Promise<Uint8Array | undefined> {\n  const key = await keyOf.attachment(accountId, messageId, attachmentId)\n  const record = await getRecord(key)\n  if (!record) return undefined\n  try {\n    const bytes = await openBytes(record.data)\n    void touchRecord(key)\n    return bytes\n  } catch {\n    return undefined\n  }\n}\n\nexport async function removeKeys(keys: string[]): Promise<void> {\n  await deleteRecords(keys)\n}\n\n/** Searchable text of an opened message: its text part, else its HTML without tags, and file names. */\nfunction bodyText(body: MailMessage): string {\n  const html = body.text ? '' : (body.html ?? '').replace(/<[^>]*>/g, ' ')\n  return `${body.text} ${html} ${body.attachments.map((a) => a.name).join(' ')}`\n}\n\nconst folded = (value: string) => value.toLocaleLowerCase().normalize('NFKD')\n\n/**\n * Search a folder on the device: every word must appear in the subject, a participant or the body\n * (the same \"all words\" feel as the server's search).\n */\nexport async function searchFolder(\n  accountId: string,\n  folderId: string,\n  query: string\n): Promise<MailMessage[]> {\n  const words = folded(query).split(/\\s+/).filter(Boolean)\n  const headers = await loadHeaders(accountId, folderId)\n  if (words.length === 0) return headers.map((h) => h.message)\n  const out: MailMessage[] = []\n  for (const { message } of headers) {\n    const people = [...message.sender, ...message.to, ...message.cc]\n      .map((p) => `${p.name ?? ''} ${p.email}`)\n      .join(' ')\n    let haystack = folded(`${message.subject} ${people} ${message.preview}`)\n    if (!words.every((w) => haystack.includes(w))) {\n      const body = await loadBody(accountId, message.id)\n      if (body) haystack += ' ' + folded(bodyText(body))\n    }\n    if (words.every((w) => haystack.includes(w))) out.push(message)\n  }\n  return out\n}\n\n/** Whether a folder is a view over the others (Flagged), with no messages of its own to keep. */\nexport const isVirtualFolder = (folder: Pick<MailFolder, 'role'> | undefined) =>\n  folder?.role === 'flagged'\n\n/**\n * Messages saved on the device across the account's folders (`include` picks the folders), each\n * once (a Gmail message is listed under every label), newest first.\n */\nexport async function loadAccountMessages(\n  accountId: string,\n  include: (folder: MailFolder) => boolean,\n  query = ''\n): Promise<MailMessage[]> {\n  const seen = new Map<string, MailMessage>()\n  for (const folder of (await loadFolders(accountId)) ?? []) {\n    if (isVirtualFolder(folder) || !include(folder)) continue\n    for (const message of await searchFolder(accountId, folder.id, query))\n      if (!seen.has(message.id)) seen.set(message.id, message)\n  }\n  return [...seen.values()].sort((a, b) => receivedAt(b) - receivedAt(a))\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mail/offline/outbox.js

@@ -0,0 +1,167 @@
+import { blind, openJson, sealJson } from "./crypto.js";
+import { isNetworkFailure } from "../../offline-store/network.js";
+import { deleteRecords, putRecord, recordsInBucket } from "./store.js";
+import { notifyOfflineMailChange } from "./settings.js";
+const bucket = () => blind("bucket", "outbox");
+const keyFor = (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;
+}
+let seqCounter = 0;
+async function write(item) {
+  await putRecord({
+    key: await keyFor(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 keyFor(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 });
+}
+const 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 unlocked = /* @__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 (!unlocked.has(item.account.id)) {
+      await sender.unlock(item.account).catch(() => {
+      });
+      unlocked.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) => keyFor(i.id))));
+  notifyOfflineMailChange("outbox");
+}
+export {
+  deleteOutboxItem,
+  enqueueOutbox,
+  flushOutboxOnce,
+  listOutbox,
+  purgeSentOutbox,
+  retryOutboxItem
+};
+//# sourceMappingURL=outbox.js.map

package/dist/mail/offline/outbox.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mail/offline/outbox.ts"],
+  "sourcesContent": ["/**\n * The mail Outbox: messages the user pressed Send on while offline (or whose send could not reach\n * the server), kept encrypted on this device and sent in order once the connection is back.\n *\n * Exactly-once: every message keeps the `request_id` it was given when the user pressed Send, for\n * its whole life in the Outbox. The send endpoints deduplicate on it (Redis reservation plus a\n * durable record per request_id), so a replay after a lost response, a reload mid-send, or two open\n * tabs flushing at once returns the first result instead of sending again. A secure message is\n * prepared (encrypted, recipient keys generated) once and that exact payload is stored and replayed,\n * because the server fingerprints the ciphertext.\n *\n * Outcomes:\n *  - network down / session not ready: the message goes back to \"queued\" and the flush stops, to\n *    resume in order on the next reconnect;\n *  - refused (4xx): \"failed\" with the server's reason; Retry resends the same request_id;\n *  - unknown outcome (409 already attempted, 5xx, unconfirmed relay): \"failed\" and marked\n *    `inDoubt` \u2014 the message may have gone out, so the UI says to check Sent; Retry is still safe\n *    (same request_id), it reports \"sent\" if the first attempt completed.\n */\n\nimport type { MailAccount, MailCompose } from '../types'\nimport { blind, openJson, sealJson } from './crypto'\nimport { isNetworkFailure } from '../../offline-store/network'\nimport { deleteRecords, putRecord, recordsInBucket } from './store'\nimport { notifyOfflineMailChange } from './settings'\n\ntype OutboxStatus = 'queued' | 'sending' | 'sent' | 'failed'\n\nexport interface OutboxItem {\n  id: string\n  /** The idempotency key sent with every attempt. Never changes for this item. */\n  requestId: string\n  account: MailAccount\n  compose: MailCompose\n  secure: boolean\n  /** The encrypted secure-delivery request, prepared on the first attempt and replayed as is. */\n  securePayload?: unknown\n  status: OutboxStatus\n  error?: string\n  /** The server may already have sent it (unknown outcome). */\n  inDoubt?: boolean\n  attempts: number\n  createdAt: number\n  sentAt?: number\n  /** Enqueue order. */\n  seq: number\n}\n\nexport interface OutboxSender {\n  /** Prepare the secure payload for an item (only for secure items, once). */\n  prepareSecure: (item: OutboxItem) => Promise<unknown>\n  /** Make the account usable in this session before sending (connector tokens, IMAP credentials). */\n  unlock: (account: MailAccount) => Promise<void>\n  /** POST the message; resolves with the server's message id. */\n  send: (item: OutboxItem) => Promise<{ id?: string }>\n}\n\nconst bucket = () => blind('bucket', 'outbox')\nconst keyFor = (id: string) => blind('outbox', id)\n\n/** Problems that make a message unsendable from the Outbox, reported when the user presses Send. */\nfunction outboxProblem(compose: MailCompose): string | null {\n  const missing = compose.attachments.find((a) => a.content_base64 == null)\n  if (missing)\n    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.`\n  return null\n}\n\nlet seqCounter = 0\n\nasync function write(item: OutboxItem): Promise<void> {\n  await putRecord({\n    key: await keyFor(item.id),\n    kind: 'outbox',\n    bucket: await bucket(),\n    sortAt: item.seq,\n    size: 0,\n    lastAccess: Date.now(),\n    data: await sealJson(item),\n  })\n}\n\nexport async function listOutbox(): Promise<OutboxItem[]> {\n  const records = await recordsInBucket(await bucket())\n  const items: OutboxItem[] = []\n  for (const record of records) {\n    try {\n      items.push(await openJson<OutboxItem>(record.data))\n    } catch {\n      // Sealed under a different identity: not this user's mail; ignore.\n    }\n  }\n  return items.sort((a, b) => a.seq - b.seq)\n}\n\nexport async function enqueueOutbox(input: {\n  account: MailAccount\n  compose: MailCompose\n  requestId: string\n  secure: boolean\n  securePayload?: unknown\n}): Promise<OutboxItem> {\n  const problem = outboxProblem(input.compose)\n  if (problem) throw new Error(problem)\n  const now = Date.now()\n  // Monotonic even when two messages are queued in the same millisecond.\n  seqCounter = Math.max(seqCounter + 1, now * 1000)\n  const item: OutboxItem = {\n    id: crypto.randomUUID(),\n    requestId: input.requestId,\n    account: input.account,\n    compose: input.compose,\n    secure: input.secure,\n    securePayload: input.securePayload,\n    status: 'queued',\n    attempts: 0,\n    createdAt: now,\n    seq: seqCounter,\n  }\n  await write(item)\n  notifyOfflineMailChange('outbox')\n  return item\n}\n\nasync function update(item: OutboxItem, patch: Partial<OutboxItem>): Promise<OutboxItem> {\n  const next = { ...item, ...patch }\n  await write(next)\n  notifyOfflineMailChange('outbox')\n  return next\n}\n\nexport async function deleteOutboxItem(id: string): Promise<void> {\n  await deleteRecords([await keyFor(id)])\n  notifyOfflineMailChange('outbox')\n}\n\n/** Put a failed message back in the queue (same request_id, so it can't go out twice). */\nexport async function retryOutboxItem(id: string): Promise<void> {\n  const item = (await listOutbox()).find((i) => i.id === id)\n  if (item && item.status === 'failed')\n    await update(item, { status: 'queued', error: undefined, inDoubt: item.inDoubt })\n}\n\ntype Outcome =\n  | { kind: 'sent'; serverId?: string }\n  | { kind: 'offline' }\n  | { kind: 'failed'; error: string; inDoubt: boolean }\n\nconst IN_DOUBT_MESSAGE =\n  \"The mail server didn't confirm this message. It may already have been sent: check Sent before sending it again.\"\n\nfunction classify(error: unknown): Outcome {\n  // No answer at all: wait for the connection (the request may have arrived; the replay is safe).\n  if (isNetworkFailure(error)) return { kind: 'offline' }\n  const status = (error as { status?: number } | null)?.status\n  const detail = error instanceof Error ? error.message : 'The message could not be sent'\n  // Refused before any request left this device (e.g. the session must be signed in again).\n  if (status === undefined) return { kind: 'failed', error: detail, inDoubt: false }\n  if (status === 409) return { kind: 'failed', error: IN_DOUBT_MESSAGE, inDoubt: true }\n  if (status >= 500) return { kind: 'failed', error: IN_DOUBT_MESSAGE, inDoubt: true }\n  return { kind: 'failed', error: detail, inDoubt: false }\n}\n\n/** Prepare a secure message's encrypted request once, persisted before it is ever sent. */\nasync function prepared(item: OutboxItem, sender: OutboxSender): Promise<OutboxItem> {\n  if (!item.secure || item.securePayload !== undefined) return item\n  // Persist before the request: a replay must carry this exact ciphertext (the server\n  // fingerprints it), so it is never prepared a second time.\n  return update(item, { securePayload: await sender.prepareSecure(item) })\n}\n\nasync function attempt(item: OutboxItem, sender: OutboxSender): Promise<Outcome> {\n  try {\n    const result = await sender.send(item)\n    return { kind: 'sent', serverId: result?.id }\n  } catch (error) {\n    const outcome = classify(error)\n    // A session that hasn't been unlocked for this account yet: unlock once and replay.\n    if ((error as { status?: number }).status === 401) {\n      try {\n        await sender.unlock(item.account)\n        const result = await sender.send(item)\n        return { kind: 'sent', serverId: result?.id }\n      } catch (retryError) {\n        return classify(retryError)\n      }\n    }\n    return outcome\n  }\n}\n\nexport interface FlushResult {\n  sent: number\n  failed: number\n  /** Stopped early because the connection dropped; the rest stays queued. */\n  interrupted: boolean\n}\n\n/**\n * Send every queued message in order. Messages left \"sending\" by a closed tab are replayed with\n * their request_id. Stops (keeping order) when the network goes away; a failed message does not\n * hold back the ones after it.\n */\nexport async function flushOutboxOnce(\n  sender: OutboxSender,\n  isOnline: () => boolean\n): Promise<FlushResult> {\n  const result: FlushResult = { sent: 0, failed: 0, interrupted: false }\n  const unlocked = new Set<string>()\n  for (;;) {\n    if (!isOnline()) {\n      result.interrupted = true\n      break\n    }\n    const next = (await listOutbox()).find((i) => i.status === 'queued' || i.status === 'sending')\n    if (!next) break\n    let item = await update(next, { status: 'sending', attempts: next.attempts + 1 })\n    try {\n      item = await prepared(item, sender)\n    } catch (error) {\n      // Local preparation failed (nothing was sent): a refusal the user can fix and retry.\n      const message = error instanceof Error ? error.message : 'Could not encrypt the message'\n      await update(item, { status: 'failed', error: message })\n      result.failed++\n      continue\n    }\n    if (!unlocked.has(item.account.id)) {\n      // Connected accounts need this session's tokens; a failure here surfaces as the send's 401.\n      await sender.unlock(item.account).catch(() => {})\n      unlocked.add(item.account.id)\n    }\n    const outcome = await attempt(item, sender)\n    if (outcome.kind === 'sent') {\n      item = await update(item, {\n        status: 'sent',\n        sentAt: Date.now(),\n        error: undefined,\n        inDoubt: false,\n      })\n      result.sent++\n    } else if (outcome.kind === 'offline') {\n      await update(item, { status: 'queued' })\n      result.interrupted = true\n      break\n    } else {\n      await update(item, {\n        status: 'failed',\n        error: outcome.error,\n        inDoubt: item.inDoubt || outcome.inDoubt,\n      })\n      result.failed++\n    }\n  }\n  return result\n}\n\n/** Drop sent messages older than `olderThanMs` from the Outbox view. */\nexport async function purgeSentOutbox(olderThanMs = 0): Promise<void> {\n  const cutoff = Date.now() - olderThanMs\n  const done = (await listOutbox()).filter((i) => i.status === 'sent' && (i.sentAt ?? 0) <= cutoff)\n  if (done.length === 0) return\n  await deleteRecords(await Promise.all(done.map((i) => keyFor(i.id))))\n  notifyOfflineMailChange('outbox')\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mail/offline/reads.js

@@ -0,0 +1,159 @@
+import { onlineManager } from "@tanstack/react-query";
+import { logger } from "@arbidocs/client";
+import {
+  accountPath,
+  conversationsPath,
+  mailJson,
+  MailOfflineUnavailableError,
+  threadPath
+} from "../client.js";
+import { mailConversationKey, groupMailConversations } from "../threads.js";
+import {
+  hasFolder,
+  isVirtualFolder,
+  loadAccountMessages,
+  loadAccounts,
+  loadBody,
+  loadFolders,
+  loadPolicy,
+  saveAccounts,
+  saveBody,
+  saveFolders,
+  saveHeader,
+  savePolicy,
+  searchFolder
+} from "./mailbox.js";
+import { getOfflineMailSettings, inOfflineWindow } from "./settings.js";
+import { overlayPendingMailChanges } from "./changes.js";
+import { isNetworkFailure } from "../../offline-store/network.js";
+import { sessionUser } from "./live.js";
+const NOT_SAVED_HINT = "Choose how much mail to keep on this device in Mail settings to read it without a connection.";
+async function onlineFirst(online, offline, unavailable) {
+  if (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);
+}
+async function deviceMessages(account, folderId, query) {
+  if (!isVirtualFolder(await savedFolder(account.id, folderId)))
+    return searchFolder(account.id, folderId, query);
+  const inView = (f) => account.provider === "imap" ? f.role === "inbox" : f.role !== "trash";
+  const all = await loadAccountMessages(account.id, inView, query);
+  return all.filter((m) => m.flagged);
+}
+async function savedFolder(accountId, folderId) {
+  return (await loadFolders(accountId) ?? []).find((f) => f.id === folderId);
+}
+function offlineMailReads(getArbi, { keepsMail = () => true } = {}) {
+  const call = (path) => mailJson((p, i) => getArbi().mail.fetch(p, i), path);
+  const settings = () => getOfflineMailSettings(sessionUser(getArbi()));
+  const storeEnabled = () => settings().enabled;
+  const keeps = (message) => inOfflineWindow(settings(), message.received_at);
+  const remember = (write) => {
+    if (!keepsMail()) return;
+    write().catch((error) => logger.warn("[offline-mail] could not save for offline use", error));
+  };
+  return {
+    getPolicy: () => onlineFirst(
+      async () => {
+        const policy = await call("/policy");
+        if (policy.enabled) 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 () => {
+            if (isVirtualFolder(await savedFolder(account.id, folderId))) return;
+            for (const message of page.messages)
+              if (keeps(message)) await saveHeader(account.id, folderId, message);
+            await overlayPendingMailChanges();
+          });
+        return page;
+      },
+      async () => {
+        if (!await hasFolder(account.id)) return void 0;
+        return { messages: await deviceMessages(account, folderId, query), fromDevice: true };
+      },
+      `You're offline and this folder isn't saved on this device. ${NOT_SAVED_HINT}`
+    ),
+    listConversations: (account, folderId, query, cursor) => onlineFirst(
+      async () => {
+        const page = await call(
+          conversationsPath(account.id, folderId, query, cursor)
+        );
+        if (storeEnabled() && !query)
+          remember(async () => {
+            if (isVirtualFolder(await savedFolder(account.id, folderId))) return;
+            for (const conversation of page.conversations)
+              for (const message of conversation.messages)
+                if (keeps(message)) await saveHeader(account.id, folderId, message);
+            await overlayPendingMailChanges();
+          });
+        return page;
+      },
+      async () => {
+        if (!await hasFolder(account.id)) return void 0;
+        const messages = await deviceMessages(account, folderId, query);
+        return { conversations: groupMailConversations(messages), fromDevice: true };
+      },
+      `You're offline and this folder isn't saved on this device. ${NOT_SAVED_HINT}`
+    ),
+    getThread: (account, threadId, folderId) => onlineFirst(
+      () => call(threadPath(account.id, threadId, folderId)),
+      async () => {
+        if (!await hasFolder(account.id)) return void 0;
+        const trash = (await savedFolder(account.id, folderId))?.role === "trash";
+        const messages = (await loadAccountMessages(account.id, (f) => f.role === "trash" === trash)).filter((m) => mailConversationKey(m) === threadId);
+        if (!messages.length) return void 0;
+        return { thread_id: threadId, messages: messages.reverse(), fromDevice: true };
+      },
+      "You're offline and this conversation isn't saved on this device."
+    ),
+    getMessage: (account, messageId) => onlineFirst(
+      async () => {
+        const message = await call(
+          `${accountPath(account.id)}/messages/${encodeURIComponent(messageId)}`
+        );
+        if (keeps(message)) 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}`
+    )
+  };
+}
+export {
+  offlineMailReads
+};
+//# sourceMappingURL=reads.js.map

package/dist/mail/offline/reads.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mail/offline/reads.ts"],
+  "sourcesContent": ["/**\n * Mail reads that keep working offline.\n *\n * Online, each read goes to the server as before; the result is also written to the encrypted\n * offline store \u2014 accounts and policy always (tiny, and needed to compose and queue mail offline),\n * folders and messages only while mail is kept on this device, and only messages received within\n * the chosen window (the last 7 days by default), so browsing older mail online does not grow it.\n * Offline (or when the request can't reach the server), the same read is answered from the store,\n * and when the store has nothing for it the error says so plainly instead of loading forever.\n *\n * The Mail queries use networkMode 'always' with these functions, so they run offline instead of\n * pausing (a paused query would show its loading state indefinitely).\n */\n\nimport { onlineManager } from '@tanstack/react-query'\nimport type { Arbi } from '@arbidocs/sdk/browser'\nimport { logger } from '@arbidocs/client'\nimport {\n  accountPath,\n  conversationsPath,\n  mailJson,\n  MailOfflineUnavailableError,\n  threadPath,\n  type MailClient,\n} from '../client'\nimport type {\n  MailAccount,\n  MailConversationPage,\n  MailFolder,\n  MailMessage,\n  MailPage,\n  MailPolicy,\n  MailThread,\n} from '../types'\nimport { mailConversationKey, groupMailConversations } from '../threads'\nimport {\n  hasFolder,\n  isVirtualFolder,\n  loadAccountMessages,\n  loadAccounts,\n  loadBody,\n  loadFolders,\n  loadPolicy,\n  saveAccounts,\n  saveBody,\n  saveFolders,\n  saveHeader,\n  savePolicy,\n  searchFolder,\n} from './mailbox'\nimport { getOfflineMailSettings, inOfflineWindow } from './settings'\nimport { overlayPendingMailChanges } from './changes'\nimport { isNetworkFailure } from '../../offline-store/network'\nimport { sessionUser } from './live'\n\nconst NOT_SAVED_HINT =\n  'Choose how much mail to keep on this device in Mail settings to read it without a connection.'\n\nasync function onlineFirst<T>(\n  online: () => Promise<T>,\n  offline: () => Promise<T | undefined>,\n  unavailable: string\n): Promise<T> {\n  if (onlineManager.isOnline()) {\n    try {\n      return await online()\n    } catch (error) {\n      if (!isNetworkFailure(error)) throw error\n    }\n  }\n  const saved = await offline().catch(() => undefined)\n  if (saved !== undefined) return saved\n  throw new MailOfflineUnavailableError(unavailable)\n}\n\nexport interface OfflineMailReadsOptions {\n  /**\n   * Whether this device keeps mail at all (e.g. the person uses Mail): when it doesn't, reads are\n   * never written to the device. Default: it does.\n   */\n  keepsMail?: () => boolean\n}\n\ntype MailReads = Pick<\n  MailClient,\n  | 'getPolicy'\n  | 'listAccounts'\n  | 'listFolders'\n  | 'listMessages'\n  | 'listConversations'\n  | 'getThread'\n  | 'getMessage'\n>\n\n/**\n * A folder's messages saved on the device, newest first. Flagged is every folder's flagged mail but\n * the Trash's, as the server lists it.\n */\nasync function deviceMessages(account: MailAccount, folderId: string, query: string) {\n  if (!isVirtualFolder(await savedFolder(account.id, folderId)))\n    return searchFolder(account.id, folderId, query)\n  // As each server lists it: IMAP's Flagged is the Inbox's flagged mail (SEARCH FLAGGED there).\n  const inView = (f: MailFolder) =>\n    account.provider === 'imap' ? f.role === 'inbox' : f.role !== 'trash'\n  const all = await loadAccountMessages(account.id, inView, query)\n  return all.filter((m) => m.flagged)\n}\n\n/** The saved folder `folderId` (its role says whether it is the Trash, or a view like Flagged). */\nasync function savedFolder(accountId: string, folderId: string) {\n  return ((await loadFolders(accountId)) ?? []).find((f) => f.id === folderId)\n}\n\n/**\n * The mail client's reads, kept working offline, on the session `getArbi()` returns (read per call,\n * so a renewed session is used). Pass them to `createMailClient` as overrides.\n */\nexport function offlineMailReads(\n  getArbi: () => Arbi,\n  { keepsMail = () => true }: OfflineMailReadsOptions = {}\n): MailReads {\n  const call = <T>(path: string) => mailJson<T>((p, i) => getArbi().mail.fetch(p, i), path)\n  const settings = () => getOfflineMailSettings(sessionUser(getArbi()))\n  const storeEnabled = () => settings().enabled\n  const keeps = (message: MailMessage) => inOfflineWindow(settings(), message.received_at)\n  /** Write-through that never fails the read it piggybacks on. */\n  const remember = (write: () => Promise<void>): void => {\n    // Only for people who use Mail: everyone else never gets an offline mail store on their device.\n    if (!keepsMail()) return\n    write().catch((error) => logger.warn('[offline-mail] could not save for offline use', error))\n  }\n  return {\n    getPolicy: () =>\n      onlineFirst(\n        async () => {\n          const policy = await call<MailPolicy>('/policy')\n          // Mail switched off on the deployment: nothing goes on the device.\n          if (policy.enabled) remember(() => savePolicy(policy))\n          return policy\n        },\n        loadPolicy,\n        \"You're offline. Mail opens here once you've used it online on this device.\"\n      ),\n    listAccounts: () =>\n      onlineFirst(\n        async () => {\n          const accounts = await call<MailAccount[]>('/accounts')\n          remember(() => saveAccounts(accounts))\n          return accounts\n        },\n        loadAccounts,\n        \"You're offline. Your mail accounts appear here once you've opened Mail online on this device.\"\n      ),\n    listFolders: (account) =>\n      onlineFirst(\n        async () => {\n          const folders = await call<MailFolder[]>(`${accountPath(account.id)}/folders`)\n          if (storeEnabled()) remember(() => saveFolders(account.id, folders))\n          return folders\n        },\n        () => loadFolders(account.id),\n        `You're offline and this mailbox isn't saved on this device. ${NOT_SAVED_HINT}`\n      ),\n    listMessages: (account, folderId, query, cursor) =>\n      onlineFirst<MailPage>(\n        async () => {\n          const page = await call<MailPage>(\n            `${accountPath(account.id)}/messages?${new URLSearchParams({ folder_id: folderId, q: query, ...(cursor ? { cursor } : {}) })}`\n          )\n          // Search results are a subset; only the unfiltered folder list is a faithful copy.\n          if (storeEnabled() && !query)\n            remember(async () => {\n              if (isVirtualFolder(await savedFolder(account.id, folderId))) return\n              for (const message of page.messages)\n                if (keeps(message)) await saveHeader(account.id, folderId, message)\n              // A change still waiting must not be undone by the server's state just written.\n              await overlayPendingMailChanges()\n            })\n          return page\n        },\n        async () => {\n          if (!(await hasFolder(account.id))) return undefined\n          return { messages: await deviceMessages(account, folderId, query), fromDevice: true }\n        },\n        `You're offline and this folder isn't saved on this device. ${NOT_SAVED_HINT}`\n      ),\n    listConversations: (account, folderId, query, cursor) =>\n      onlineFirst<MailConversationPage>(\n        async () => {\n          const page = await call<MailConversationPage>(\n            conversationsPath(account.id, folderId, query, cursor)\n          )\n          // As the message list: only an unfiltered real folder is a faithful copy of its rows.\n          if (storeEnabled() && !query)\n            remember(async () => {\n              if (isVirtualFolder(await savedFolder(account.id, folderId))) return\n              for (const conversation of page.conversations)\n                for (const message of conversation.messages)\n                  if (keeps(message)) await saveHeader(account.id, folderId, message)\n              await overlayPendingMailChanges()\n            })\n          return page\n        },\n        async () => {\n          if (!(await hasFolder(account.id))) return undefined\n          const messages = await deviceMessages(account, folderId, query)\n          return { conversations: groupMailConversations(messages), fromDevice: true }\n        },\n        `You're offline and this folder isn't saved on this device. ${NOT_SAVED_HINT}`\n      ),\n    getThread: (account, threadId, folderId) =>\n      onlineFirst<MailThread>(\n        () => call<MailThread>(threadPath(account.id, threadId, folderId)),\n        async () => {\n          if (!(await hasFolder(account.id))) return undefined\n          // Across folders but the Trash, unless it is the Trash being read: as the server does.\n          const trash = (await savedFolder(account.id, folderId))?.role === 'trash'\n          const messages = (\n            await loadAccountMessages(account.id, (f) => (f.role === 'trash') === trash)\n          ).filter((m) => mailConversationKey(m) === threadId)\n          if (!messages.length) return undefined\n          return { thread_id: threadId, messages: messages.reverse(), fromDevice: true }\n        },\n        \"You're offline and this conversation isn't saved on this device.\"\n      ),\n    getMessage: (account, messageId) =>\n      onlineFirst(\n        async () => {\n          const message = await call<MailMessage>(\n            `${accountPath(account.id)}/messages/${encodeURIComponent(messageId)}`\n          )\n          if (keeps(message)) remember(() => saveBody(account.id, message))\n          return message\n        },\n        () => loadBody(account.id, messageId),\n        storeEnabled()\n          ? \"You're offline and this message hasn't been saved on this device yet.\"\n          : `You're offline. ${NOT_SAVED_HINT}`\n      ),\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mail/offline/runtime.js

@@ -0,0 +1,100 @@
+import { useEffect, useRef } from "react";
+import { onlineManager, useQueryClient } from "@tanstack/react-query";
+import { logger } from "@arbidocs/client";
+import { useArbi } from "../../useArbi.js";
+import { useFeature } from "../../host/features.js";
+import { useIsEntitled } from "../../account/entitlements.js";
+import { isUnderQueryKey } from "../../query-keys.js";
+import { useArbiSession } from "../../session/signed-in.js";
+import { mailQueryKeys, useMailPolicy } from "../hooks.js";
+import {
+  flushOutbox,
+  sessionUser,
+  syncOfflineMailbox,
+  uploadOfflineDrafts
+} from "./live.js";
+import { getOfflineMailSettings, onOfflineMailChange } from "./settings.js";
+import { trimOfflineMailbox } from "./sync.js";
+import { claimOfflineMail } from "./wipe.js";
+const SYNC_INTERVAL_MS = 5 * 60 * 1e3;
+const NEW_MAIL_DEBOUNCE_MS = 5e3;
+function useOfflineMailActive() {
+  const { user, status } = useArbiSession();
+  const mailEnabled = useFeature("mail");
+  const entitled = useIsEntitled("mail");
+  const eligible = status === "signed-in" && !!user?.external_id && mailEnabled && entitled;
+  const { data: policy } = useMailPolicy({ enabled: eligible });
+  return eligible && !!policy?.enabled && (policy.native_enabled || policy.enabled_providers.length > 0);
+}
+function useOfflineMailRuntime({ openOutbox } = {}) {
+  const { user, serverSessionKey } = useArbiSession();
+  const userExtId = user?.external_id;
+  const hasSession = !!serverSessionKey;
+  const active = useOfflineMailActive();
+  const queryClient = useQueryClient();
+  const arbi = useArbi();
+  const latest = useRef({ arbi, queryClient, openOutbox });
+  latest.current = { arbi, queryClient, openOutbox };
+  useEffect(() => {
+    if (!active || !userExtId) return;
+    claimOfflineMail(userExtId).catch(
+      (error) => logger.warn("[offline-mail] could not bind the store", error)
+    );
+  }, [active, userExtId]);
+  useEffect(() => {
+    if (!active || !userExtId) return;
+    return onOfflineMailChange((change) => {
+      if (change !== "settings") return;
+      trimOfflineMailbox(getOfflineMailSettings(userExtId)).then(
+        () => latest.current.queryClient.invalidateQueries({ queryKey: mailQueryKeys.allMessages() })
+      ).catch((error) => logger.warn("[offline-mail] could not trim the device copy", error));
+    });
+  }, [active, userExtId]);
+  useEffect(() => {
+    if (!active || !hasSession) return;
+    const context = () => latest.current;
+    const catchUp = async () => {
+      await flushOutbox(context());
+      await uploadOfflineDrafts(context());
+      await syncOfflineMailbox(context());
+    };
+    const run = () => {
+      catchUp().catch((error) => logger.warn("[offline-mail] catch-up failed", error));
+    };
+    run();
+    let wasOnline = onlineManager.isOnline();
+    const offOnline = onlineManager.subscribe((online) => {
+      if (online && !wasOnline) run();
+      wasOnline = online;
+    });
+    const interval = setInterval(() => {
+      if (document.visibilityState === "visible") run();
+    }, 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 (!isUnderQueryKey(event.query.queryKey, 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 === "changes") void flushOutbox(context());
+      if (change === "drafts") void uploadOfflineDrafts(context());
+    });
+    return () => {
+      offOnline();
+      clearInterval(interval);
+      if (newMailTimer) clearTimeout(newMailTimer);
+      offCache();
+      offSettings();
+    };
+  }, [active, hasSession, queryClient]);
+}
+export {
+  useOfflineMailActive,
+  useOfflineMailRuntime
+};
+//# sourceMappingURL=runtime.js.map

package/dist/mail/offline/runtime.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mail/offline/runtime.ts"],
+  "sourcesContent": ["/**\n * useOfflineMailRuntime \u2014 mounted once by the host for a signed-in user with Mail switched on.\n * Wherever the user is in the app, it:\n *  - binds the offline mail store to this account (another account's data on the device is removed);\n *  - on reconnect (and at start, when online): sends the Outbox, applies the changes made offline\n *    (read, moved, trashed, deleted), uploads offline drafts, then syncs the offline mailbox if it\n *    is on for this device. Nothing goes out while the person chose \"Work offline\": that turns the\n *    app's online state off, and every runner checks it before each request;\n *  - keeps the mailbox in sync while online: every few minutes and shortly after new mail arrives\n *    (the server's mail notification refreshes the Mail queries; that is the cue);\n *  - when the user changes how much mail is kept, trims the device copy to it at once (offline too)\n *    and, online, syncs fully so a longer window fills in.\n */\n\nimport { useEffect, useRef } from 'react'\nimport { onlineManager, useQueryClient } from '@tanstack/react-query'\nimport { logger } from '@arbidocs/client'\nimport { useArbi } from '../../useArbi'\nimport { useFeature } from '../../host/features'\nimport { useIsEntitled } from '../../account/entitlements'\nimport { isUnderQueryKey } from '../../query-keys'\nimport { useArbiSession } from '../../session/signed-in'\nimport { mailQueryKeys, useMailPolicy } from '../hooks'\nimport {\n  flushOutbox,\n  sessionUser,\n  syncOfflineMailbox,\n  uploadOfflineDrafts,\n  type OfflineMailContext,\n} from './live'\nimport { getOfflineMailSettings, onOfflineMailChange } from './settings'\nimport { trimOfflineMailbox } from './sync'\nimport { claimOfflineMail } from './wipe'\n\nconst SYNC_INTERVAL_MS = 5 * 60 * 1000\nconst NEW_MAIL_DEBOUNCE_MS = 5_000\n\nexport interface OfflineMailRuntimeOptions {\n  /** Show the Outbox, offered on the notice that a queued message could not be sent. */\n  openOutbox?: () => void\n}\n\n/**\n * Whether mail is kept on this device for the signed-in user: Mail switched on for them, their plan\n * includes it, and the deployment offers mail (its native inbox or a mail provider). Entitlement\n * alone is not enough: it is granted wherever billing is off, mail or not. Nothing runs, and no\n * store is made, while this is false.\n */\nexport function useOfflineMailActive(): boolean {\n  const { user, status } = useArbiSession()\n  const mailEnabled = useFeature('mail')\n  const entitled = useIsEntitled('mail')\n  const eligible = status === 'signed-in' && !!user?.external_id && mailEnabled && entitled\n  const { data: policy } = useMailPolicy({ enabled: eligible })\n  return (\n    eligible && !!policy?.enabled && (policy.native_enabled || policy.enabled_providers.length > 0)\n  )\n}\n\nexport function useOfflineMailRuntime({ openOutbox }: OfflineMailRuntimeOptions = {}): void {\n  const { user, serverSessionKey } = useArbiSession()\n  const userExtId = user?.external_id\n  const hasSession = !!serverSessionKey\n  const active = useOfflineMailActive()\n  const queryClient = useQueryClient()\n  // A new `Arbi` (another workspace opened) is the same session: each run reads the current one.\n  const arbi = useArbi()\n  const latest = useRef<OfflineMailContext>({ arbi, queryClient, openOutbox })\n  latest.current = { arbi, queryClient, openOutbox }\n\n  useEffect(() => {\n    if (!active || !userExtId) return\n    claimOfflineMail(userExtId).catch((error) =>\n      logger.warn('[offline-mail] could not bind the store', error)\n    )\n  }, [active, userExtId])\n\n  // A shorter window (or Off) applies at once, with no network or session keys: only plaintext\n  // receive times are read.\n  useEffect(() => {\n    if (!active || !userExtId) return\n    return onOfflineMailChange((change) => {\n      if (change !== 'settings') return\n      trimOfflineMailbox(getOfflineMailSettings(userExtId))\n        // Offline the lists come from the device: show what is left.\n        .then(() =>\n          latest.current.queryClient.invalidateQueries({ queryKey: mailQueryKeys.allMessages() })\n        )\n        .catch((error) => logger.warn('[offline-mail] could not trim the device copy', error))\n    })\n  }, [active, userExtId])\n\n  useEffect(() => {\n    if (!active || !hasSession) return\n    const context = () => latest.current\n    const catchUp = async () => {\n      await flushOutbox(context())\n      await uploadOfflineDrafts(context())\n      await syncOfflineMailbox(context())\n    }\n    const run = () => {\n      catchUp().catch((error) => logger.warn('[offline-mail] catch-up failed', error))\n    }\n    run()\n    let wasOnline = onlineManager.isOnline()\n    const offOnline = onlineManager.subscribe((online) => {\n      if (online && !wasOnline) run()\n      wasOnline = online\n    })\n    // What waits (an Outbox message or a change whose request got no answer while online) is tried\n    // again with each regular sync, not only on reconnect.\n    const interval = setInterval(() => {\n      if (document.visibilityState === 'visible') run()\n    }, SYNC_INTERVAL_MS)\n    const enabled = () => getOfflineMailSettings(sessionUser(context().arbi)).enabled\n    let newMailTimer: ReturnType<typeof setTimeout> | null = null\n    const offCache = queryClient.getQueryCache().subscribe((event) => {\n      if (event.type !== 'updated' || event.action.type !== 'invalidate') return\n      if (!isUnderQueryKey(event.query.queryKey, mailQueryKeys.all()) || !enabled()) return\n      if (newMailTimer) clearTimeout(newMailTimer)\n      newMailTimer = setTimeout(() => void syncOfflineMailbox(context()), NEW_MAIL_DEBOUNCE_MS)\n    })\n    const offSettings = onOfflineMailChange((change) => {\n      if (change === 'settings' && enabled()) void syncOfflineMailbox(context(), { full: true })\n      if (change === 'outbox') void flushOutbox(context())\n      if (change === 'changes') void flushOutbox(context())\n      if (change === 'drafts') void uploadOfflineDrafts(context())\n    })\n    return () => {\n      offOnline()\n      clearInterval(interval)\n      if (newMailTimer) clearTimeout(newMailTimer)\n      offCache()\n      offSettings()\n    }\n  }, [active, hasSession, queryClient])\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mail/offline/settings.js

@@ -0,0 +1,84 @@
+const DEFAULT_OFFLINE_MAIL_SETTINGS = {
+  enabled: true,
+  scope: "7d",
+  attachmentCapMb: 25,
+  quotaMb: 1024
+};
+const SCOPE_DAYS = {
+  "1d": 1,
+  "7d": 7,
+  "30d": 30,
+  "90d": 90
+};
+const DAY_MS = 24 * 60 * 60 * 1e3;
+function offlineWindowStart(settings, now = Date.now()) {
+  return now - SCOPE_DAYS[settings.scope] * DAY_MS;
+}
+function inOfflineWindow(settings, receivedAt, now = Date.now()) {
+  const at = receivedAt ? Date.parse(receivedAt) || 0 : 0;
+  return settings.enabled && (!at || at >= offlineWindowStart(settings, now));
+}
+function normalize(saved) {
+  const merged = { ...DEFAULT_OFFLINE_MAIL_SETTINGS, ...saved };
+  const scope = merged.scope;
+  if (scope in SCOPE_DAYS) return merged;
+  const longer = scope === "365d" || scope === "all";
+  return { ...merged, scope: longer ? "90d" : DEFAULT_OFFLINE_MAIL_SETTINGS.scope };
+}
+const STORAGE_PREFIX = "arbi-offline-mail-settings:";
+const SIGNED_OUT = { ...DEFAULT_OFFLINE_MAIL_SETTINGS, enabled: false };
+function getOfflineMailSettings(userExtId) {
+  if (!userExtId) return SIGNED_OUT;
+  const key = STORAGE_PREFIX + userExtId;
+  try {
+    const raw = localStorage.getItem(key);
+    return raw ? normalize(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;
+}
+const listeners = /* @__PURE__ */ new Set();
+const CHANNEL = "arbi-offline-mail";
+let 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);
+}
+export {
+  DEFAULT_OFFLINE_MAIL_SETTINGS,
+  SCOPE_DAYS,
+  getOfflineMailSettings,
+  inOfflineWindow,
+  notifyOfflineMailChange,
+  offlineWindowStart,
+  onOfflineMailChange,
+  setOfflineMailSettings
+};
+//# sourceMappingURL=settings.js.map