@athenaintel/react 0.54.0 → 0.55.0

package/dist/agent-runtime/src/offline-status.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"offline-status.cjs","sources":["../../../../agent-runtime/src/offline-status.ts"],"sourcesContent":["/**\n * Athena's offline language: the one set of states and words every app uses to\n * say where the person stands when the network, or Athena, is out of reach —\n * Olympus, the desktop app, the phone app, the Chrome extension and the Office\n * add-in.\n *\n * The rule the words follow: say what still works before what doesn't. Work\n * done while Athena can't be reached is kept on the device and syncs when\n * Athena is back, so every message leads with that promise. Nothing here is\n * shown while Athena answers and nothing waits; the \"back\" messages are brief.\n *\n * Pure strings and small functions, no UI library: each app draws them its own\n * way (a banner, a header chip, a tooltip, a sheet). Reachability itself is\n * each app's own (the browser's or OS's online flag AND agora answering its\n * health read); this module only names the result.\n */\n\n/** Where the app stands with Athena. */\nexport type ConnectionState =\n  /** Athena answers. Nothing is shown. */\n  | 'online'\n  /** The device has no network. */\n  | 'offline'\n  /** The network is up but Athena doesn't answer. */\n  | 'unreachable'\n  /** Athena answers again and what waited is being sent. */\n  | 'reconnecting'\n  /** Just back, and everything that waited was sent. Shown briefly. */\n  | 'synced';\n\n/** Where one document's edits stand, for the chip in its header. */\nexport type DocumentSyncState =\n  /** In Athena. */\n  | 'saved'\n  /** Being sent to Athena. */\n  | 'saving'\n  /** Kept on this device while Athena can't be reached; syncs when it is back. */\n  | 'on-device'\n  /** Kept only while this tab or app stays open (no device storage); syncs when Athena is back. */\n  | 'in-memory'\n  /** Sending what was kept on this device. */\n  | 'syncing'\n  /** Some changes overlap with Athena's version: the person chooses. */\n  | 'needs-review'\n  /** The document can no longer take these edits (access or state changed): kept, not sent. */\n  | 'view-only'\n  /**\n   * Athena answers but isn't taking this document's changes for now: it holds the document while it\n   * repairs it, or hasn't confirmed the latest changes for longer than usual (`SavingDelayCause`\n   * says which). Kept, and saved once Athena takes them. Never said while Athena can't be reached:\n   * that is `on-device` or `in-memory`.\n   */\n  | 'delayed';\n\n/** Why a document's saving is delayed while Athena answers (`DocumentSyncState` `delayed`). */\nexport type SavingDelayCause =\n  /** Athena holds the document while it repairs it, and takes no changes to it until then. */\n  | 'repairing'\n  /** Athena hasn't confirmed the latest changes for longer than usual. */\n  | 'unconfirmed';\n\n/** How a sentence names the device the person is on. */\nexport type DeviceNoun =\n  | 'this browser'\n  | 'this Mac'\n  | 'this computer'\n  | 'this phone'\n  | 'this tablet'\n  | 'this device';\n\n/**\n * What the app really keeps of work done while Athena can't be reached, so the\n * words never promise more: `device` (stored on the device, survives closing),\n * `memory` (kept only while this tab or app stays open: a tenant that turns\n * device copies off, or storage the app can't open), `none` (a surface that\n * keeps no work offline at all, like the Chrome side panel).\n */\nexport type OfflineKeeping = 'device' | 'memory' | 'none';\n\n/** A title and the one line under it (a banner, a sheet, a tooltip's heading). */\nexport interface StatusCopy {\n  title: string;\n  detail: string;\n}\n\n/** A short label for a chip or a disabled control, and its one-line explanation. */\nexport interface LabelCopy {\n  label: string;\n  detail: string;\n}\n\nfunction plural(count: number, one: string, many: string): string {\n  return `${count} ${count === 1 ? one : many}`;\n}\n\n/** What a tab or an app is called when work lasts only while it stays open. */\nfunction openContainer(device: DeviceNoun): string {\n  return device === 'this browser' ? 'this tab' : 'the app';\n}\n\n/** The promise after \"You're offline\" / \"Can't reach Athena\", honest to what is kept. */\nfunction keepingPromise({\n  keeping,\n  device,\n  when,\n}: {\n  keeping: OfflineKeeping;\n  device: DeviceNoun;\n  when: string;\n}): string {\n  switch (keeping) {\n    case 'device':\n      return `You can keep working. Changes are saved on ${device} and sync ${when}.`;\n    case 'memory':\n      return `You can keep working, but changes are kept only until you close ${openContainer(device)}. They sync ${when}.`;\n    case 'none':\n      return `You’re still signed in. This reconnects ${when}.`;\n  }\n}\n\n/**\n * The app-wide status line, or `null` while Athena answers and nothing waits.\n * `waiting` counts changes not in Athena yet: while `reconnecting` they are\n * being sent; while `online` they wait for something else (a copy that sends\n * when it is next opened), and the line stays until they are gone.\n * `keeping` is what the app really keeps offline (default `device`). A surface\n * that keeps nothing (`none`) has nothing to sync, so its way back is only\n * \"Back online\", never \"Syncing…\" or \"All changes synced\".\n */\nexport function connectionCopy({\n  state,\n  device,\n  waiting = 0,\n  keeping = 'device',\n}: {\n  state: ConnectionState;\n  device: DeviceNoun;\n  waiting?: number;\n  keeping?: OfflineKeeping;\n}): StatusCopy | null {\n  switch (state) {\n    case 'online':\n      return waiting > 0\n        ? {\n            title: 'Not synced yet',\n            detail: `${plural(waiting, 'change', 'changes')} on ${device} ${waiting === 1 ? 'hasn’t' : 'haven’t'} synced yet.`,\n          }\n        : null;\n    case 'offline':\n      return {\n        title: 'You’re offline',\n        detail: keepingPromise({ keeping, device, when: 'when you’re back online' }),\n      };\n    case 'unreachable':\n      return {\n        title: 'Can’t reach Athena',\n        detail: keepingPromise({ keeping, device, when: 'when Athena is back' }),\n      };\n    case 'reconnecting':\n      if (keeping === 'none') return { title: 'Back online', detail: '' };\n      return {\n        title: 'Back online',\n        detail:\n          waiting > 0 ? `Syncing ${plural(waiting, 'change', 'changes')}…` : 'Syncing…',\n      };\n    case 'synced':\n      return keeping === 'none'\n        ? { title: 'Back online', detail: '' }\n        : { title: 'All changes synced', detail: '' };\n  }\n}\n\n/**\n * The line under \"Saving delayed\": why saving waits, and what is kept meanwhile, never promising\n * more than the app keeps.\n */\nfunction savingDelayedDetail({\n  delay,\n  keeping,\n  device,\n}: {\n  delay: SavingDelayCause;\n  keeping: Exclude<OfflineKeeping, 'none'>;\n  device: DeviceNoun;\n}): string {\n  if (delay === 'repairing') {\n    return keeping === 'memory'\n      ? `You can keep working, but your changes are kept only until you close ${openContainer(device)}. They save once Athena finishes repairing this document.`\n      : `You can keep working. Your changes are kept on ${device} and save once Athena finishes repairing this document.`;\n  }\n  return keeping === 'memory'\n    ? `Athena is taking longer than usual to save your latest changes. They’re kept only until you close ${openContainer(device)}, so keep it open.`\n    : `Athena is taking longer than usual to save your latest changes. They’re kept on ${device} in the meantime.`;\n}\n\n/**\n * The chip in a document's header, and the line it explains itself with. For `delayed`, `delay`\n * says why (default `unconfirmed`) and `keeping` whether the changes are kept on the device or only\n * while the tab or app stays open (default `device`); every other state ignores both.\n */\nexport function documentSyncCopy({\n  state,\n  device,\n  delay = 'unconfirmed',\n  keeping = 'device',\n}: {\n  state: DocumentSyncState;\n  device: DeviceNoun;\n  delay?: SavingDelayCause;\n  keeping?: Exclude<OfflineKeeping, 'none'>;\n}): LabelCopy {\n  switch (state) {\n    case 'saved':\n      return { label: 'Saved', detail: 'Saved to Athena.' };\n    case 'saving':\n      return { label: 'Saving…', detail: 'Saving to Athena.' };\n    case 'on-device':\n      return {\n        label: `Saved on ${device}`,\n        detail: `Saved on ${device}. Your changes sync when Athena is back.`,\n      };\n    case 'in-memory':\n      return {\n        label: 'Not saved yet',\n        detail: `Your changes are kept only until you close ${openContainer(device)}, and save when Athena is back.`,\n      };\n    case 'syncing':\n      return { label: 'Syncing…', detail: `Sending the changes saved on ${device}.` };\n    case 'needs-review':\n      return {\n        label: 'Review changes',\n        detail: 'Some of your changes overlap with changes made in Athena. Choose what to keep.',\n      };\n    case 'view-only':\n      return {\n        label: 'View only',\n        detail: `You can’t edit this anymore. Your changes stay on ${device}.`,\n      };\n    case 'delayed':\n      return { label: 'Saving delayed', detail: savingDelayedDetail({ delay, keeping, device }) };\n  }\n}\n\n/**\n * How long a document's edits may wait unconfirmed on a connection that is up before its saving\n * reads as delayed (`delayed`, `unconfirmed`), and before its room asks Keryx why: the stall window\n * every editor shares (`ACK_STALL_MS` in `@athenaintel/asset-host/local-updates`, which Olympus's\n * `room-sync-store.test.ts` holds equal).\n */\nexport const UNCONFIRMED_EDITS_STALL_MS = 15_000;\n\n/**\n * Whether a document's saving is delayed, and why (`DocumentSyncState` `delayed`): only while Athena\n * answers and the document's room is connected; `repairing` when Keryx refuses the room's writes\n * (quarantined while it is repaired: said at once, before anything waits), `unconfirmed` once its\n * edits have stayed unconfirmed past {@link UNCONFIRMED_EDITS_STALL_MS}; `null` otherwise. Every\n * app's chip asks it after a hold and after edits kept without a connection, and ahead of syncing\n * and saving, so a room that refuses writes never spins and being offline is never a delay.\n */\nexport function savingDelayCause({\n  reachable,\n  connected,\n  writesRefused,\n  unconfirmedStalled,\n}: {\n  /** Athena answers (the app's reachability, never the socket alone). */\n  reachable: boolean;\n  /** The document's room is connected. */\n  connected: boolean;\n  /** Keryx's document status says the room takes no writes for now. */\n  writesRefused: boolean;\n  /** Local edits have waited unconfirmed past the stall window on this connection. */\n  unconfirmedStalled: boolean;\n}): SavingDelayCause | null {\n  if (!reachable || !connected) return null;\n  if (writesRefused) return 'repairing';\n  return unconfirmedStalled ? 'unconfirmed' : null;\n}\n\n/** When something that needs Athena works again (the second half of `NEEDS_CONNECTION`'s line). */\nconst AVAILABLE_AGAIN = 'It’s available again when you’re back online.';\n\n/**\n * The reason on a control that needs Athena (share, run, upload, invite…),\n * shown disabled while Athena can't be reached rather than failing when used.\n */\nexport const NEEDS_CONNECTION: LabelCopy = {\n  label: 'Needs a connection',\n  detail: `This needs Athena. ${AVAILABLE_AGAIN}`,\n};\n\n/** What a composer was given to attach: a photo (from the phone's library or camera) or any file. */\nexport type AttachmentKind = 'photo' | 'file';\n\n/**\n * What a composer says when a photo or file is picked, pasted or dropped while\n * Athena can't be reached. It isn't attached: only Athena can take the upload.\n * In a chat whose messages wait to be sent meanwhile (`messagesWait`: the chat\n * keeps an outbox), the message itself still goes, so that comes first. Where\n * nothing waits (the Chrome side panel, a launcher that keeps its draft), it\n * says only when attaching works again, as `NEEDS_CONNECTION` does.\n */\nexport function attachmentNeedsConnection({\n  kind,\n  messagesWait,\n}: {\n  kind: AttachmentKind;\n  messagesWait: boolean;\n}): string {\n  const attaching = `Attaching ${kind === 'photo' ? 'a photo' : 'a file'} needs Athena. ${AVAILABLE_AGAIN}`;\n  return messagesWait\n    ? `You can still send your message: it goes when Athena is back. ${attaching}`\n    : attaching;\n}\n\n/** What a sent message carries besides its text that can't wait for Athena. */\nfunction heldExtras(withQuote: boolean): string {\n  return withQuote ? 'an attachment or a quote' : 'an attachment';\n}\n\n/**\n * What a composer says when a message is sent while Athena can't be reached\n * with an attachment that never reached Athena (or, `withQuote`, a quote the\n * chat can't keep waiting). Its text could wait in the chat outbox; the\n * attachment can't, so the draft stays as it is.\n */\nexport function attachedMessageNeedsConnection({\n  withQuote = false,\n}: {\n  withQuote?: boolean;\n} = {}): string {\n  return `Your text can wait and go when Athena is back, but ${heldExtras(withQuote)} can’t. Remove ${\n    withQuote ? 'it' : 'the attachment'\n  } to send the text.`;\n}\n\n/**\n * What a composer says when a message with an attachment (or, `withQuote`, a\n * quote) is sent while messages written when Athena couldn't be reached still\n * wait to go: those go first, and this one can't wait behind them.\n */\nexport function attachedMessageBehindWaiting({\n  withQuote = false,\n}: {\n  withQuote?: boolean;\n} = {}): string {\n  return `Messages you wrote while Athena couldn’t be reached go first. A message with ${heldExtras(\n    withQuote\n  )} can’t wait behind them, so send it once they’ve gone.`;\n}\n\n/**\n * The reason on New Presentation while Athena can't be reached, in a workspace\n * whose new presentations start from its design system's template: a\n * presentation made offline starts blank, and only Athena can copy the\n * template, so none is made until it can.\n */\nexport const NEW_PRESENTATION_NEEDS_TEMPLATE: LabelCopy = {\n  label: 'Needs a connection',\n  detail:\n    'New presentations in this workspace start from its design template, which needs Athena. You can make one when you’re back online.',\n};\n\n/**\n * What a download of a spreadsheet made from an Excel Macro-Enabled Workbook\n * (`.xlsm`) says when it went without the macros because they come from Athena,\n * which can't be reached, and the device hasn't kept them (they travel with the\n * workbook and never run). The file is the workbook without them; downloading\n * it again with a connection keeps them.\n */\nexport function downloadedWithoutMacros({ device }: { device: DeviceNoun }): string {\n  return `Downloaded without the spreadsheet’s macros: they come from Athena, which can’t be reached, and ${device} hasn’t kept them. Download it again when you’re back online to keep them.`;\n}\n\n/**\n * Save's question for a spreadsheet whose file is an Excel Macro-Enabled\n * Workbook (`.xlsm`) while its macros come from Athena, which can't be reached,\n * and the device hasn't kept them: the `.xlsm` is never written without them,\n * so the person may save an Excel Workbook (`.xlsx`) beside it, and Save writes\n * the `.xlsm` again once Athena answers.\n */\nexport function macrosNeedConnectionToSave({\n  name,\n  device,\n}: {\n  name: string;\n  device: DeviceNoun;\n}): StatusCopy {\n  return {\n    title: `Athena can’t save the macros in “${name}” right now.`,\n    detail: `They come from Athena, which can’t be reached, and ${device} hasn’t kept them. Save it as an Excel Workbook (.xlsx) instead. “${name}” stays as it is, macros included, and Save writes it again when you’re back online.`,\n  };\n}\n\n/**\n * What saving a version kept on the device as a new spreadsheet says when the\n * spreadsheet was made from an Excel Macro-Enabled Workbook (`.xlsm`) and\n * Athena can't be reached: the new spreadsheet is made all the same (on the\n * device, and it syncs when Athena is back), but without the macros, which only\n * Athena can keep with a new spreadsheet (they travel with the workbook and\n * never run). The kept version stays on the device, so saving it again with a\n * connection keeps them.\n */\nexport function savedAsNewWithoutMacros({ device }: { device: DeviceNoun }): string {\n  return `The new spreadsheet was made without the macros: only Athena can keep them in a new spreadsheet, and it can’t be reached. The kept version stays on ${device}: save it as a new spreadsheet again when you’re back online to keep them.`;\n}\n\n/**\n * Whether an item opens without a connection on this device, for lists.\n * `canKeep` says whether opening it online would keep a copy here (the\n * deployment allows device copies and the item's type is one that is kept):\n * only then is the person told to open it once.\n */\nexport function offlineAvailabilityCopy({\n  available,\n  canKeep,\n  device,\n}: {\n  available: boolean;\n  canKeep: boolean;\n  device: DeviceNoun;\n}): LabelCopy {\n  if (available) {\n    return { label: 'Available offline', detail: `Opens without a connection on ${device}.` };\n  }\n  return canKeep\n    ? {\n        label: 'Not available offline',\n        detail: `Open it once while online to keep it on ${device}.`,\n      }\n    : { label: 'Not available offline', detail: 'This opens only with a connection.' };\n}\n\n/**\n * The one-time explainer shown the first time the person goes offline, on a\n * surface that keeps work there (`keeping` `device`). A surface that keeps\n * nothing (`none`: the Chrome side panel, the Office task pane) shows no\n * explainer; its status line already says all that holds.\n */\nexport function firstOfflineExplainer({ device }: { device: DeviceNoun }): StatusCopy & {\n  action: string;\n} {\n  return {\n    title: 'You can keep working offline',\n    detail: `Documents you’ve opened recently keep working on ${device}. Your changes sync when you’re back online.`,\n    action: 'Got it',\n  };\n}\n\n/**\n * The summary heading of the one \"Waiting to sync\" list, from what waits on\n * the device; `null` when nothing does.\n */\nexport function waitingSummary({\n  changes = 0,\n  messages = 0,\n  recordings = 0,\n}: {\n  changes?: number;\n  messages?: number;\n  recordings?: number;\n}): string | null {\n  const parts = [\n    changes > 0 ? plural(changes, 'change', 'changes') : null,\n    messages > 0 ? plural(messages, 'message', 'messages') : null,\n    recordings > 0 ? plural(recordings, 'recording', 'recordings') : null,\n  ].filter((part): part is string => part !== null);\n  return parts.length === 0 ? null : `Waiting to sync: ${parts.join(', ')}`;\n}\n\n/**\n * Where one item in the \"Waiting to sync\" list stands: a change, a message or a\n * recording made while Athena couldn't be reached.\n */\nexport type WaitingItemState =\n  /** Saved on the device; it syncs when Athena is back. */\n  | 'waiting'\n  /** Being sent to Athena now. */\n  | 'syncing'\n  /**\n   * Kept only while this tab or app stays open: it couldn't be saved on the\n   * device (the organization keeps nothing on devices, or storage failed).\n   */\n  | 'in-memory'\n  /**\n   * Saved on the device in something that isn't open (a document closed before\n   * its edits synced, one made offline): it syncs when it is next opened with a\n   * connection (opening it offline sends nothing).\n   */\n  | 'when-opened'\n  /** Made in another workspace: it syncs once that workspace is open again, with a connection. */\n  | 'other-workspace'\n  /** It doesn't go on its own: the person chooses (a message that waited more than a day). */\n  | 'needs-you'\n  /** Athena didn't take it: the app adds why, and what the person can do about it. */\n  | 'not-synced';\n\n/** The state of one item in the \"Waiting to sync\" list, and the line that explains it. */\nexport function waitingItemCopy({\n  state,\n  device,\n}: {\n  state: WaitingItemState;\n  device: DeviceNoun;\n}): LabelCopy {\n  switch (state) {\n    case 'waiting':\n      return {\n        label: 'Waiting to sync',\n        detail: `Saved on ${device}. It syncs when Athena is back.`,\n      };\n    case 'syncing':\n      return { label: 'Syncing…', detail: `Sending what was saved on ${device}.` };\n    case 'in-memory':\n      return {\n        label: 'Not saved yet',\n        detail: `Kept only until you close ${openContainer(device)}. It syncs when Athena is back.`,\n      };\n    case 'when-opened':\n      return {\n        label: 'Not synced yet',\n        detail: `Saved on ${device}. It syncs when you next open it with a connection.`,\n      };\n    case 'other-workspace':\n      return {\n        label: 'Waiting for its workspace',\n        detail: 'It syncs once you’re in the workspace it was made in, with a connection.',\n      };\n    case 'needs-you':\n      return { label: 'Waiting for you', detail: 'Open it to choose what happens to it.' };\n    case 'not-synced':\n      return { label: 'Couldn’t sync', detail: 'Athena didn’t take it.' };\n  }\n}\n\n/** The headings of the \"Waiting to sync\" list, one per kind of item. */\nexport const WAITING_SECTION_TITLES = {\n  changes: 'Changes',\n  messages: 'Messages',\n  recordings: 'Recordings',\n} as const;\n\n/**\n * What the person can do with an item Athena didn't take (`not-synced`) in the\n * \"Waiting to sync\" list: send it again, or delete the copy on the device. That\n * copy is the item's only one, so the app asks first (`deleteFromDeviceConfirm`)\n * and never deletes it as a side effect of anything else.\n */\nexport function notSyncedActions({ device }: { device: DeviceNoun }): {\n  retry: string;\n  remove: string;\n} {\n  return { retry: 'Try again', remove: `Delete from ${device}` };\n}\n\n/** One of `notSyncedActions`, or showing where the item is kept on the device. */\nexport type NotSyncedAction = 'retry' | 'reveal' | 'remove';\n\n/**\n * What the person hears when the device couldn't do what they asked for an\n * item Athena didn't take (its files, not Athena, failed).\n */\nexport function notSyncedActionFailed({\n  action,\n  device,\n}: {\n  action: NotSyncedAction;\n  device: DeviceNoun;\n}): string {\n  switch (action) {\n    case 'retry':\n      return 'Couldn’t send it again. Try again in a moment.';\n    case 'reveal':\n      return `Couldn’t show where it’s kept on ${device}.`;\n    case 'remove':\n      return `Couldn’t delete it from ${device}.`;\n  }\n}\n\n/**\n * The question before deleting such an item's copy on the device, naming the\n * item: the destructive choice is never the default.\n */\nexport function deleteFromDeviceConfirm({\n  name,\n  device,\n}: {\n  name: string;\n  device: DeviceNoun;\n}): StatusCopy & { confirm: string; cancel: string } {\n  return {\n    title: `Delete “${name}” from ${device}?`,\n    detail: 'Athena didn’t take it, so this is its only copy. Deleting it can’t be undone.',\n    confirm: 'Delete',\n    cancel: 'Cancel',\n  };\n}\n"],"names":[],"mappings":";;AAyPO,MAAM,6BAA6B;AA+B1C,MAAM,kBAAkB;AAMjB,MAAM,mBAA8B;AAAA,EACzC,OAAO;AAAA,EACP,QAAQ,sBAAsB,eAAe;AAC/C;AAaO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AACF,GAGW;AACT,QAAM,YAAY,aAA4C,QAAQ,kBAAkB,eAAe;AACvG,SAAO,eACH,iEAAiE,SAAS,KAC1E;AACN;AAGA,SAAS,WAAW,WAA4B;AAC9C,SAAO,YAAY,6BAA6B;AAClD;AAQO,SAAS,+BAA+B;AAAA,EAC7C,YAAY;AACd,IAEI,IAAY;AACd,SAAO,sDAAsD,WAAW,SAAS,CAAC,kBAChF,YAAY,OAAO,gBACrB;AACF;AAOO,SAAS,6BAA6B;AAAA,EAC3C,YAAY;AACd,IAEI,IAAY;AACd,SAAO,gFAAgF;AAAA,IACrF;AAAA,EAAA,CACD;AACH;;;;;;"}
+{"version":3,"file":"offline-status.cjs","sources":["../../../../agent-runtime/src/offline-status.ts"],"sourcesContent":["/**\n * Athena's offline language: the one set of states and words every app uses to\n * say where the person stands when the network, or Athena, is out of reach —\n * Olympus, the desktop app, the phone app, the Chrome extension and the Office\n * add-in.\n *\n * The rule the words follow: say what still works before what doesn't. Work\n * done while Athena can't be reached is kept on the device and syncs when\n * Athena is back, so every message leads with that promise. Nothing here is\n * shown while Athena answers and nothing waits; the \"back\" messages are brief.\n *\n * Pure strings and small functions, no UI library: each app draws them its own\n * way (a banner, a header chip, a tooltip, a sheet). Reachability itself is\n * each app's own (the browser's or OS's online flag AND agora answering its\n * health read); this module only names the result.\n */\n\n/** Where the app stands with Athena. */\nexport type ConnectionState =\n  /** Athena answers. Nothing is shown. */\n  | 'online'\n  /** The device has no network. */\n  | 'offline'\n  /** The network is up but Athena doesn't answer. */\n  | 'unreachable'\n  /** Athena answers again and what waited is being sent. */\n  | 'reconnecting'\n  /** Just back, and everything that waited was sent. Shown briefly. */\n  | 'synced';\n\n/** Where one document's edits stand, for the chip in its header. */\nexport type DocumentSyncState =\n  /** In Athena. */\n  | 'saved'\n  /** Being sent to Athena. */\n  | 'saving'\n  /** Kept on this device while Athena can't be reached; syncs when it is back. */\n  | 'on-device'\n  /** Kept only while this tab or app stays open (no device storage); syncs when Athena is back. */\n  | 'in-memory'\n  /** Sending what was kept on this device. */\n  | 'syncing'\n  /** Some changes overlap with Athena's version: the person chooses. */\n  | 'needs-review'\n  /** The document can no longer take these edits (access or state changed): kept, not sent. */\n  | 'view-only'\n  /**\n   * Athena answers but isn't taking this document's changes for now: it holds the document while it\n   * repairs it, or hasn't confirmed the latest changes for longer than usual (`SavingDelayCause`\n   * says which). Kept, and saved once Athena takes them. Never said while Athena can't be reached:\n   * that is `on-device` or `in-memory`.\n   */\n  | 'delayed';\n\n/** Why a document's saving is delayed while Athena answers (`DocumentSyncState` `delayed`). */\nexport type SavingDelayCause =\n  /** Athena holds the document while it repairs it, and takes no changes to it until then. */\n  | 'repairing'\n  /** Athena hasn't confirmed the latest changes for longer than usual. */\n  | 'unconfirmed';\n\n/** How a sentence names the device the person is on. */\nexport type DeviceNoun =\n  | 'this browser'\n  | 'this Mac'\n  | 'this computer'\n  | 'this phone'\n  | 'this tablet'\n  | 'this device';\n\n/**\n * What the app really keeps of work done while Athena can't be reached, so the\n * words never promise more: `device` (stored on the device, survives closing),\n * `memory` (kept only while this tab or app stays open: a tenant that turns\n * device copies off, or storage the app can't open), `none` (a surface that\n * keeps no work offline at all, like the Chrome side panel).\n */\nexport type OfflineKeeping = 'device' | 'memory' | 'none';\n\n/** A title and the one line under it (a banner, a sheet, a tooltip's heading). */\nexport interface StatusCopy {\n  title: string;\n  detail: string;\n}\n\n/** A short label for a chip or a disabled control, and its one-line explanation. */\nexport interface LabelCopy {\n  label: string;\n  detail: string;\n}\n\nfunction plural(count: number, one: string, many: string): string {\n  return `${count} ${count === 1 ? one : many}`;\n}\n\n/** What a tab or an app is called when work lasts only while it stays open. */\nfunction openContainer(device: DeviceNoun): string {\n  return device === 'this browser' ? 'this tab' : 'the app';\n}\n\n/** The promise after \"You're offline\" / \"Can't reach Athena\", honest to what is kept. */\nfunction keepingPromise({\n  keeping,\n  device,\n  when,\n}: {\n  keeping: OfflineKeeping;\n  device: DeviceNoun;\n  when: string;\n}): string {\n  switch (keeping) {\n    case 'device':\n      return `You can keep working. Changes are saved on ${device} and sync ${when}.`;\n    case 'memory':\n      return `You can keep working, but changes are kept only until you close ${openContainer(device)}. They sync ${when}.`;\n    case 'none':\n      return `You’re still signed in. This reconnects ${when}.`;\n  }\n}\n\n/**\n * The app-wide status line, or `null` while Athena answers and nothing waits.\n * `waiting` counts changes not in Athena yet: while `reconnecting` they are\n * being sent; while `online` they wait for something else (a copy that sends\n * when it is next opened), and the line stays until they are gone.\n * `keeping` is what the app really keeps offline (default `device`). A surface\n * that keeps nothing (`none`) has nothing to sync, so its way back is only\n * \"Back online\", never \"Syncing…\" or \"All changes synced\".\n */\nexport function connectionCopy({\n  state,\n  device,\n  waiting = 0,\n  keeping = 'device',\n}: {\n  state: ConnectionState;\n  device: DeviceNoun;\n  waiting?: number;\n  keeping?: OfflineKeeping;\n}): StatusCopy | null {\n  switch (state) {\n    case 'online':\n      return waiting > 0\n        ? {\n            title: 'Not synced yet',\n            detail: `${plural(waiting, 'change', 'changes')} on ${device} ${waiting === 1 ? 'hasn’t' : 'haven’t'} synced yet.`,\n          }\n        : null;\n    case 'offline':\n      return {\n        title: 'You’re offline',\n        detail: keepingPromise({ keeping, device, when: 'when you’re back online' }),\n      };\n    case 'unreachable':\n      return {\n        title: 'Can’t reach Athena',\n        detail: keepingPromise({ keeping, device, when: 'when Athena is back' }),\n      };\n    case 'reconnecting':\n      if (keeping === 'none') return { title: 'Back online', detail: '' };\n      return {\n        title: 'Back online',\n        detail:\n          waiting > 0 ? `Syncing ${plural(waiting, 'change', 'changes')}…` : 'Syncing…',\n      };\n    case 'synced':\n      return keeping === 'none'\n        ? { title: 'Back online', detail: '' }\n        : { title: 'All changes synced', detail: '' };\n  }\n}\n\n/**\n * The line under \"Saving delayed\": why saving waits, and what is kept meanwhile, never promising\n * more than the app keeps.\n */\nfunction savingDelayedDetail({\n  delay,\n  keeping,\n  device,\n}: {\n  delay: SavingDelayCause;\n  keeping: Exclude<OfflineKeeping, 'none'>;\n  device: DeviceNoun;\n}): string {\n  if (delay === 'repairing') {\n    return keeping === 'memory'\n      ? `You can keep working, but your changes are kept only until you close ${openContainer(device)}. They save once Athena finishes repairing this document.`\n      : `You can keep working. Your changes are kept on ${device} and save once Athena finishes repairing this document.`;\n  }\n  return keeping === 'memory'\n    ? `Athena is taking longer than usual to save your latest changes. They’re kept only until you close ${openContainer(device)}, so keep it open.`\n    : `Athena is taking longer than usual to save your latest changes. They’re kept on ${device} in the meantime.`;\n}\n\n/**\n * What `on-device` says. The desktop app on a Mac speaks as Word, Excel and PowerPoint for Mac do\n * of a cloud document whose changes wait on the Mac (Office's own title-bar words): \"Upload\n * Pending\", and \"Upload Pending (Offline)\" while Athena can't be reached. Every other app says the\n * changes are saved on its device: a browser has no such words (Word for the web can't edit\n * offline), nor does the phone.\n */\nfunction onDeviceCopy({ device, reachable }: { device: DeviceNoun; reachable: boolean }): LabelCopy {\n  if (device === 'this Mac') {\n    return {\n      label: reachable ? 'Upload Pending' : 'Upload Pending (Offline)',\n      detail: 'Upload pending. Your changes sync when Athena is back.',\n    };\n  }\n  return {\n    label: `Saved on ${device}`,\n    detail: `Saved on ${device}. Your changes sync when Athena is back.`,\n  };\n}\n\n/**\n * The chip in a document's header, and the line it explains itself with. For `delayed`, `delay`\n * says why (default `unconfirmed`) and `keeping` whether the changes are kept on the device or only\n * while the tab or app stays open (default `device`); every other state ignores both. `reachable`\n * (default `true`) is whether Athena can be reached, which only the Mac's `on-device` words read.\n */\nexport function documentSyncCopy({\n  state,\n  device,\n  delay = 'unconfirmed',\n  keeping = 'device',\n  reachable = true,\n}: {\n  state: DocumentSyncState;\n  device: DeviceNoun;\n  delay?: SavingDelayCause;\n  keeping?: Exclude<OfflineKeeping, 'none'>;\n  reachable?: boolean;\n}): LabelCopy {\n  switch (state) {\n    case 'saved':\n      return { label: 'Saved', detail: 'Saved to Athena.' };\n    case 'saving':\n      return { label: 'Saving…', detail: 'Saving to Athena.' };\n    case 'on-device':\n      return onDeviceCopy({ device, reachable });\n    case 'in-memory':\n      return {\n        label: 'Not saved yet',\n        detail: `Your changes are kept only until you close ${openContainer(device)}, and save when Athena is back.`,\n      };\n    case 'syncing':\n      return { label: 'Syncing…', detail: `Sending the changes saved on ${device}.` };\n    case 'needs-review':\n      return {\n        label: 'Review changes',\n        detail: 'Some of your changes overlap with changes made in Athena. Choose what to keep.',\n      };\n    case 'view-only':\n      return {\n        label: 'View only',\n        detail: `You can’t edit this anymore. Your changes stay on ${device}.`,\n      };\n    case 'delayed':\n      return { label: 'Saving delayed', detail: savingDelayedDetail({ delay, keeping, device }) };\n  }\n}\n\n/**\n * How long a document's edits may wait unconfirmed on a connection that is up before its saving\n * reads as delayed (`delayed`, `unconfirmed`), and before its room asks Keryx why: the stall window\n * every editor shares (`ACK_STALL_MS` in `@athenaintel/asset-host/local-updates`, which Olympus's\n * `room-sync-store.test.ts` holds equal).\n */\nexport const UNCONFIRMED_EDITS_STALL_MS = 15_000;\n\n/**\n * Whether a document's saving is delayed, and why (`DocumentSyncState` `delayed`): only while Athena\n * answers and the document's room is connected; `repairing` when Keryx refuses the room's writes\n * (quarantined while it is repaired: said at once, before anything waits), `unconfirmed` once its\n * edits have stayed unconfirmed past {@link UNCONFIRMED_EDITS_STALL_MS}; `null` otherwise. Every\n * app's chip asks it after a hold and after edits kept without a connection, and ahead of syncing\n * and saving, so a room that refuses writes never spins and being offline is never a delay.\n */\nexport function savingDelayCause({\n  reachable,\n  connected,\n  writesRefused,\n  unconfirmedStalled,\n}: {\n  /** Athena answers (the app's reachability, never the socket alone). */\n  reachable: boolean;\n  /** The document's room is connected. */\n  connected: boolean;\n  /** Keryx's document status says the room takes no writes for now. */\n  writesRefused: boolean;\n  /** Local edits have waited unconfirmed past the stall window on this connection. */\n  unconfirmedStalled: boolean;\n}): SavingDelayCause | null {\n  if (!reachable || !connected) return null;\n  if (writesRefused) return 'repairing';\n  return unconfirmedStalled ? 'unconfirmed' : null;\n}\n\n/**\n * What the person lost of a document while it was open, when the server checked its room's grant\n * again (Keryx's 4401, after a share changed): `edit`, they may still view it but no longer edit it;\n * `view`, they may no longer open it at all.\n */\nexport type AccessLoss = 'edit' | 'view';\n\n/** What a document says once the person's access changed while it was open. */\nexport interface AccessChangedCopy extends StatusCopy {\n  /**\n   * The label of the button that saves the person's version as a file of their own, with the\n   * changes Athena never took, or `null` when nothing is offered: nothing of theirs waits, or the\n   * device no longer serves the document (`view`).\n   */\n  saveCopy: string | null;\n}\n\n/**\n * What a document says once the person's access to it changed while it was open (its editor turns\n * read-only at once), in Word's own words (Word for Mac's message bar, `strman_a6d4`, and its\n * \"Permissions Have Changed\" notice, `strman_0a3e`). `keptChanges`: changes Athena never took wait\n * on the device, never sent; Word offers to save a copy of the file so nothing typed is lost. A\n * `view` loss offers nothing to save: the device stops serving a document the person may no longer\n * read, and their changes stay where they are kept.\n */\nexport function accessChangedCopy({\n  loss,\n  keptChanges,\n}: {\n  loss: AccessLoss;\n  keptChanges: boolean;\n}): AccessChangedCopy {\n  if (loss === 'view') {\n    return {\n      title: 'Permissions Have Changed',\n      detail:\n        'The permissions on this file were updated and you no longer have rights to view this file. If you previously made changes to this file, they may not be saved.',\n      saveCopy: null,\n    };\n  }\n  if (keptChanges) {\n    return {\n      title: 'Can’t save',\n      detail:\n        'You no longer have the permission to edit this file. To keep your changes, save a copy of the file.',\n      saveCopy: 'Save a Copy',\n    };\n  }\n  return {\n    title: 'Read Only',\n    detail: 'You no longer have the permission to edit this file.',\n    saveCopy: null,\n  };\n}\n\n/** When something that needs Athena works again (the second half of `NEEDS_CONNECTION`'s line). */\nconst AVAILABLE_AGAIN = 'It’s available again when you’re back online.';\n\n/**\n * The reason on a control that needs Athena (share, run, upload, invite…),\n * shown disabled while Athena can't be reached rather than failing when used.\n */\nexport const NEEDS_CONNECTION: LabelCopy = {\n  label: 'Needs a connection',\n  detail: `This needs Athena. ${AVAILABLE_AGAIN}`,\n};\n\n/** What a composer was given to attach: a photo (from the phone's library or camera) or any file. */\nexport type AttachmentKind = 'photo' | 'file';\n\n/**\n * What a composer says when a photo or file is picked, pasted or dropped while\n * Athena can't be reached. It isn't attached: only Athena can take the upload.\n * In a chat whose messages wait to be sent meanwhile (`messagesWait`: the chat\n * keeps an outbox), the message itself still goes, so that comes first. Where\n * nothing waits (the Chrome side panel, a launcher that keeps its draft), it\n * says only when attaching works again, as `NEEDS_CONNECTION` does.\n */\nexport function attachmentNeedsConnection({\n  kind,\n  messagesWait,\n}: {\n  kind: AttachmentKind;\n  messagesWait: boolean;\n}): string {\n  const attaching = `Attaching ${kind === 'photo' ? 'a photo' : 'a file'} needs Athena. ${AVAILABLE_AGAIN}`;\n  return messagesWait\n    ? `You can still send your message: it goes when Athena is back. ${attaching}`\n    : attaching;\n}\n\n/** What a sent message carries besides its text that can't wait for Athena. */\nfunction heldExtras(withQuote: boolean): string {\n  return withQuote ? 'an attachment or a quote' : 'an attachment';\n}\n\n/**\n * What a composer says when a message is sent while Athena can't be reached\n * with an attachment that never reached Athena (or, `withQuote`, a quote the\n * chat can't keep waiting). Its text could wait in the chat outbox; the\n * attachment can't, so the draft stays as it is.\n */\nexport function attachedMessageNeedsConnection({\n  withQuote = false,\n}: {\n  withQuote?: boolean;\n} = {}): string {\n  return `Your text can wait and go when Athena is back, but ${heldExtras(withQuote)} can’t. Remove ${\n    withQuote ? 'it' : 'the attachment'\n  } to send the text.`;\n}\n\n/**\n * What a composer says when a message with an attachment (or, `withQuote`, a\n * quote) is sent while messages written when Athena couldn't be reached still\n * wait to go: those go first, and this one can't wait behind them.\n */\nexport function attachedMessageBehindWaiting({\n  withQuote = false,\n}: {\n  withQuote?: boolean;\n} = {}): string {\n  return `Messages you wrote while Athena couldn’t be reached go first. A message with ${heldExtras(\n    withQuote\n  )} can’t wait behind them, so send it once they’ve gone.`;\n}\n\n/**\n * The reason on New Presentation while Athena can't be reached, in a workspace\n * whose new presentations start from its design system's template: a\n * presentation made offline starts blank, and only Athena can copy the\n * template, so none is made until it can.\n */\nexport const NEW_PRESENTATION_NEEDS_TEMPLATE: LabelCopy = {\n  label: 'Needs a connection',\n  detail:\n    'New presentations in this workspace start from its design template, which needs Athena. You can make one when you’re back online.',\n};\n\n/**\n * What a download of a spreadsheet made from an Excel Macro-Enabled Workbook\n * (`.xlsm`) says when it went without the macros because they come from Athena,\n * which can't be reached, and the device hasn't kept them (they travel with the\n * workbook and never run). The file is the workbook without them; downloading\n * it again with a connection keeps them.\n */\nexport function downloadedWithoutMacros({ device }: { device: DeviceNoun }): string {\n  return `Downloaded without the spreadsheet’s macros: they come from Athena, which can’t be reached, and ${device} hasn’t kept them. Download it again when you’re back online to keep them.`;\n}\n\n/**\n * Save's question for a spreadsheet whose file is an Excel Macro-Enabled\n * Workbook (`.xlsm`) while its macros come from Athena, which can't be reached,\n * and the device hasn't kept them: the `.xlsm` is never written without them,\n * so the person may save an Excel Workbook (`.xlsx`) beside it, and Save writes\n * the `.xlsm` again once Athena answers.\n */\nexport function macrosNeedConnectionToSave({\n  name,\n  device,\n}: {\n  name: string;\n  device: DeviceNoun;\n}): StatusCopy {\n  return {\n    title: `Athena can’t save the macros in “${name}” right now.`,\n    detail: `They come from Athena, which can’t be reached, and ${device} hasn’t kept them. Save it as an Excel Workbook (.xlsx) instead. “${name}” stays as it is, macros included, and Save writes it again when you’re back online.`,\n  };\n}\n\n/**\n * What saving a version kept on the device as a new spreadsheet says when the\n * spreadsheet was made from an Excel Macro-Enabled Workbook (`.xlsm`) and\n * Athena can't be reached: the new spreadsheet is made all the same (on the\n * device, and it syncs when Athena is back), but without the macros, which only\n * Athena can keep with a new spreadsheet (they travel with the workbook and\n * never run). The kept version stays on the device, so saving it again with a\n * connection keeps them.\n */\nexport function savedAsNewWithoutMacros({ device }: { device: DeviceNoun }): string {\n  return `The new spreadsheet was made without the macros: only Athena can keep them in a new spreadsheet, and it can’t be reached. The kept version stays on ${device}: save it as a new spreadsheet again when you’re back online to keep them.`;\n}\n\n/**\n * Whether an item opens without a connection on this device, for lists.\n * `canKeep` says whether opening it online would keep a copy here (the\n * deployment allows device copies and the item's type is one that is kept):\n * only then is the person told to open it once.\n */\nexport function offlineAvailabilityCopy({\n  available,\n  canKeep,\n  device,\n}: {\n  available: boolean;\n  canKeep: boolean;\n  device: DeviceNoun;\n}): LabelCopy {\n  if (available) {\n    return { label: 'Available offline', detail: `Opens without a connection on ${device}.` };\n  }\n  return canKeep\n    ? {\n        label: 'Not available offline',\n        detail: `Open it once while online to keep it on ${device}.`,\n      }\n    : { label: 'Not available offline', detail: 'This opens only with a connection.' };\n}\n\n/**\n * The one-time explainer shown the first time the person goes offline, on a\n * surface that keeps work there (`keeping` `device`). A surface that keeps\n * nothing (`none`: the Chrome side panel, the Office task pane) shows no\n * explainer; its status line already says all that holds.\n */\nexport function firstOfflineExplainer({ device }: { device: DeviceNoun }): StatusCopy & {\n  action: string;\n} {\n  return {\n    title: 'You can keep working offline',\n    detail: `Documents you’ve opened recently keep working on ${device}. Your changes sync when you’re back online.`,\n    action: 'Got it',\n  };\n}\n\n/**\n * The summary heading of the one \"Waiting to sync\" list, from what waits on\n * the device; `null` when nothing does.\n */\nexport function waitingSummary({\n  changes = 0,\n  messages = 0,\n  recordings = 0,\n}: {\n  changes?: number;\n  messages?: number;\n  recordings?: number;\n}): string | null {\n  const parts = [\n    changes > 0 ? plural(changes, 'change', 'changes') : null,\n    messages > 0 ? plural(messages, 'message', 'messages') : null,\n    recordings > 0 ? plural(recordings, 'recording', 'recordings') : null,\n  ].filter((part): part is string => part !== null);\n  return parts.length === 0 ? null : `Waiting to sync: ${parts.join(', ')}`;\n}\n\n/**\n * Where one item in the \"Waiting to sync\" list stands: a change, a message or a\n * recording made while Athena couldn't be reached.\n */\nexport type WaitingItemState =\n  /** Saved on the device; it syncs when Athena is back. */\n  | 'waiting'\n  /** Being sent to Athena now. */\n  | 'syncing'\n  /**\n   * Kept only while this tab or app stays open: it couldn't be saved on the\n   * device (the organization keeps nothing on devices, or storage failed).\n   */\n  | 'in-memory'\n  /**\n   * Saved on the device in something that isn't open (a document closed before\n   * its edits synced, one made offline): it syncs when it is next opened with a\n   * connection (opening it offline sends nothing).\n   */\n  | 'when-opened'\n  /** Made in another workspace: it syncs once that workspace is open again, with a connection. */\n  | 'other-workspace'\n  /** It doesn't go on its own: the person chooses (a message that waited more than a day). */\n  | 'needs-you'\n  /** Athena didn't take it: the app adds why, and what the person can do about it. */\n  | 'not-synced';\n\n/** The state of one item in the \"Waiting to sync\" list, and the line that explains it. */\nexport function waitingItemCopy({\n  state,\n  device,\n}: {\n  state: WaitingItemState;\n  device: DeviceNoun;\n}): LabelCopy {\n  switch (state) {\n    case 'waiting':\n      return {\n        label: 'Waiting to sync',\n        detail: `Saved on ${device}. It syncs when Athena is back.`,\n      };\n    case 'syncing':\n      return { label: 'Syncing…', detail: `Sending what was saved on ${device}.` };\n    case 'in-memory':\n      return {\n        label: 'Not saved yet',\n        detail: `Kept only until you close ${openContainer(device)}. It syncs when Athena is back.`,\n      };\n    case 'when-opened':\n      return {\n        label: 'Not synced yet',\n        detail: `Saved on ${device}. It syncs when you next open it with a connection.`,\n      };\n    case 'other-workspace':\n      return {\n        label: 'Waiting for its workspace',\n        detail: 'It syncs once you’re in the workspace it was made in, with a connection.',\n      };\n    case 'needs-you':\n      return { label: 'Waiting for you', detail: 'Open it to choose what happens to it.' };\n    case 'not-synced':\n      return { label: 'Couldn’t sync', detail: 'Athena didn’t take it.' };\n  }\n}\n\n/** The headings of the \"Waiting to sync\" list, one per kind of item. */\nexport const WAITING_SECTION_TITLES = {\n  changes: 'Changes',\n  messages: 'Messages',\n  recordings: 'Recordings',\n} as const;\n\n/**\n * What the person can do with an item Athena didn't take (`not-synced`) in the\n * \"Waiting to sync\" list: send it again, or delete the copy on the device. That\n * copy is the item's only one, so the app asks first (`deleteFromDeviceConfirm`)\n * and never deletes it as a side effect of anything else.\n */\nexport function notSyncedActions({ device }: { device: DeviceNoun }): {\n  retry: string;\n  remove: string;\n} {\n  return { retry: 'Try again', remove: `Delete from ${device}` };\n}\n\n/** One of `notSyncedActions`, or showing where the item is kept on the device. */\nexport type NotSyncedAction = 'retry' | 'reveal' | 'remove';\n\n/**\n * What the person hears when the device couldn't do what they asked for an\n * item Athena didn't take (its files, not Athena, failed).\n */\nexport function notSyncedActionFailed({\n  action,\n  device,\n}: {\n  action: NotSyncedAction;\n  device: DeviceNoun;\n}): string {\n  switch (action) {\n    case 'retry':\n      return 'Couldn’t send it again. Try again in a moment.';\n    case 'reveal':\n      return `Couldn’t show where it’s kept on ${device}.`;\n    case 'remove':\n      return `Couldn’t delete it from ${device}.`;\n  }\n}\n\n/**\n * The question before deleting such an item's copy on the device, naming the\n * item: the destructive choice is never the default.\n */\nexport function deleteFromDeviceConfirm({\n  name,\n  device,\n}: {\n  name: string;\n  device: DeviceNoun;\n}): StatusCopy & { confirm: string; cancel: string } {\n  return {\n    title: `Delete “${name}” from ${device}?`,\n    detail: 'Athena didn’t take it, so this is its only copy. Deleting it can’t be undone.',\n    confirm: 'Delete',\n    cancel: 'Cancel',\n  };\n}\n"],"names":[],"mappings":";;AA6QO,MAAM,6BAA6B;AAsF1C,MAAM,kBAAkB;AAMjB,MAAM,mBAA8B;AAAA,EACzC,OAAO;AAAA,EACP,QAAQ,sBAAsB,eAAe;AAC/C;AAaO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AACF,GAGW;AACT,QAAM,YAAY,aAA4C,QAAQ,kBAAkB,eAAe;AACvG,SAAO,eACH,iEAAiE,SAAS,KAC1E;AACN;AAGA,SAAS,WAAW,WAA4B;AAC9C,SAAO,YAAY,6BAA6B;AAClD;AAQO,SAAS,+BAA+B;AAAA,EAC7C,YAAY;AACd,IAEI,IAAY;AACd,SAAO,sDAAsD,WAAW,SAAS,CAAC,kBAChF,YAAY,OAAO,gBACrB;AACF;AAOO,SAAS,6BAA6B;AAAA,EAC3C,YAAY;AACd,IAEI,IAAY;AACd,SAAO,gFAAgF;AAAA,IACrF;AAAA,EAAA,CACD;AACH;;;;;;"}

package/dist/agent-runtime/src/offline-status.d.ts

@@ -93,13 +93,15 @@ export declare function connectionCopy({ state, device, waiting, keeping, }: {
 /**
  * The chip in a document's header, and the line it explains itself with. For `delayed`, `delay`
  * says why (default `unconfirmed`) and `keeping` whether the changes are kept on the device or only
- * while the tab or app stays open (default `device`); every other state ignores both.
+ * while the tab or app stays open (default `device`); every other state ignores both. `reachable`
+ * (default `true`) is whether Athena can be reached, which only the Mac's `on-device` words read.
  */
-export declare function documentSyncCopy({ state, device, delay, keeping, }: {
+export declare function documentSyncCopy({ state, device, delay, keeping, reachable, }: {
     state: DocumentSyncState;
     device: DeviceNoun;
     delay?: SavingDelayCause;
     keeping?: Exclude<OfflineKeeping, 'none'>;
+    reachable?: boolean;
 }): LabelCopy;
 /**
  * How long a document's edits may wait unconfirmed on a connection that is up before its saving
@@ -126,6 +128,33 @@ export declare function savingDelayCause({ reachable, connected, writesRefused,
     /** Local edits have waited unconfirmed past the stall window on this connection. */
     unconfirmedStalled: boolean;
 }): SavingDelayCause | null;
+/**
+ * What the person lost of a document while it was open, when the server checked its room's grant
+ * again (Keryx's 4401, after a share changed): `edit`, they may still view it but no longer edit it;
+ * `view`, they may no longer open it at all.
+ */
+export type AccessLoss = 'edit' | 'view';
+/** What a document says once the person's access changed while it was open. */
+export interface AccessChangedCopy extends StatusCopy {
+    /**
+     * The label of the button that saves the person's version as a file of their own, with the
+     * changes Athena never took, or `null` when nothing is offered: nothing of theirs waits, or the
+     * device no longer serves the document (`view`).
+     */
+    saveCopy: string | null;
+}
+/**
+ * What a document says once the person's access to it changed while it was open (its editor turns
+ * read-only at once), in Word's own words (Word for Mac's message bar, `strman_a6d4`, and its
+ * "Permissions Have Changed" notice, `strman_0a3e`). `keptChanges`: changes Athena never took wait
+ * on the device, never sent; Word offers to save a copy of the file so nothing typed is lost. A
+ * `view` loss offers nothing to save: the device stops serving a document the person may no longer
+ * read, and their changes stay where they are kept.
+ */
+export declare function accessChangedCopy({ loss, keptChanges, }: {
+    loss: AccessLoss;
+    keptChanges: boolean;
+}): AccessChangedCopy;
 /**
  * The reason on a control that needs Athena (share, run, upload, invite…),
  * shown disabled while Athena can't be reached rather than failing when used.

package/dist/agent-runtime/src/offline-status.js.map

@@ -1 +1 @@
-{"version":3,"file":"offline-status.js","sources":["../../../../agent-runtime/src/offline-status.ts"],"sourcesContent":["/**\n * Athena's offline language: the one set of states and words every app uses to\n * say where the person stands when the network, or Athena, is out of reach —\n * Olympus, the desktop app, the phone app, the Chrome extension and the Office\n * add-in.\n *\n * The rule the words follow: say what still works before what doesn't. Work\n * done while Athena can't be reached is kept on the device and syncs when\n * Athena is back, so every message leads with that promise. Nothing here is\n * shown while Athena answers and nothing waits; the \"back\" messages are brief.\n *\n * Pure strings and small functions, no UI library: each app draws them its own\n * way (a banner, a header chip, a tooltip, a sheet). Reachability itself is\n * each app's own (the browser's or OS's online flag AND agora answering its\n * health read); this module only names the result.\n */\n\n/** Where the app stands with Athena. */\nexport type ConnectionState =\n  /** Athena answers. Nothing is shown. */\n  | 'online'\n  /** The device has no network. */\n  | 'offline'\n  /** The network is up but Athena doesn't answer. */\n  | 'unreachable'\n  /** Athena answers again and what waited is being sent. */\n  | 'reconnecting'\n  /** Just back, and everything that waited was sent. Shown briefly. */\n  | 'synced';\n\n/** Where one document's edits stand, for the chip in its header. */\nexport type DocumentSyncState =\n  /** In Athena. */\n  | 'saved'\n  /** Being sent to Athena. */\n  | 'saving'\n  /** Kept on this device while Athena can't be reached; syncs when it is back. */\n  | 'on-device'\n  /** Kept only while this tab or app stays open (no device storage); syncs when Athena is back. */\n  | 'in-memory'\n  /** Sending what was kept on this device. */\n  | 'syncing'\n  /** Some changes overlap with Athena's version: the person chooses. */\n  | 'needs-review'\n  /** The document can no longer take these edits (access or state changed): kept, not sent. */\n  | 'view-only'\n  /**\n   * Athena answers but isn't taking this document's changes for now: it holds the document while it\n   * repairs it, or hasn't confirmed the latest changes for longer than usual (`SavingDelayCause`\n   * says which). Kept, and saved once Athena takes them. Never said while Athena can't be reached:\n   * that is `on-device` or `in-memory`.\n   */\n  | 'delayed';\n\n/** Why a document's saving is delayed while Athena answers (`DocumentSyncState` `delayed`). */\nexport type SavingDelayCause =\n  /** Athena holds the document while it repairs it, and takes no changes to it until then. */\n  | 'repairing'\n  /** Athena hasn't confirmed the latest changes for longer than usual. */\n  | 'unconfirmed';\n\n/** How a sentence names the device the person is on. */\nexport type DeviceNoun =\n  | 'this browser'\n  | 'this Mac'\n  | 'this computer'\n  | 'this phone'\n  | 'this tablet'\n  | 'this device';\n\n/**\n * What the app really keeps of work done while Athena can't be reached, so the\n * words never promise more: `device` (stored on the device, survives closing),\n * `memory` (kept only while this tab or app stays open: a tenant that turns\n * device copies off, or storage the app can't open), `none` (a surface that\n * keeps no work offline at all, like the Chrome side panel).\n */\nexport type OfflineKeeping = 'device' | 'memory' | 'none';\n\n/** A title and the one line under it (a banner, a sheet, a tooltip's heading). */\nexport interface StatusCopy {\n  title: string;\n  detail: string;\n}\n\n/** A short label for a chip or a disabled control, and its one-line explanation. */\nexport interface LabelCopy {\n  label: string;\n  detail: string;\n}\n\nfunction plural(count: number, one: string, many: string): string {\n  return `${count} ${count === 1 ? one : many}`;\n}\n\n/** What a tab or an app is called when work lasts only while it stays open. */\nfunction openContainer(device: DeviceNoun): string {\n  return device === 'this browser' ? 'this tab' : 'the app';\n}\n\n/** The promise after \"You're offline\" / \"Can't reach Athena\", honest to what is kept. */\nfunction keepingPromise({\n  keeping,\n  device,\n  when,\n}: {\n  keeping: OfflineKeeping;\n  device: DeviceNoun;\n  when: string;\n}): string {\n  switch (keeping) {\n    case 'device':\n      return `You can keep working. Changes are saved on ${device} and sync ${when}.`;\n    case 'memory':\n      return `You can keep working, but changes are kept only until you close ${openContainer(device)}. They sync ${when}.`;\n    case 'none':\n      return `You’re still signed in. This reconnects ${when}.`;\n  }\n}\n\n/**\n * The app-wide status line, or `null` while Athena answers and nothing waits.\n * `waiting` counts changes not in Athena yet: while `reconnecting` they are\n * being sent; while `online` they wait for something else (a copy that sends\n * when it is next opened), and the line stays until they are gone.\n * `keeping` is what the app really keeps offline (default `device`). A surface\n * that keeps nothing (`none`) has nothing to sync, so its way back is only\n * \"Back online\", never \"Syncing…\" or \"All changes synced\".\n */\nexport function connectionCopy({\n  state,\n  device,\n  waiting = 0,\n  keeping = 'device',\n}: {\n  state: ConnectionState;\n  device: DeviceNoun;\n  waiting?: number;\n  keeping?: OfflineKeeping;\n}): StatusCopy | null {\n  switch (state) {\n    case 'online':\n      return waiting > 0\n        ? {\n            title: 'Not synced yet',\n            detail: `${plural(waiting, 'change', 'changes')} on ${device} ${waiting === 1 ? 'hasn’t' : 'haven’t'} synced yet.`,\n          }\n        : null;\n    case 'offline':\n      return {\n        title: 'You’re offline',\n        detail: keepingPromise({ keeping, device, when: 'when you’re back online' }),\n      };\n    case 'unreachable':\n      return {\n        title: 'Can’t reach Athena',\n        detail: keepingPromise({ keeping, device, when: 'when Athena is back' }),\n      };\n    case 'reconnecting':\n      if (keeping === 'none') return { title: 'Back online', detail: '' };\n      return {\n        title: 'Back online',\n        detail:\n          waiting > 0 ? `Syncing ${plural(waiting, 'change', 'changes')}…` : 'Syncing…',\n      };\n    case 'synced':\n      return keeping === 'none'\n        ? { title: 'Back online', detail: '' }\n        : { title: 'All changes synced', detail: '' };\n  }\n}\n\n/**\n * The line under \"Saving delayed\": why saving waits, and what is kept meanwhile, never promising\n * more than the app keeps.\n */\nfunction savingDelayedDetail({\n  delay,\n  keeping,\n  device,\n}: {\n  delay: SavingDelayCause;\n  keeping: Exclude<OfflineKeeping, 'none'>;\n  device: DeviceNoun;\n}): string {\n  if (delay === 'repairing') {\n    return keeping === 'memory'\n      ? `You can keep working, but your changes are kept only until you close ${openContainer(device)}. They save once Athena finishes repairing this document.`\n      : `You can keep working. Your changes are kept on ${device} and save once Athena finishes repairing this document.`;\n  }\n  return keeping === 'memory'\n    ? `Athena is taking longer than usual to save your latest changes. They’re kept only until you close ${openContainer(device)}, so keep it open.`\n    : `Athena is taking longer than usual to save your latest changes. They’re kept on ${device} in the meantime.`;\n}\n\n/**\n * The chip in a document's header, and the line it explains itself with. For `delayed`, `delay`\n * says why (default `unconfirmed`) and `keeping` whether the changes are kept on the device or only\n * while the tab or app stays open (default `device`); every other state ignores both.\n */\nexport function documentSyncCopy({\n  state,\n  device,\n  delay = 'unconfirmed',\n  keeping = 'device',\n}: {\n  state: DocumentSyncState;\n  device: DeviceNoun;\n  delay?: SavingDelayCause;\n  keeping?: Exclude<OfflineKeeping, 'none'>;\n}): LabelCopy {\n  switch (state) {\n    case 'saved':\n      return { label: 'Saved', detail: 'Saved to Athena.' };\n    case 'saving':\n      return { label: 'Saving…', detail: 'Saving to Athena.' };\n    case 'on-device':\n      return {\n        label: `Saved on ${device}`,\n        detail: `Saved on ${device}. Your changes sync when Athena is back.`,\n      };\n    case 'in-memory':\n      return {\n        label: 'Not saved yet',\n        detail: `Your changes are kept only until you close ${openContainer(device)}, and save when Athena is back.`,\n      };\n    case 'syncing':\n      return { label: 'Syncing…', detail: `Sending the changes saved on ${device}.` };\n    case 'needs-review':\n      return {\n        label: 'Review changes',\n        detail: 'Some of your changes overlap with changes made in Athena. Choose what to keep.',\n      };\n    case 'view-only':\n      return {\n        label: 'View only',\n        detail: `You can’t edit this anymore. Your changes stay on ${device}.`,\n      };\n    case 'delayed':\n      return { label: 'Saving delayed', detail: savingDelayedDetail({ delay, keeping, device }) };\n  }\n}\n\n/**\n * How long a document's edits may wait unconfirmed on a connection that is up before its saving\n * reads as delayed (`delayed`, `unconfirmed`), and before its room asks Keryx why: the stall window\n * every editor shares (`ACK_STALL_MS` in `@athenaintel/asset-host/local-updates`, which Olympus's\n * `room-sync-store.test.ts` holds equal).\n */\nexport const UNCONFIRMED_EDITS_STALL_MS = 15_000;\n\n/**\n * Whether a document's saving is delayed, and why (`DocumentSyncState` `delayed`): only while Athena\n * answers and the document's room is connected; `repairing` when Keryx refuses the room's writes\n * (quarantined while it is repaired: said at once, before anything waits), `unconfirmed` once its\n * edits have stayed unconfirmed past {@link UNCONFIRMED_EDITS_STALL_MS}; `null` otherwise. Every\n * app's chip asks it after a hold and after edits kept without a connection, and ahead of syncing\n * and saving, so a room that refuses writes never spins and being offline is never a delay.\n */\nexport function savingDelayCause({\n  reachable,\n  connected,\n  writesRefused,\n  unconfirmedStalled,\n}: {\n  /** Athena answers (the app's reachability, never the socket alone). */\n  reachable: boolean;\n  /** The document's room is connected. */\n  connected: boolean;\n  /** Keryx's document status says the room takes no writes for now. */\n  writesRefused: boolean;\n  /** Local edits have waited unconfirmed past the stall window on this connection. */\n  unconfirmedStalled: boolean;\n}): SavingDelayCause | null {\n  if (!reachable || !connected) return null;\n  if (writesRefused) return 'repairing';\n  return unconfirmedStalled ? 'unconfirmed' : null;\n}\n\n/** When something that needs Athena works again (the second half of `NEEDS_CONNECTION`'s line). */\nconst AVAILABLE_AGAIN = 'It’s available again when you’re back online.';\n\n/**\n * The reason on a control that needs Athena (share, run, upload, invite…),\n * shown disabled while Athena can't be reached rather than failing when used.\n */\nexport const NEEDS_CONNECTION: LabelCopy = {\n  label: 'Needs a connection',\n  detail: `This needs Athena. ${AVAILABLE_AGAIN}`,\n};\n\n/** What a composer was given to attach: a photo (from the phone's library or camera) or any file. */\nexport type AttachmentKind = 'photo' | 'file';\n\n/**\n * What a composer says when a photo or file is picked, pasted or dropped while\n * Athena can't be reached. It isn't attached: only Athena can take the upload.\n * In a chat whose messages wait to be sent meanwhile (`messagesWait`: the chat\n * keeps an outbox), the message itself still goes, so that comes first. Where\n * nothing waits (the Chrome side panel, a launcher that keeps its draft), it\n * says only when attaching works again, as `NEEDS_CONNECTION` does.\n */\nexport function attachmentNeedsConnection({\n  kind,\n  messagesWait,\n}: {\n  kind: AttachmentKind;\n  messagesWait: boolean;\n}): string {\n  const attaching = `Attaching ${kind === 'photo' ? 'a photo' : 'a file'} needs Athena. ${AVAILABLE_AGAIN}`;\n  return messagesWait\n    ? `You can still send your message: it goes when Athena is back. ${attaching}`\n    : attaching;\n}\n\n/** What a sent message carries besides its text that can't wait for Athena. */\nfunction heldExtras(withQuote: boolean): string {\n  return withQuote ? 'an attachment or a quote' : 'an attachment';\n}\n\n/**\n * What a composer says when a message is sent while Athena can't be reached\n * with an attachment that never reached Athena (or, `withQuote`, a quote the\n * chat can't keep waiting). Its text could wait in the chat outbox; the\n * attachment can't, so the draft stays as it is.\n */\nexport function attachedMessageNeedsConnection({\n  withQuote = false,\n}: {\n  withQuote?: boolean;\n} = {}): string {\n  return `Your text can wait and go when Athena is back, but ${heldExtras(withQuote)} can’t. Remove ${\n    withQuote ? 'it' : 'the attachment'\n  } to send the text.`;\n}\n\n/**\n * What a composer says when a message with an attachment (or, `withQuote`, a\n * quote) is sent while messages written when Athena couldn't be reached still\n * wait to go: those go first, and this one can't wait behind them.\n */\nexport function attachedMessageBehindWaiting({\n  withQuote = false,\n}: {\n  withQuote?: boolean;\n} = {}): string {\n  return `Messages you wrote while Athena couldn’t be reached go first. A message with ${heldExtras(\n    withQuote\n  )} can’t wait behind them, so send it once they’ve gone.`;\n}\n\n/**\n * The reason on New Presentation while Athena can't be reached, in a workspace\n * whose new presentations start from its design system's template: a\n * presentation made offline starts blank, and only Athena can copy the\n * template, so none is made until it can.\n */\nexport const NEW_PRESENTATION_NEEDS_TEMPLATE: LabelCopy = {\n  label: 'Needs a connection',\n  detail:\n    'New presentations in this workspace start from its design template, which needs Athena. You can make one when you’re back online.',\n};\n\n/**\n * What a download of a spreadsheet made from an Excel Macro-Enabled Workbook\n * (`.xlsm`) says when it went without the macros because they come from Athena,\n * which can't be reached, and the device hasn't kept them (they travel with the\n * workbook and never run). The file is the workbook without them; downloading\n * it again with a connection keeps them.\n */\nexport function downloadedWithoutMacros({ device }: { device: DeviceNoun }): string {\n  return `Downloaded without the spreadsheet’s macros: they come from Athena, which can’t be reached, and ${device} hasn’t kept them. Download it again when you’re back online to keep them.`;\n}\n\n/**\n * Save's question for a spreadsheet whose file is an Excel Macro-Enabled\n * Workbook (`.xlsm`) while its macros come from Athena, which can't be reached,\n * and the device hasn't kept them: the `.xlsm` is never written without them,\n * so the person may save an Excel Workbook (`.xlsx`) beside it, and Save writes\n * the `.xlsm` again once Athena answers.\n */\nexport function macrosNeedConnectionToSave({\n  name,\n  device,\n}: {\n  name: string;\n  device: DeviceNoun;\n}): StatusCopy {\n  return {\n    title: `Athena can’t save the macros in “${name}” right now.`,\n    detail: `They come from Athena, which can’t be reached, and ${device} hasn’t kept them. Save it as an Excel Workbook (.xlsx) instead. “${name}” stays as it is, macros included, and Save writes it again when you’re back online.`,\n  };\n}\n\n/**\n * What saving a version kept on the device as a new spreadsheet says when the\n * spreadsheet was made from an Excel Macro-Enabled Workbook (`.xlsm`) and\n * Athena can't be reached: the new spreadsheet is made all the same (on the\n * device, and it syncs when Athena is back), but without the macros, which only\n * Athena can keep with a new spreadsheet (they travel with the workbook and\n * never run). The kept version stays on the device, so saving it again with a\n * connection keeps them.\n */\nexport function savedAsNewWithoutMacros({ device }: { device: DeviceNoun }): string {\n  return `The new spreadsheet was made without the macros: only Athena can keep them in a new spreadsheet, and it can’t be reached. The kept version stays on ${device}: save it as a new spreadsheet again when you’re back online to keep them.`;\n}\n\n/**\n * Whether an item opens without a connection on this device, for lists.\n * `canKeep` says whether opening it online would keep a copy here (the\n * deployment allows device copies and the item's type is one that is kept):\n * only then is the person told to open it once.\n */\nexport function offlineAvailabilityCopy({\n  available,\n  canKeep,\n  device,\n}: {\n  available: boolean;\n  canKeep: boolean;\n  device: DeviceNoun;\n}): LabelCopy {\n  if (available) {\n    return { label: 'Available offline', detail: `Opens without a connection on ${device}.` };\n  }\n  return canKeep\n    ? {\n        label: 'Not available offline',\n        detail: `Open it once while online to keep it on ${device}.`,\n      }\n    : { label: 'Not available offline', detail: 'This opens only with a connection.' };\n}\n\n/**\n * The one-time explainer shown the first time the person goes offline, on a\n * surface that keeps work there (`keeping` `device`). A surface that keeps\n * nothing (`none`: the Chrome side panel, the Office task pane) shows no\n * explainer; its status line already says all that holds.\n */\nexport function firstOfflineExplainer({ device }: { device: DeviceNoun }): StatusCopy & {\n  action: string;\n} {\n  return {\n    title: 'You can keep working offline',\n    detail: `Documents you’ve opened recently keep working on ${device}. Your changes sync when you’re back online.`,\n    action: 'Got it',\n  };\n}\n\n/**\n * The summary heading of the one \"Waiting to sync\" list, from what waits on\n * the device; `null` when nothing does.\n */\nexport function waitingSummary({\n  changes = 0,\n  messages = 0,\n  recordings = 0,\n}: {\n  changes?: number;\n  messages?: number;\n  recordings?: number;\n}): string | null {\n  const parts = [\n    changes > 0 ? plural(changes, 'change', 'changes') : null,\n    messages > 0 ? plural(messages, 'message', 'messages') : null,\n    recordings > 0 ? plural(recordings, 'recording', 'recordings') : null,\n  ].filter((part): part is string => part !== null);\n  return parts.length === 0 ? null : `Waiting to sync: ${parts.join(', ')}`;\n}\n\n/**\n * Where one item in the \"Waiting to sync\" list stands: a change, a message or a\n * recording made while Athena couldn't be reached.\n */\nexport type WaitingItemState =\n  /** Saved on the device; it syncs when Athena is back. */\n  | 'waiting'\n  /** Being sent to Athena now. */\n  | 'syncing'\n  /**\n   * Kept only while this tab or app stays open: it couldn't be saved on the\n   * device (the organization keeps nothing on devices, or storage failed).\n   */\n  | 'in-memory'\n  /**\n   * Saved on the device in something that isn't open (a document closed before\n   * its edits synced, one made offline): it syncs when it is next opened with a\n   * connection (opening it offline sends nothing).\n   */\n  | 'when-opened'\n  /** Made in another workspace: it syncs once that workspace is open again, with a connection. */\n  | 'other-workspace'\n  /** It doesn't go on its own: the person chooses (a message that waited more than a day). */\n  | 'needs-you'\n  /** Athena didn't take it: the app adds why, and what the person can do about it. */\n  | 'not-synced';\n\n/** The state of one item in the \"Waiting to sync\" list, and the line that explains it. */\nexport function waitingItemCopy({\n  state,\n  device,\n}: {\n  state: WaitingItemState;\n  device: DeviceNoun;\n}): LabelCopy {\n  switch (state) {\n    case 'waiting':\n      return {\n        label: 'Waiting to sync',\n        detail: `Saved on ${device}. It syncs when Athena is back.`,\n      };\n    case 'syncing':\n      return { label: 'Syncing…', detail: `Sending what was saved on ${device}.` };\n    case 'in-memory':\n      return {\n        label: 'Not saved yet',\n        detail: `Kept only until you close ${openContainer(device)}. It syncs when Athena is back.`,\n      };\n    case 'when-opened':\n      return {\n        label: 'Not synced yet',\n        detail: `Saved on ${device}. It syncs when you next open it with a connection.`,\n      };\n    case 'other-workspace':\n      return {\n        label: 'Waiting for its workspace',\n        detail: 'It syncs once you’re in the workspace it was made in, with a connection.',\n      };\n    case 'needs-you':\n      return { label: 'Waiting for you', detail: 'Open it to choose what happens to it.' };\n    case 'not-synced':\n      return { label: 'Couldn’t sync', detail: 'Athena didn’t take it.' };\n  }\n}\n\n/** The headings of the \"Waiting to sync\" list, one per kind of item. */\nexport const WAITING_SECTION_TITLES = {\n  changes: 'Changes',\n  messages: 'Messages',\n  recordings: 'Recordings',\n} as const;\n\n/**\n * What the person can do with an item Athena didn't take (`not-synced`) in the\n * \"Waiting to sync\" list: send it again, or delete the copy on the device. That\n * copy is the item's only one, so the app asks first (`deleteFromDeviceConfirm`)\n * and never deletes it as a side effect of anything else.\n */\nexport function notSyncedActions({ device }: { device: DeviceNoun }): {\n  retry: string;\n  remove: string;\n} {\n  return { retry: 'Try again', remove: `Delete from ${device}` };\n}\n\n/** One of `notSyncedActions`, or showing where the item is kept on the device. */\nexport type NotSyncedAction = 'retry' | 'reveal' | 'remove';\n\n/**\n * What the person hears when the device couldn't do what they asked for an\n * item Athena didn't take (its files, not Athena, failed).\n */\nexport function notSyncedActionFailed({\n  action,\n  device,\n}: {\n  action: NotSyncedAction;\n  device: DeviceNoun;\n}): string {\n  switch (action) {\n    case 'retry':\n      return 'Couldn’t send it again. Try again in a moment.';\n    case 'reveal':\n      return `Couldn’t show where it’s kept on ${device}.`;\n    case 'remove':\n      return `Couldn’t delete it from ${device}.`;\n  }\n}\n\n/**\n * The question before deleting such an item's copy on the device, naming the\n * item: the destructive choice is never the default.\n */\nexport function deleteFromDeviceConfirm({\n  name,\n  device,\n}: {\n  name: string;\n  device: DeviceNoun;\n}): StatusCopy & { confirm: string; cancel: string } {\n  return {\n    title: `Delete “${name}” from ${device}?`,\n    detail: 'Athena didn’t take it, so this is its only copy. Deleting it can’t be undone.',\n    confirm: 'Delete',\n    cancel: 'Cancel',\n  };\n}\n"],"names":[],"mappings":"AAyPO,MAAM,6BAA6B;AA+B1C,MAAM,kBAAkB;AAMjB,MAAM,mBAA8B;AAAA,EACzC,OAAO;AAAA,EACP,QAAQ,sBAAsB,eAAe;AAC/C;AAaO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AACF,GAGW;AACT,QAAM,YAAY,aAA4C,QAAQ,kBAAkB,eAAe;AACvG,SAAO,eACH,iEAAiE,SAAS,KAC1E;AACN;AAGA,SAAS,WAAW,WAA4B;AAC9C,SAAO,YAAY,6BAA6B;AAClD;AAQO,SAAS,+BAA+B;AAAA,EAC7C,YAAY;AACd,IAEI,IAAY;AACd,SAAO,sDAAsD,WAAW,SAAS,CAAC,kBAChF,YAAY,OAAO,gBACrB;AACF;AAOO,SAAS,6BAA6B;AAAA,EAC3C,YAAY;AACd,IAEI,IAAY;AACd,SAAO,gFAAgF;AAAA,IACrF;AAAA,EAAA,CACD;AACH;"}
+{"version":3,"file":"offline-status.js","sources":["../../../../agent-runtime/src/offline-status.ts"],"sourcesContent":["/**\n * Athena's offline language: the one set of states and words every app uses to\n * say where the person stands when the network, or Athena, is out of reach —\n * Olympus, the desktop app, the phone app, the Chrome extension and the Office\n * add-in.\n *\n * The rule the words follow: say what still works before what doesn't. Work\n * done while Athena can't be reached is kept on the device and syncs when\n * Athena is back, so every message leads with that promise. Nothing here is\n * shown while Athena answers and nothing waits; the \"back\" messages are brief.\n *\n * Pure strings and small functions, no UI library: each app draws them its own\n * way (a banner, a header chip, a tooltip, a sheet). Reachability itself is\n * each app's own (the browser's or OS's online flag AND agora answering its\n * health read); this module only names the result.\n */\n\n/** Where the app stands with Athena. */\nexport type ConnectionState =\n  /** Athena answers. Nothing is shown. */\n  | 'online'\n  /** The device has no network. */\n  | 'offline'\n  /** The network is up but Athena doesn't answer. */\n  | 'unreachable'\n  /** Athena answers again and what waited is being sent. */\n  | 'reconnecting'\n  /** Just back, and everything that waited was sent. Shown briefly. */\n  | 'synced';\n\n/** Where one document's edits stand, for the chip in its header. */\nexport type DocumentSyncState =\n  /** In Athena. */\n  | 'saved'\n  /** Being sent to Athena. */\n  | 'saving'\n  /** Kept on this device while Athena can't be reached; syncs when it is back. */\n  | 'on-device'\n  /** Kept only while this tab or app stays open (no device storage); syncs when Athena is back. */\n  | 'in-memory'\n  /** Sending what was kept on this device. */\n  | 'syncing'\n  /** Some changes overlap with Athena's version: the person chooses. */\n  | 'needs-review'\n  /** The document can no longer take these edits (access or state changed): kept, not sent. */\n  | 'view-only'\n  /**\n   * Athena answers but isn't taking this document's changes for now: it holds the document while it\n   * repairs it, or hasn't confirmed the latest changes for longer than usual (`SavingDelayCause`\n   * says which). Kept, and saved once Athena takes them. Never said while Athena can't be reached:\n   * that is `on-device` or `in-memory`.\n   */\n  | 'delayed';\n\n/** Why a document's saving is delayed while Athena answers (`DocumentSyncState` `delayed`). */\nexport type SavingDelayCause =\n  /** Athena holds the document while it repairs it, and takes no changes to it until then. */\n  | 'repairing'\n  /** Athena hasn't confirmed the latest changes for longer than usual. */\n  | 'unconfirmed';\n\n/** How a sentence names the device the person is on. */\nexport type DeviceNoun =\n  | 'this browser'\n  | 'this Mac'\n  | 'this computer'\n  | 'this phone'\n  | 'this tablet'\n  | 'this device';\n\n/**\n * What the app really keeps of work done while Athena can't be reached, so the\n * words never promise more: `device` (stored on the device, survives closing),\n * `memory` (kept only while this tab or app stays open: a tenant that turns\n * device copies off, or storage the app can't open), `none` (a surface that\n * keeps no work offline at all, like the Chrome side panel).\n */\nexport type OfflineKeeping = 'device' | 'memory' | 'none';\n\n/** A title and the one line under it (a banner, a sheet, a tooltip's heading). */\nexport interface StatusCopy {\n  title: string;\n  detail: string;\n}\n\n/** A short label for a chip or a disabled control, and its one-line explanation. */\nexport interface LabelCopy {\n  label: string;\n  detail: string;\n}\n\nfunction plural(count: number, one: string, many: string): string {\n  return `${count} ${count === 1 ? one : many}`;\n}\n\n/** What a tab or an app is called when work lasts only while it stays open. */\nfunction openContainer(device: DeviceNoun): string {\n  return device === 'this browser' ? 'this tab' : 'the app';\n}\n\n/** The promise after \"You're offline\" / \"Can't reach Athena\", honest to what is kept. */\nfunction keepingPromise({\n  keeping,\n  device,\n  when,\n}: {\n  keeping: OfflineKeeping;\n  device: DeviceNoun;\n  when: string;\n}): string {\n  switch (keeping) {\n    case 'device':\n      return `You can keep working. Changes are saved on ${device} and sync ${when}.`;\n    case 'memory':\n      return `You can keep working, but changes are kept only until you close ${openContainer(device)}. They sync ${when}.`;\n    case 'none':\n      return `You’re still signed in. This reconnects ${when}.`;\n  }\n}\n\n/**\n * The app-wide status line, or `null` while Athena answers and nothing waits.\n * `waiting` counts changes not in Athena yet: while `reconnecting` they are\n * being sent; while `online` they wait for something else (a copy that sends\n * when it is next opened), and the line stays until they are gone.\n * `keeping` is what the app really keeps offline (default `device`). A surface\n * that keeps nothing (`none`) has nothing to sync, so its way back is only\n * \"Back online\", never \"Syncing…\" or \"All changes synced\".\n */\nexport function connectionCopy({\n  state,\n  device,\n  waiting = 0,\n  keeping = 'device',\n}: {\n  state: ConnectionState;\n  device: DeviceNoun;\n  waiting?: number;\n  keeping?: OfflineKeeping;\n}): StatusCopy | null {\n  switch (state) {\n    case 'online':\n      return waiting > 0\n        ? {\n            title: 'Not synced yet',\n            detail: `${plural(waiting, 'change', 'changes')} on ${device} ${waiting === 1 ? 'hasn’t' : 'haven’t'} synced yet.`,\n          }\n        : null;\n    case 'offline':\n      return {\n        title: 'You’re offline',\n        detail: keepingPromise({ keeping, device, when: 'when you’re back online' }),\n      };\n    case 'unreachable':\n      return {\n        title: 'Can’t reach Athena',\n        detail: keepingPromise({ keeping, device, when: 'when Athena is back' }),\n      };\n    case 'reconnecting':\n      if (keeping === 'none') return { title: 'Back online', detail: '' };\n      return {\n        title: 'Back online',\n        detail:\n          waiting > 0 ? `Syncing ${plural(waiting, 'change', 'changes')}…` : 'Syncing…',\n      };\n    case 'synced':\n      return keeping === 'none'\n        ? { title: 'Back online', detail: '' }\n        : { title: 'All changes synced', detail: '' };\n  }\n}\n\n/**\n * The line under \"Saving delayed\": why saving waits, and what is kept meanwhile, never promising\n * more than the app keeps.\n */\nfunction savingDelayedDetail({\n  delay,\n  keeping,\n  device,\n}: {\n  delay: SavingDelayCause;\n  keeping: Exclude<OfflineKeeping, 'none'>;\n  device: DeviceNoun;\n}): string {\n  if (delay === 'repairing') {\n    return keeping === 'memory'\n      ? `You can keep working, but your changes are kept only until you close ${openContainer(device)}. They save once Athena finishes repairing this document.`\n      : `You can keep working. Your changes are kept on ${device} and save once Athena finishes repairing this document.`;\n  }\n  return keeping === 'memory'\n    ? `Athena is taking longer than usual to save your latest changes. They’re kept only until you close ${openContainer(device)}, so keep it open.`\n    : `Athena is taking longer than usual to save your latest changes. They’re kept on ${device} in the meantime.`;\n}\n\n/**\n * What `on-device` says. The desktop app on a Mac speaks as Word, Excel and PowerPoint for Mac do\n * of a cloud document whose changes wait on the Mac (Office's own title-bar words): \"Upload\n * Pending\", and \"Upload Pending (Offline)\" while Athena can't be reached. Every other app says the\n * changes are saved on its device: a browser has no such words (Word for the web can't edit\n * offline), nor does the phone.\n */\nfunction onDeviceCopy({ device, reachable }: { device: DeviceNoun; reachable: boolean }): LabelCopy {\n  if (device === 'this Mac') {\n    return {\n      label: reachable ? 'Upload Pending' : 'Upload Pending (Offline)',\n      detail: 'Upload pending. Your changes sync when Athena is back.',\n    };\n  }\n  return {\n    label: `Saved on ${device}`,\n    detail: `Saved on ${device}. Your changes sync when Athena is back.`,\n  };\n}\n\n/**\n * The chip in a document's header, and the line it explains itself with. For `delayed`, `delay`\n * says why (default `unconfirmed`) and `keeping` whether the changes are kept on the device or only\n * while the tab or app stays open (default `device`); every other state ignores both. `reachable`\n * (default `true`) is whether Athena can be reached, which only the Mac's `on-device` words read.\n */\nexport function documentSyncCopy({\n  state,\n  device,\n  delay = 'unconfirmed',\n  keeping = 'device',\n  reachable = true,\n}: {\n  state: DocumentSyncState;\n  device: DeviceNoun;\n  delay?: SavingDelayCause;\n  keeping?: Exclude<OfflineKeeping, 'none'>;\n  reachable?: boolean;\n}): LabelCopy {\n  switch (state) {\n    case 'saved':\n      return { label: 'Saved', detail: 'Saved to Athena.' };\n    case 'saving':\n      return { label: 'Saving…', detail: 'Saving to Athena.' };\n    case 'on-device':\n      return onDeviceCopy({ device, reachable });\n    case 'in-memory':\n      return {\n        label: 'Not saved yet',\n        detail: `Your changes are kept only until you close ${openContainer(device)}, and save when Athena is back.`,\n      };\n    case 'syncing':\n      return { label: 'Syncing…', detail: `Sending the changes saved on ${device}.` };\n    case 'needs-review':\n      return {\n        label: 'Review changes',\n        detail: 'Some of your changes overlap with changes made in Athena. Choose what to keep.',\n      };\n    case 'view-only':\n      return {\n        label: 'View only',\n        detail: `You can’t edit this anymore. Your changes stay on ${device}.`,\n      };\n    case 'delayed':\n      return { label: 'Saving delayed', detail: savingDelayedDetail({ delay, keeping, device }) };\n  }\n}\n\n/**\n * How long a document's edits may wait unconfirmed on a connection that is up before its saving\n * reads as delayed (`delayed`, `unconfirmed`), and before its room asks Keryx why: the stall window\n * every editor shares (`ACK_STALL_MS` in `@athenaintel/asset-host/local-updates`, which Olympus's\n * `room-sync-store.test.ts` holds equal).\n */\nexport const UNCONFIRMED_EDITS_STALL_MS = 15_000;\n\n/**\n * Whether a document's saving is delayed, and why (`DocumentSyncState` `delayed`): only while Athena\n * answers and the document's room is connected; `repairing` when Keryx refuses the room's writes\n * (quarantined while it is repaired: said at once, before anything waits), `unconfirmed` once its\n * edits have stayed unconfirmed past {@link UNCONFIRMED_EDITS_STALL_MS}; `null` otherwise. Every\n * app's chip asks it after a hold and after edits kept without a connection, and ahead of syncing\n * and saving, so a room that refuses writes never spins and being offline is never a delay.\n */\nexport function savingDelayCause({\n  reachable,\n  connected,\n  writesRefused,\n  unconfirmedStalled,\n}: {\n  /** Athena answers (the app's reachability, never the socket alone). */\n  reachable: boolean;\n  /** The document's room is connected. */\n  connected: boolean;\n  /** Keryx's document status says the room takes no writes for now. */\n  writesRefused: boolean;\n  /** Local edits have waited unconfirmed past the stall window on this connection. */\n  unconfirmedStalled: boolean;\n}): SavingDelayCause | null {\n  if (!reachable || !connected) return null;\n  if (writesRefused) return 'repairing';\n  return unconfirmedStalled ? 'unconfirmed' : null;\n}\n\n/**\n * What the person lost of a document while it was open, when the server checked its room's grant\n * again (Keryx's 4401, after a share changed): `edit`, they may still view it but no longer edit it;\n * `view`, they may no longer open it at all.\n */\nexport type AccessLoss = 'edit' | 'view';\n\n/** What a document says once the person's access changed while it was open. */\nexport interface AccessChangedCopy extends StatusCopy {\n  /**\n   * The label of the button that saves the person's version as a file of their own, with the\n   * changes Athena never took, or `null` when nothing is offered: nothing of theirs waits, or the\n   * device no longer serves the document (`view`).\n   */\n  saveCopy: string | null;\n}\n\n/**\n * What a document says once the person's access to it changed while it was open (its editor turns\n * read-only at once), in Word's own words (Word for Mac's message bar, `strman_a6d4`, and its\n * \"Permissions Have Changed\" notice, `strman_0a3e`). `keptChanges`: changes Athena never took wait\n * on the device, never sent; Word offers to save a copy of the file so nothing typed is lost. A\n * `view` loss offers nothing to save: the device stops serving a document the person may no longer\n * read, and their changes stay where they are kept.\n */\nexport function accessChangedCopy({\n  loss,\n  keptChanges,\n}: {\n  loss: AccessLoss;\n  keptChanges: boolean;\n}): AccessChangedCopy {\n  if (loss === 'view') {\n    return {\n      title: 'Permissions Have Changed',\n      detail:\n        'The permissions on this file were updated and you no longer have rights to view this file. If you previously made changes to this file, they may not be saved.',\n      saveCopy: null,\n    };\n  }\n  if (keptChanges) {\n    return {\n      title: 'Can’t save',\n      detail:\n        'You no longer have the permission to edit this file. To keep your changes, save a copy of the file.',\n      saveCopy: 'Save a Copy',\n    };\n  }\n  return {\n    title: 'Read Only',\n    detail: 'You no longer have the permission to edit this file.',\n    saveCopy: null,\n  };\n}\n\n/** When something that needs Athena works again (the second half of `NEEDS_CONNECTION`'s line). */\nconst AVAILABLE_AGAIN = 'It’s available again when you’re back online.';\n\n/**\n * The reason on a control that needs Athena (share, run, upload, invite…),\n * shown disabled while Athena can't be reached rather than failing when used.\n */\nexport const NEEDS_CONNECTION: LabelCopy = {\n  label: 'Needs a connection',\n  detail: `This needs Athena. ${AVAILABLE_AGAIN}`,\n};\n\n/** What a composer was given to attach: a photo (from the phone's library or camera) or any file. */\nexport type AttachmentKind = 'photo' | 'file';\n\n/**\n * What a composer says when a photo or file is picked, pasted or dropped while\n * Athena can't be reached. It isn't attached: only Athena can take the upload.\n * In a chat whose messages wait to be sent meanwhile (`messagesWait`: the chat\n * keeps an outbox), the message itself still goes, so that comes first. Where\n * nothing waits (the Chrome side panel, a launcher that keeps its draft), it\n * says only when attaching works again, as `NEEDS_CONNECTION` does.\n */\nexport function attachmentNeedsConnection({\n  kind,\n  messagesWait,\n}: {\n  kind: AttachmentKind;\n  messagesWait: boolean;\n}): string {\n  const attaching = `Attaching ${kind === 'photo' ? 'a photo' : 'a file'} needs Athena. ${AVAILABLE_AGAIN}`;\n  return messagesWait\n    ? `You can still send your message: it goes when Athena is back. ${attaching}`\n    : attaching;\n}\n\n/** What a sent message carries besides its text that can't wait for Athena. */\nfunction heldExtras(withQuote: boolean): string {\n  return withQuote ? 'an attachment or a quote' : 'an attachment';\n}\n\n/**\n * What a composer says when a message is sent while Athena can't be reached\n * with an attachment that never reached Athena (or, `withQuote`, a quote the\n * chat can't keep waiting). Its text could wait in the chat outbox; the\n * attachment can't, so the draft stays as it is.\n */\nexport function attachedMessageNeedsConnection({\n  withQuote = false,\n}: {\n  withQuote?: boolean;\n} = {}): string {\n  return `Your text can wait and go when Athena is back, but ${heldExtras(withQuote)} can’t. Remove ${\n    withQuote ? 'it' : 'the attachment'\n  } to send the text.`;\n}\n\n/**\n * What a composer says when a message with an attachment (or, `withQuote`, a\n * quote) is sent while messages written when Athena couldn't be reached still\n * wait to go: those go first, and this one can't wait behind them.\n */\nexport function attachedMessageBehindWaiting({\n  withQuote = false,\n}: {\n  withQuote?: boolean;\n} = {}): string {\n  return `Messages you wrote while Athena couldn’t be reached go first. A message with ${heldExtras(\n    withQuote\n  )} can’t wait behind them, so send it once they’ve gone.`;\n}\n\n/**\n * The reason on New Presentation while Athena can't be reached, in a workspace\n * whose new presentations start from its design system's template: a\n * presentation made offline starts blank, and only Athena can copy the\n * template, so none is made until it can.\n */\nexport const NEW_PRESENTATION_NEEDS_TEMPLATE: LabelCopy = {\n  label: 'Needs a connection',\n  detail:\n    'New presentations in this workspace start from its design template, which needs Athena. You can make one when you’re back online.',\n};\n\n/**\n * What a download of a spreadsheet made from an Excel Macro-Enabled Workbook\n * (`.xlsm`) says when it went without the macros because they come from Athena,\n * which can't be reached, and the device hasn't kept them (they travel with the\n * workbook and never run). The file is the workbook without them; downloading\n * it again with a connection keeps them.\n */\nexport function downloadedWithoutMacros({ device }: { device: DeviceNoun }): string {\n  return `Downloaded without the spreadsheet’s macros: they come from Athena, which can’t be reached, and ${device} hasn’t kept them. Download it again when you’re back online to keep them.`;\n}\n\n/**\n * Save's question for a spreadsheet whose file is an Excel Macro-Enabled\n * Workbook (`.xlsm`) while its macros come from Athena, which can't be reached,\n * and the device hasn't kept them: the `.xlsm` is never written without them,\n * so the person may save an Excel Workbook (`.xlsx`) beside it, and Save writes\n * the `.xlsm` again once Athena answers.\n */\nexport function macrosNeedConnectionToSave({\n  name,\n  device,\n}: {\n  name: string;\n  device: DeviceNoun;\n}): StatusCopy {\n  return {\n    title: `Athena can’t save the macros in “${name}” right now.`,\n    detail: `They come from Athena, which can’t be reached, and ${device} hasn’t kept them. Save it as an Excel Workbook (.xlsx) instead. “${name}” stays as it is, macros included, and Save writes it again when you’re back online.`,\n  };\n}\n\n/**\n * What saving a version kept on the device as a new spreadsheet says when the\n * spreadsheet was made from an Excel Macro-Enabled Workbook (`.xlsm`) and\n * Athena can't be reached: the new spreadsheet is made all the same (on the\n * device, and it syncs when Athena is back), but without the macros, which only\n * Athena can keep with a new spreadsheet (they travel with the workbook and\n * never run). The kept version stays on the device, so saving it again with a\n * connection keeps them.\n */\nexport function savedAsNewWithoutMacros({ device }: { device: DeviceNoun }): string {\n  return `The new spreadsheet was made without the macros: only Athena can keep them in a new spreadsheet, and it can’t be reached. The kept version stays on ${device}: save it as a new spreadsheet again when you’re back online to keep them.`;\n}\n\n/**\n * Whether an item opens without a connection on this device, for lists.\n * `canKeep` says whether opening it online would keep a copy here (the\n * deployment allows device copies and the item's type is one that is kept):\n * only then is the person told to open it once.\n */\nexport function offlineAvailabilityCopy({\n  available,\n  canKeep,\n  device,\n}: {\n  available: boolean;\n  canKeep: boolean;\n  device: DeviceNoun;\n}): LabelCopy {\n  if (available) {\n    return { label: 'Available offline', detail: `Opens without a connection on ${device}.` };\n  }\n  return canKeep\n    ? {\n        label: 'Not available offline',\n        detail: `Open it once while online to keep it on ${device}.`,\n      }\n    : { label: 'Not available offline', detail: 'This opens only with a connection.' };\n}\n\n/**\n * The one-time explainer shown the first time the person goes offline, on a\n * surface that keeps work there (`keeping` `device`). A surface that keeps\n * nothing (`none`: the Chrome side panel, the Office task pane) shows no\n * explainer; its status line already says all that holds.\n */\nexport function firstOfflineExplainer({ device }: { device: DeviceNoun }): StatusCopy & {\n  action: string;\n} {\n  return {\n    title: 'You can keep working offline',\n    detail: `Documents you’ve opened recently keep working on ${device}. Your changes sync when you’re back online.`,\n    action: 'Got it',\n  };\n}\n\n/**\n * The summary heading of the one \"Waiting to sync\" list, from what waits on\n * the device; `null` when nothing does.\n */\nexport function waitingSummary({\n  changes = 0,\n  messages = 0,\n  recordings = 0,\n}: {\n  changes?: number;\n  messages?: number;\n  recordings?: number;\n}): string | null {\n  const parts = [\n    changes > 0 ? plural(changes, 'change', 'changes') : null,\n    messages > 0 ? plural(messages, 'message', 'messages') : null,\n    recordings > 0 ? plural(recordings, 'recording', 'recordings') : null,\n  ].filter((part): part is string => part !== null);\n  return parts.length === 0 ? null : `Waiting to sync: ${parts.join(', ')}`;\n}\n\n/**\n * Where one item in the \"Waiting to sync\" list stands: a change, a message or a\n * recording made while Athena couldn't be reached.\n */\nexport type WaitingItemState =\n  /** Saved on the device; it syncs when Athena is back. */\n  | 'waiting'\n  /** Being sent to Athena now. */\n  | 'syncing'\n  /**\n   * Kept only while this tab or app stays open: it couldn't be saved on the\n   * device (the organization keeps nothing on devices, or storage failed).\n   */\n  | 'in-memory'\n  /**\n   * Saved on the device in something that isn't open (a document closed before\n   * its edits synced, one made offline): it syncs when it is next opened with a\n   * connection (opening it offline sends nothing).\n   */\n  | 'when-opened'\n  /** Made in another workspace: it syncs once that workspace is open again, with a connection. */\n  | 'other-workspace'\n  /** It doesn't go on its own: the person chooses (a message that waited more than a day). */\n  | 'needs-you'\n  /** Athena didn't take it: the app adds why, and what the person can do about it. */\n  | 'not-synced';\n\n/** The state of one item in the \"Waiting to sync\" list, and the line that explains it. */\nexport function waitingItemCopy({\n  state,\n  device,\n}: {\n  state: WaitingItemState;\n  device: DeviceNoun;\n}): LabelCopy {\n  switch (state) {\n    case 'waiting':\n      return {\n        label: 'Waiting to sync',\n        detail: `Saved on ${device}. It syncs when Athena is back.`,\n      };\n    case 'syncing':\n      return { label: 'Syncing…', detail: `Sending what was saved on ${device}.` };\n    case 'in-memory':\n      return {\n        label: 'Not saved yet',\n        detail: `Kept only until you close ${openContainer(device)}. It syncs when Athena is back.`,\n      };\n    case 'when-opened':\n      return {\n        label: 'Not synced yet',\n        detail: `Saved on ${device}. It syncs when you next open it with a connection.`,\n      };\n    case 'other-workspace':\n      return {\n        label: 'Waiting for its workspace',\n        detail: 'It syncs once you’re in the workspace it was made in, with a connection.',\n      };\n    case 'needs-you':\n      return { label: 'Waiting for you', detail: 'Open it to choose what happens to it.' };\n    case 'not-synced':\n      return { label: 'Couldn’t sync', detail: 'Athena didn’t take it.' };\n  }\n}\n\n/** The headings of the \"Waiting to sync\" list, one per kind of item. */\nexport const WAITING_SECTION_TITLES = {\n  changes: 'Changes',\n  messages: 'Messages',\n  recordings: 'Recordings',\n} as const;\n\n/**\n * What the person can do with an item Athena didn't take (`not-synced`) in the\n * \"Waiting to sync\" list: send it again, or delete the copy on the device. That\n * copy is the item's only one, so the app asks first (`deleteFromDeviceConfirm`)\n * and never deletes it as a side effect of anything else.\n */\nexport function notSyncedActions({ device }: { device: DeviceNoun }): {\n  retry: string;\n  remove: string;\n} {\n  return { retry: 'Try again', remove: `Delete from ${device}` };\n}\n\n/** One of `notSyncedActions`, or showing where the item is kept on the device. */\nexport type NotSyncedAction = 'retry' | 'reveal' | 'remove';\n\n/**\n * What the person hears when the device couldn't do what they asked for an\n * item Athena didn't take (its files, not Athena, failed).\n */\nexport function notSyncedActionFailed({\n  action,\n  device,\n}: {\n  action: NotSyncedAction;\n  device: DeviceNoun;\n}): string {\n  switch (action) {\n    case 'retry':\n      return 'Couldn’t send it again. Try again in a moment.';\n    case 'reveal':\n      return `Couldn’t show where it’s kept on ${device}.`;\n    case 'remove':\n      return `Couldn’t delete it from ${device}.`;\n  }\n}\n\n/**\n * The question before deleting such an item's copy on the device, naming the\n * item: the destructive choice is never the default.\n */\nexport function deleteFromDeviceConfirm({\n  name,\n  device,\n}: {\n  name: string;\n  device: DeviceNoun;\n}): StatusCopy & { confirm: string; cancel: string } {\n  return {\n    title: `Delete “${name}” from ${device}?`,\n    detail: 'Athena didn’t take it, so this is its only copy. Deleting it can’t be undone.',\n    confirm: 'Delete',\n    cancel: 'Cancel',\n  };\n}\n"],"names":[],"mappings":"AA6QO,MAAM,6BAA6B;AAsF1C,MAAM,kBAAkB;AAMjB,MAAM,mBAA8B;AAAA,EACzC,OAAO;AAAA,EACP,QAAQ,sBAAsB,eAAe;AAC/C;AAaO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AACF,GAGW;AACT,QAAM,YAAY,aAA4C,QAAQ,kBAAkB,eAAe;AACvG,SAAO,eACH,iEAAiE,SAAS,KAC1E;AACN;AAGA,SAAS,WAAW,WAA4B;AAC9C,SAAO,YAAY,6BAA6B;AAClD;AAQO,SAAS,+BAA+B;AAAA,EAC7C,YAAY;AACd,IAEI,IAAY;AACd,SAAO,sDAAsD,WAAW,SAAS,CAAC,kBAChF,YAAY,OAAO,gBACrB;AACF;AAOO,SAAS,6BAA6B;AAAA,EAC3C,YAAY;AACd,IAEI,IAAY;AACd,SAAO,gFAAgF;AAAA,IACrF;AAAA,EAAA,CACD;AACH;"}

package/dist/agent-runtime/src/use-deep-agent-thread.cjs

@@ -8,6 +8,7 @@ const deepAgentTransportRecipe = require("./deep-agent-transport-recipe.cjs");
 const errors = require("./errors.cjs");
 const messageAuthor = require("./message-author.cjs");
 const runconfigContract = require("./generated/runconfig-contract.cjs");
+const historyPages = require("./history-pages.cjs");
 const messageWindow = require("./message-window.cjs");
 const messages = require("./messages.cjs");
 const protocol = require("./protocol.cjs");
@@ -58,6 +59,7 @@ function useDeepAgentThread({
   readMessageWindow = messageWindow.readDeepAgentMessageWindow,
   createConversionCache = messages.createDeepAgentMessageConversionCache,
   toolOutputs,
+  historyStore,
   withdrawnTurns,
   prewarmPool,
   onAttachTiming,
@@ -108,6 +110,11 @@ function useDeepAgentThread({
     if (!toolOutputs) return void 0;
     return toolOutputs.subscribe(() => setToolOutputsVersion((version) => version + 1));
   }, [toolOutputs]);
+  const [historyVersion, setHistoryVersion] = require$$0.useState(0);
+  require$$0.useEffect(() => {
+    if (!historyStore) return void 0;
+    return historyStore.subscribe(() => setHistoryVersion((version) => version + 1));
+  }, [historyStore]);
   const [withdrawnTurnsVersion, setWithdrawnTurnsVersion] = require$$0.useState(0);
   require$$0.useEffect(() => {
     if (!withdrawnTurns) return void 0;
@@ -272,10 +279,17 @@ function useDeepAgentThread({
       const values = statewireState.readDeepAgentStreamValues(wireState);
       const window = readMessageWindow(meta.mounted);
       const held = ((_a2 = lastMessagesRef.current) == null ? void 0 : _a2.attachId) === attachId ? lastMessagesRef.current.messages : null;
-      const messages2 = (window == null ? void 0 : window.messages) ?? values.messages ?? held ?? [];
+      const live = (window == null ? void 0 : window.messages) ?? values.messages ?? held ?? [];
+      const paged = historyStore && window !== null ? historyStore.join({
+        threadId: window.threadId,
+        live,
+        liveIds: new Set(window.chain.map((entry) => entry.id))
+      }) : null;
+      const messages2 = (paged == null ? void 0 : paged.messages) ?? live;
       if (window !== null || messages2.length > 0) lastMessagesRef.current = { attachId, messages: messages2 };
       if (window !== null) heldViewRef.current = { attachId, mounted: meta.mounted };
       const state = { ...values, messages: [...messages2] };
+      if (paged == null ? void 0 : paged.atStart) state[historyPages.DEEP_AGENT_HISTORY_START_KEY] = true;
       statewireState.pairDeepAgentStateWithThread({ state, threadId });
       materialize(state);
       const joined = state.messages ?? [];
@@ -362,7 +376,7 @@ function useDeepAgentThread({
       }
       return converter(state, ((_g = (_f = state.runs) == null ? void 0 : _f[0]) == null ? void 0 : _g.status) === "running", conversionCache);
     },
-    [attachId, conversionCache, converter, materialize, readMessageWindow, threadId]
+    [attachId, conversionCache, converter, historyStore, historyVersion, materialize, readMessageWindow, threadId]
   );
   const thread = reactStatewire.StatewireThread({
     // The transport stamps this protocol on every command; the thread client