@athenaintel/react 0.57.2 → 0.60.0

package/dist/agent-runtime/src/named-agents.js

@@ -0,0 +1,301 @@
+import { useSyncExternalStore } from "react";
+import { withAddressedAgents, readAddressedAgents } from "./addressed-agents.js";
+const MAX_DEEP_AGENT_NAMED_AGENTS = 8;
+const OWN_ASSISTANT_AGENT_REF = "assistant";
+const COLLAB_AGENT_REF_PREFIX = "collab_agent:";
+const NO_NAMED_AGENTS = Object.freeze([]);
+function normalizeNamedAgents(agents) {
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const agent of agents) {
+    const ref = agent.ref.trim();
+    if (!ref || seen.has(ref)) continue;
+    seen.add(ref);
+    normalized.push(ref === agent.ref ? agent : { ...agent, ref });
+    if (normalized.length === MAX_DEEP_AGENT_NAMED_AGENTS) break;
+  }
+  return normalized.length === 0 ? NO_NAMED_AGENTS : normalized;
+}
+function sameNamedAgents(a, b) {
+  return a.length === b.length && a.every(
+    (agent, index) => {
+      var _a, _b, _c;
+      return agent.ref === ((_a = b[index]) == null ? void 0 : _a.ref) && agent.name === ((_b = b[index]) == null ? void 0 : _b.name) && agent.assetId === ((_c = b[index]) == null ? void 0 : _c.assetId);
+    }
+  );
+}
+function namedAgentRefs(agents) {
+  const refs = [];
+  for (const agent of agents) {
+    const ref = agent.ref.trim();
+    if (!ref || refs.includes(ref)) continue;
+    refs.push(ref);
+    if (refs.length === MAX_DEEP_AGENT_NAMED_AGENTS) break;
+  }
+  return refs;
+}
+function setBounded(map, key, value, limit) {
+  map.delete(key);
+  map.set(key, value);
+  while (map.size > limit) {
+    const oldest = map.keys().next();
+    if (oldest.done) break;
+    map.delete(oldest.value);
+  }
+}
+function createNamedAgentsStore(initial) {
+  let state = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    get state() {
+      return state;
+    },
+    setState(update) {
+      const next = update(state);
+      if (Object.is(next, state)) return;
+      state = next;
+      for (const listener of [...listeners]) listener();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+const deepAgentNamedAgentsStore = createNamedAgentsStore({
+  byThread: {}
+});
+const namedAgentsSeen = /* @__PURE__ */ new Map();
+const NAMED_AGENTS_SEEN_KEPT = 200;
+function writeNamedAgents(threadId, agents) {
+  for (const agent of agents) setBounded(namedAgentsSeen, agent.ref, agent, NAMED_AGENTS_SEEN_KEPT);
+  deepAgentNamedAgentsStore.setState((state) => {
+    if (sameNamedAgents(state.byThread[threadId] ?? NO_NAMED_AGENTS, agents)) return state;
+    const byThread = { ...state.byThread };
+    if (agents.length === 0) delete byThread[threadId];
+    else byThread[threadId] = agents;
+    return { byThread };
+  });
+}
+function useDeepAgentNamedAgents(threadId) {
+  const read = () => readDeepAgentNamedAgents(threadId);
+  return useSyncExternalStore(deepAgentNamedAgentsStore.subscribe, read, read);
+}
+function readDeepAgentNamedAgents(threadId) {
+  return deepAgentNamedAgentsStore.state.byThread[threadId] ?? NO_NAMED_AGENTS;
+}
+function addDeepAgentNamedAgent({
+  threadId,
+  agent
+}) {
+  const current = readDeepAgentNamedAgents(threadId);
+  const ref = agent.ref.trim();
+  if (!threadId || !ref || current.length >= MAX_DEEP_AGENT_NAMED_AGENTS || current.some((named) => named.ref === ref)) {
+    return false;
+  }
+  writeNamedAgents(threadId, normalizeNamedAgents([...current, agent]));
+  return true;
+}
+function removeDeepAgentNamedAgent({
+  threadId,
+  ref
+}) {
+  const current = readDeepAgentNamedAgents(threadId);
+  if (!current.some((agent) => agent.ref === ref)) return;
+  writeNamedAgents(threadId, normalizeNamedAgents(current.filter((agent) => agent.ref !== ref)));
+}
+const SENT_TEXTS_KEPT_PER_THREAD = 20;
+const THREADS_WITH_SENT_TEXTS_KEPT = 50;
+const WITHDRAWAL_RESTORES_KEPT = 20;
+const sentTextNamedAgents = /* @__PURE__ */ new Map();
+const withdrawalRestores = /* @__PURE__ */ new Map();
+function rememberDeepAgentSentNamedAgents({
+  threadId,
+  text,
+  agents
+}) {
+  if (!threadId) return;
+  const named = normalizeNamedAgents(agents);
+  const texts = sentTextNamedAgents.get(threadId);
+  if (named.length === 0) {
+    texts == null ? void 0 : texts.delete(text);
+    return;
+  }
+  const kept = texts ?? /* @__PURE__ */ new Map();
+  setBounded(kept, text, named, SENT_TEXTS_KEPT_PER_THREAD);
+  setBounded(sentTextNamedAgents, threadId, kept, THREADS_WITH_SENT_TEXTS_KEPT);
+}
+function restoreDeepAgentSentNamedAgents({
+  threadId,
+  text,
+  withdrawnMessageId
+}) {
+  var _a;
+  const named = ((_a = sentTextNamedAgents.get(threadId)) == null ? void 0 : _a.get(text)) ?? NO_NAMED_AGENTS;
+  const restored = named.filter((agent) => addDeepAgentNamedAgent({ threadId, agent }));
+  if (withdrawnMessageId !== void 0 && restored.length > 0) {
+    setBounded(
+      withdrawalRestores,
+      withdrawnMessageId,
+      { threadId, agents: restored },
+      WITHDRAWAL_RESTORES_KEPT
+    );
+  }
+  return restored;
+}
+const NAMED_AGENTS_STAGED_TTL_MS = 1e4;
+const stagedForSend = /* @__PURE__ */ new Map();
+function stageDeepAgentNamedAgentsForSend({
+  threadId,
+  agents
+}) {
+  if (!threadId) return;
+  const refs = namedAgentRefs(agents);
+  if (refs.length === 0) {
+    stagedForSend.delete(threadId);
+    return;
+  }
+  stagedForSend.set(threadId, { refs, stagedAt: Date.now() });
+}
+function takeStagedDeepAgentNamedAgents(threadId) {
+  const staged = stagedForSend.get(threadId);
+  stagedForSend.delete(threadId);
+  if (staged === void 0 || Date.now() - staged.stagedAt > NAMED_AGENTS_STAGED_TTL_MS) {
+    return void 0;
+  }
+  return staged.refs;
+}
+function stagedNamedAgentsMessageMetadata(threadId) {
+  return withAddressedAgents(void 0, takeStagedDeepAgentNamedAgents(threadId));
+}
+function deepAgentOutboxAddressedAgents(agents) {
+  const refs = namedAgentRefs(agents);
+  return refs.length === 0 ? void 0 : refs;
+}
+function namedAgentsForRefsSeen(refs) {
+  const agents = [];
+  for (const ref of refs) {
+    const seen = namedAgentsSeen.get(ref);
+    if (seen) agents.push(seen);
+    else if (ref === OWN_ASSISTANT_AGENT_REF) {
+      agents.push({ ref, name: OWN_ASSISTANT_DISPLAY_NAME, assetId: null });
+    } else if (ref.startsWith(COLLAB_AGENT_REF_PREFIX)) {
+      agents.push({ ref, name: "Untitled agent", assetId: ref.slice(COLLAB_AGENT_REF_PREFIX.length) });
+    }
+  }
+  return agents;
+}
+function giveBackDeepAgentOutboxNamedAgents(entry, {
+  namedAgentsForRefs = namedAgentsForRefsSeen
+} = {}) {
+  const refs = readAddressedAgents(entry.metadata);
+  if (!refs || refs.length === 0) return NO_NAMED_AGENTS;
+  return namedAgentsForRefs(refs).filter(
+    (agent) => addDeepAgentNamedAgent({ threadId: entry.threadId, agent })
+  );
+}
+function chatAgentNamingOffered({ isAdmin }) {
+  return isAdmin;
+}
+const OWN_ASSISTANT_DISPLAY_NAME = "Athena";
+const OWN_ASSISTANT_OFFERED_AGENT = Object.freeze({
+  ref: OWN_ASSISTANT_AGENT_REF,
+  name: OWN_ASSISTANT_DISPLAY_NAME,
+  assetId: null,
+  icon: "Bot"
+});
+function collabAgentOfferedAgent({
+  assetId,
+  name,
+  icon
+}) {
+  return {
+    ref: `${COLLAB_AGENT_REF_PREFIX}${assetId}`,
+    name: name || "Untitled agent",
+    assetId,
+    icon: icon || "Bot"
+  };
+}
+function offeredDeepAgentNamedAgents({
+  collabAgents,
+  named
+}) {
+  if (named.length >= MAX_DEEP_AGENT_NAMED_AGENTS) return [];
+  const taken = new Set(named.map((agent) => agent.ref));
+  const offered = [];
+  for (const agent of [OWN_ASSISTANT_OFFERED_AGENT, ...collabAgents]) {
+    if (taken.has(agent.ref)) continue;
+    taken.add(agent.ref);
+    offered.push(agent);
+  }
+  return offered;
+}
+function namedAgentsLimitMessage(leftOut) {
+  const names = new Intl.ListFormat("en", { style: "long", type: "conjunction" }).format(leftOut);
+  return `A message names at most ${MAX_DEEP_AGENT_NAMED_AGENTS} agents, so ${names} ${leftOut.length === 1 ? "wasn't" : "weren't"} added.`;
+}
+function nameDeepAgentMentionedAgents({
+  threadId,
+  agents
+}) {
+  const leftOut = [];
+  for (const agent of agents) {
+    const named = readDeepAgentNamedAgents(threadId);
+    if (named.some((entry) => entry.ref === agent.ref.trim())) continue;
+    if (named.length >= MAX_DEEP_AGENT_NAMED_AGENTS) {
+      leftOut.push(agent.name);
+      continue;
+    }
+    addDeepAgentNamedAgent({
+      threadId,
+      agent: { ref: agent.ref, name: agent.name, assetId: agent.assetId }
+    });
+  }
+  return leftOut;
+}
+let namedAgentsIdentity = null;
+function forgetAllDeepAgentNamedAgents() {
+  stagedForSend.clear();
+  sentTextNamedAgents.clear();
+  withdrawalRestores.clear();
+  namedAgentsSeen.clear();
+  namedAgentsIdentity = null;
+  deepAgentNamedAgentsStore.setState(() => ({ byThread: {} }));
+}
+function keepDeepAgentNamedAgentsForIdentity(identity) {
+  if (namedAgentsIdentity !== null && namedAgentsIdentity !== identity) {
+    forgetAllDeepAgentNamedAgents();
+  }
+  namedAgentsIdentity = identity;
+}
+export {
+  COLLAB_AGENT_REF_PREFIX,
+  MAX_DEEP_AGENT_NAMED_AGENTS,
+  NAMED_AGENTS_STAGED_TTL_MS,
+  OWN_ASSISTANT_AGENT_REF,
+  OWN_ASSISTANT_DISPLAY_NAME,
+  OWN_ASSISTANT_OFFERED_AGENT,
+  addDeepAgentNamedAgent,
+  chatAgentNamingOffered,
+  collabAgentOfferedAgent,
+  deepAgentNamedAgentsStore,
+  deepAgentOutboxAddressedAgents,
+  forgetAllDeepAgentNamedAgents,
+  giveBackDeepAgentOutboxNamedAgents,
+  keepDeepAgentNamedAgentsForIdentity,
+  nameDeepAgentMentionedAgents,
+  namedAgentRefs,
+  namedAgentsLimitMessage,
+  offeredDeepAgentNamedAgents,
+  readDeepAgentNamedAgents,
+  rememberDeepAgentSentNamedAgents,
+  removeDeepAgentNamedAgent,
+  restoreDeepAgentSentNamedAgents,
+  stageDeepAgentNamedAgentsForSend,
+  stagedNamedAgentsMessageMetadata,
+  takeStagedDeepAgentNamedAgents,
+  useDeepAgentNamedAgents
+};
+//# sourceMappingURL=named-agents.js.map

package/dist/agent-runtime/src/named-agents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"named-agents.js","sources":["../../../../agent-runtime/src/named-agents.ts"],"sourcesContent":["import { useSyncExternalStore } from 'react';\nimport { ADDRESSED_AGENTS_METADATA_KEY, readAddressedAgents, withAddressedAgents } from './addressed-agents';\nimport type { ChatOutboxEntry } from './chat-outbox-entry';\n\n/**\n * The agents a message names (identity v7 D13): one conversation has many participants, and\n * each message goes to the agents it names, each answering in its own turn, in the order named.\n * agora reads the names from the message itself (`message.metadata.addressedAgents`,\n * `addressed-agents.ts`) ahead of the run config's `addressed_agents`, and checks every one of them\n * (the collab overlay's VIEW gate, a colleague's assistant refused, the history re-check), so the\n * client only presents what the person can pick and never gates.\n *\n * Every chat that names agents runs on this one module: Olympus's deep-agent composer (whose\n * `deep-agent-named-agents.ts` re-exports it) and the SDK's `AthenaChat` (and so Athena Desktop),\n * so naming an agent means the same thing, and reaches agora as the same payload, in both. What a\n * composer's `@` menu offers to name is {@link offeredDeepAgentNamedAgents}.\n *\n * - **The chips.** The agents the composer's To line names for each thread, in the order named\n *   (`set` / `add` / `remove` / `clear`, read with {@link useDeepAgentNamedAgents}). They stay\n *   for every message until the person changes them. Anything may set a thread's chips; its\n *   composer shows them. Kept in memory for the page, and dropped when the signed-in identity\n *   changes ({@link keepDeepAgentNamedAgentsForIdentity}).\n * - **The send.** statewire captures a new message's metadata once, as it journals it\n *   (`getMessageMetadata`), without saying which message it is for. So the composer stages the\n *   chips for its next send right before `aui.composer.send`\n *   ({@link stageDeepAgentNamedAgentsForSend}), and the runtime's getter takes them for the message\n *   that follows ({@link takeStagedDeepAgentNamedAgents}, {@link stagedNamedAgentsMessageMetadata}).\n *   The names then travel with the message: a send that waits, is retried after a failure, or is\n *   posted again by a page reloaded meanwhile names its own agents, whatever the conversation's\n *   context says by then, so no send waits for another's. A slot nobody takes expires.\n * - **The chat outbox.** A message held while Athena can't be reached carries its names on its\n *   message the same way (`ChatOutbox.hold({ addressedAgents })`,\n *   {@link deepAgentOutboxAddressedAgents}); its Cancel gives them back as chips with its text\n *   ({@link giveBackDeepAgentOutboxNamedAgents}).\n *\n * Text a send carried that comes back to the composer (a failed send handed back, an early Stop)\n * brings its chips back ({@link restoreDeepAgentSentNamedAgents}).\n *\n * State is per copy of this module: Olympus runs agent-runtime from source, and the SDK bundles\n * its own copy, whose composer and runtime share it.\n */\n\n/**\n * The message metadata key of the agents a message names (agora:\n * `agent_refs.ADDRESSED_AGENTS_METADATA_KEY`, read in place of the run config's and never kept on\n * the turn the transcript records).\n */\nexport const DEEP_AGENT_MESSAGE_ADDRESSED_AGENTS_KEY = ADDRESSED_AGENTS_METADATA_KEY;\n\nexport interface DeepAgentNamedAgent {\n  /** What the send names: `collab_agent:<asset id>`, or `assistant` (the sender's own assistant). */\n  ref: string;\n  /** What the chip shows. */\n  name: string;\n  /** The collab agent asset behind `ref`; `null` for the sender's own assistant. */\n  assetId: string | null;\n}\n\n/** agora takes at most this many names on one message. */\nexport const MAX_DEEP_AGENT_NAMED_AGENTS = 8;\n\n/** The ref of the sender's own assistant. */\nexport const OWN_ASSISTANT_AGENT_REF = 'assistant';\n\n/** The prefix of a collab agent's ref (`collab_agent:<asset id>`). */\nexport const COLLAB_AGENT_REF_PREFIX = 'collab_agent:';\n\nconst NO_NAMED_AGENTS: readonly DeepAgentNamedAgent[] = Object.freeze([]);\n\n/** Each agent once (by ref, the first kept), in the order named, at most eight; blank refs dropped. */\nfunction normalizeNamedAgents(\n  agents: readonly DeepAgentNamedAgent[]\n): readonly DeepAgentNamedAgent[] {\n  const seen = new Set<string>();\n  const normalized: DeepAgentNamedAgent[] = [];\n  for (const agent of agents) {\n    const ref = agent.ref.trim();\n    if (!ref || seen.has(ref)) continue;\n    seen.add(ref);\n    normalized.push(ref === agent.ref ? agent : { ...agent, ref });\n    if (normalized.length === MAX_DEEP_AGENT_NAMED_AGENTS) break;\n  }\n  return normalized.length === 0 ? NO_NAMED_AGENTS : normalized;\n}\n\nfunction sameNamedAgents(\n  a: readonly DeepAgentNamedAgent[],\n  b: readonly DeepAgentNamedAgent[]\n): boolean {\n  return (\n    a.length === b.length &&\n    a.every(\n      (agent, index) =>\n        agent.ref === b[index]?.ref &&\n        agent.name === b[index]?.name &&\n        agent.assetId === b[index]?.assetId\n    )\n  );\n}\n\n/** The refs a message naming `agents` sends: in the order named, each once, at most eight. */\nexport function namedAgentRefs(agents: readonly Pick<DeepAgentNamedAgent, 'ref'>[]): string[] {\n  const refs: string[] = [];\n  for (const agent of agents) {\n    const ref = agent.ref.trim();\n    if (!ref || refs.includes(ref)) continue;\n    refs.push(ref);\n    if (refs.length === MAX_DEEP_AGENT_NAMED_AGENTS) break;\n  }\n  return refs;\n}\n\n/** What a send naming `agents` names, as one key: two sends name the same agents when equal. */\nexport function namedAgentsKey(agents: readonly Pick<DeepAgentNamedAgent, 'ref'>[]): string {\n  return namedAgentRefs(agents).join('\\n');\n}\n\n/**\n * Named agents read back from storage (a draft kept across a reload, a message waiting in the chat\n * outbox): a list of `{ ref, name, assetId }` with a non-empty ref and name and an asset id that is\n * a string or `null`, each agent once, at most eight. Anything else reads as naming none, entry by\n * entry, so a newer build's extra fields never break an older reader.\n */\nexport function parseDeepAgentNamedAgents(value: unknown): readonly DeepAgentNamedAgent[] {\n  if (!Array.isArray(value)) return NO_NAMED_AGENTS;\n  const agents: DeepAgentNamedAgent[] = [];\n  for (const item of value) {\n    if (typeof item !== 'object' || item === null) continue;\n    const ref: unknown = Reflect.get(item, 'ref');\n    const name: unknown = Reflect.get(item, 'name');\n    const assetId: unknown = Reflect.get(item, 'assetId');\n    if (typeof ref !== 'string' || !ref.trim() || typeof name !== 'string' || !name.trim())\n      continue;\n    if (assetId !== null && typeof assetId !== 'string') continue;\n    agents.push({ ref, name, assetId });\n  }\n  return normalizeNamedAgents(agents);\n}\n\n/** A small map that keeps its newest `limit` entries (insertion order is age). */\nfunction setBounded<K, V>(map: Map<K, V>, key: K, value: V, limit: number): void {\n  map.delete(key);\n  map.set(key, value);\n  while (map.size > limit) {\n    const oldest = map.keys().next();\n    if (oldest.done) break;\n    map.delete(oldest.value);\n  }\n}\n\n// ── The stores ──────────────────────────────────────────────────────────────\n\n/** A value its readers follow: a write that changes it tells every listener, synchronously. */\nexport interface NamedAgentsStore<T> {\n  readonly state: T;\n  /** Replace the value with what `update` returns; returning the value it was given changes nothing. */\n  setState: (update: (state: T) => T) => void;\n  /** Called after every change; returns the unsubscribe function. */\n  subscribe: (listener: () => void) => () => void;\n}\n\nfunction createNamedAgentsStore<T>(initial: T): NamedAgentsStore<T> {\n  let state = initial;\n  const listeners = new Set<() => void>();\n  return {\n    get state() {\n      return state;\n    },\n    setState(update) {\n      const next = update(state);\n      if (Object.is(next, state)) return;\n      state = next;\n      for (const listener of [...listeners]) listener();\n    },\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n  };\n}\n\n// ── The chips ───────────────────────────────────────────────────────────────\n\ninterface DeepAgentNamedAgentsState {\n  /** Each thread's named agents (its composer's chips), in the order named. */\n  byThread: Readonly<Record<string, readonly DeepAgentNamedAgent[]>>;\n}\n\nexport const deepAgentNamedAgentsStore = createNamedAgentsStore<DeepAgentNamedAgentsState>({\n  byThread: {},\n});\n\n// process-local: client-only — the last name and asset this page gave each agent it named, so a\n// message given back with only its refs comes back with the chips it was sent with.\nconst namedAgentsSeen = new Map<string, DeepAgentNamedAgent>();\nconst NAMED_AGENTS_SEEN_KEPT = 200;\n\nfunction writeNamedAgents(threadId: string, agents: readonly DeepAgentNamedAgent[]): void {\n  for (const agent of agents) setBounded(namedAgentsSeen, agent.ref, agent, NAMED_AGENTS_SEEN_KEPT);\n  deepAgentNamedAgentsStore.setState((state) => {\n    if (sameNamedAgents(state.byThread[threadId] ?? NO_NAMED_AGENTS, agents)) return state;\n    const byThread = { ...state.byThread };\n    if (agents.length === 0) delete byThread[threadId];\n    else byThread[threadId] = agents;\n    return { byThread };\n  });\n}\n\n/** The agents `threadId`'s composer names for its next message, in the order named. */\nexport function useDeepAgentNamedAgents(threadId: string): readonly DeepAgentNamedAgent[] {\n  const read = (): readonly DeepAgentNamedAgent[] => readDeepAgentNamedAgents(threadId);\n  return useSyncExternalStore(deepAgentNamedAgentsStore.subscribe, read, read);\n}\n\n/** Imperative read of {@link useDeepAgentNamedAgents} (for send paths and handlers). */\nexport function readDeepAgentNamedAgents(threadId: string): readonly DeepAgentNamedAgent[] {\n  return deepAgentNamedAgentsStore.state.byThread[threadId] ?? NO_NAMED_AGENTS;\n}\n\n/**\n * Listen for `threadId`'s chips changing (the composer keeps them with its draft). Another\n * thread's change notifies nothing. Returns the unsubscribe function.\n */\nexport function subscribeDeepAgentNamedAgents({\n  threadId,\n  listener,\n}: {\n  threadId: string;\n  listener: () => void;\n}): () => void {\n  let agents = readDeepAgentNamedAgents(threadId);\n  return deepAgentNamedAgentsStore.subscribe(() => {\n    const next = readDeepAgentNamedAgents(threadId);\n    if (next === agents) return;\n    agents = next;\n    listener();\n  });\n}\n\n/** Name exactly `agents` for `threadId`'s next message (each once, in order, at most eight). */\nexport function setDeepAgentNamedAgents({\n  threadId,\n  agents,\n}: {\n  threadId: string;\n  agents: readonly DeepAgentNamedAgent[];\n}): void {\n  if (!threadId) return;\n  writeNamedAgents(threadId, normalizeNamedAgents(agents));\n}\n\n/**\n * Name one more agent, after those already named. `false` when nothing changed: it is named\n * already, eight are named, or its ref is blank.\n */\nexport function addDeepAgentNamedAgent({\n  threadId,\n  agent,\n}: {\n  threadId: string;\n  agent: DeepAgentNamedAgent;\n}): boolean {\n  const current = readDeepAgentNamedAgents(threadId);\n  const ref = agent.ref.trim();\n  if (\n    !threadId ||\n    !ref ||\n    current.length >= MAX_DEEP_AGENT_NAMED_AGENTS ||\n    current.some((named) => named.ref === ref)\n  ) {\n    return false;\n  }\n  writeNamedAgents(threadId, normalizeNamedAgents([...current, agent]));\n  return true;\n}\n\nexport function removeDeepAgentNamedAgent({\n  threadId,\n  ref,\n}: {\n  threadId: string;\n  ref: string;\n}): void {\n  const current = readDeepAgentNamedAgents(threadId);\n  if (!current.some((agent) => agent.ref === ref)) return;\n  writeNamedAgents(threadId, normalizeNamedAgents(current.filter((agent) => agent.ref !== ref)));\n}\n\nexport function clearDeepAgentNamedAgents({ threadId }: { threadId: string }): void {\n  writeNamedAgents(threadId, NO_NAMED_AGENTS);\n}\n\n/**\n * Clear `threadId`'s chips once the message that named `agents` has left, but only while they\n * still are those agents: names changed since the message was sent (while it waited behind a\n * loading conversation) belong to the next message and stay. Returns whether they were cleared.\n */\nexport function clearDeepAgentNamedAgentsIfUnchanged({\n  threadId,\n  agents,\n}: {\n  threadId: string;\n  agents: readonly DeepAgentNamedAgent[];\n}): boolean {\n  const current = readDeepAgentNamedAgents(threadId);\n  if (current.length === 0) return false;\n  if (namedAgentRefs(current).join('\\n') !== namedAgentRefs(agents).join('\\n')) return false;\n  clearDeepAgentNamedAgents({ threadId });\n  return true;\n}\n\n// ── Text that comes back to the composer ────────────────────────────────────\n\n/** How many sent texts each thread remembers the names of, and how many threads. */\nconst SENT_TEXTS_KEPT_PER_THREAD = 20;\nconst THREADS_WITH_SENT_TEXTS_KEPT = 50;\nconst WITHDRAWAL_RESTORES_KEPT = 20;\n\n// process-local: client-only — the names each recent send carried, per thread by its sent text\n// (the verbatim text the runtime hands back), so text that comes back brings its chips back.\nconst sentTextNamedAgents = new Map<string, Map<string, readonly DeepAgentNamedAgent[]>>();\n\n// process-local: client-only — the chips an early Stop gave back, by the withdrawn message, so a\n// contradicted withdrawal takes them away again.\nconst withdrawalRestores = new Map<\n  string,\n  { threadId: string; agents: readonly DeepAgentNamedAgent[] }\n>();\n\n/** Remember the names a send of `text` carried (a send naming none forgets earlier ones). */\nexport function rememberDeepAgentSentNamedAgents({\n  threadId,\n  text,\n  agents,\n}: {\n  threadId: string;\n  text: string;\n  agents: readonly DeepAgentNamedAgent[];\n}): void {\n  if (!threadId) return;\n  const named = normalizeNamedAgents(agents);\n  const texts = sentTextNamedAgents.get(threadId);\n  if (named.length === 0) {\n    texts?.delete(text);\n    return;\n  }\n  const kept = texts ?? new Map<string, readonly DeepAgentNamedAgent[]>();\n  setBounded(kept, text, named, SENT_TEXTS_KEPT_PER_THREAD);\n  setBounded(sentTextNamedAgents, threadId, kept, THREADS_WITH_SENT_TEXTS_KEPT);\n}\n\n/**\n * Text a send carried came back to `threadId`'s composer (a failed send handed back, an early\n * Stop): the names it carried come back as chips, after any named since (each once, at most\n * eight). `withdrawnMessageId` marks an early Stop's turn, whose chips go again if the run\n * answers it after all ({@link undoDeepAgentWithdrawalNamedAgents}). Returns the agents put back.\n */\nexport function restoreDeepAgentSentNamedAgents({\n  threadId,\n  text,\n  withdrawnMessageId,\n}: {\n  threadId: string;\n  text: string;\n  withdrawnMessageId?: string;\n}): readonly DeepAgentNamedAgent[] {\n  const named = sentTextNamedAgents.get(threadId)?.get(text) ?? NO_NAMED_AGENTS;\n  const restored = named.filter((agent) => addDeepAgentNamedAgent({ threadId, agent }));\n  if (withdrawnMessageId !== undefined && restored.length > 0) {\n    setBounded(\n      withdrawalRestores,\n      withdrawnMessageId,\n      { threadId, agents: restored },\n      WITHDRAWAL_RESTORES_KEPT\n    );\n  }\n  return restored;\n}\n\n/**\n * The run answered a turn its sender took back after all (an early Stop contradicted): the chips\n * that came back with its text go again, except any taken off since.\n */\nexport function undoDeepAgentWithdrawalNamedAgents({ messageId }: { messageId: string }): void {\n  const restore = withdrawalRestores.get(messageId);\n  if (!restore) return;\n  withdrawalRestores.delete(messageId);\n  for (const agent of restore.agents) {\n    removeDeepAgentNamedAgent({ threadId: restore.threadId, ref: agent.ref });\n  }\n}\n\n/** A withdrawal settled without undoing its restore (the editor changed since): forget it. */\nexport function forgetDeepAgentWithdrawalNamedAgents({ messageId }: { messageId: string }): void {\n  withdrawalRestores.delete(messageId);\n}\n\n// ── The send ────────────────────────────────────────────────────────────────\n\n/** How long staged names wait for the message they were staged for before they expire. */\nexport const NAMED_AGENTS_STAGED_TTL_MS = 10_000;\n\n// process-local: client-only — the names each thread's composer staged for the message it submits\n// next, taken once by the runtime's `getMessageMetadata`.\nconst stagedForSend = new Map<string, { refs: readonly string[]; stagedAt: number }>();\n\n/**\n * Stage `agents` as the names of the message `threadId`'s composer submits next. Call right before\n * the send (`aui.composer.send`): the runtime's `getMessageMetadata` takes them for that message\n * ({@link takeStagedDeepAgentNamedAgents}). A send naming none stages nothing and lets an earlier\n * slot go.\n */\nexport function stageDeepAgentNamedAgentsForSend({\n  threadId,\n  agents,\n}: {\n  threadId: string;\n  agents: readonly DeepAgentNamedAgent[];\n}): void {\n  if (!threadId) return;\n  const refs = namedAgentRefs(agents);\n  if (refs.length === 0) {\n    stagedForSend.delete(threadId);\n    return;\n  }\n  stagedForSend.set(threadId, { refs, stagedAt: Date.now() });\n}\n\n/**\n * The refs staged for the message `threadId` journals now, taking the slot (`undefined`: none\n * staged, or staged more than {@link NAMED_AGENTS_STAGED_TTL_MS} ago).\n */\nexport function takeStagedDeepAgentNamedAgents(threadId: string): readonly string[] | undefined {\n  const staged = stagedForSend.get(threadId);\n  stagedForSend.delete(threadId);\n  if (staged === undefined || Date.now() - staged.stagedAt > NAMED_AGENTS_STAGED_TTL_MS) {\n    return undefined;\n  }\n  return staged.refs;\n}\n\n/**\n * The metadata of the message `threadId` journals now, for a runtime's `getMessageMetadata` (the\n * SDK's): the names staged for it under {@link DEEP_AGENT_MESSAGE_ADDRESSED_AGENTS_KEY}, taking the\n * slot, or `undefined` when none are staged (the message then names none of its own). Olympus's\n * runtime takes the slot itself, falling back to the conversation's default agent.\n */\nexport function stagedNamedAgentsMessageMetadata(\n  threadId: string\n): Record<string, unknown> | undefined {\n  return withAddressedAgents(undefined, takeStagedDeepAgentNamedAgents(threadId));\n}\n\n// ── The chat outbox ─────────────────────────────────────────────────────────\n\n/**\n * The agents a message held in the chat outbox names (`ChatOutbox.hold`'s `addressedAgents`, kept\n * on its message): its chips' refs, or `undefined` when it names none (it then goes out as a send\n * naming none does).\n */\nexport function deepAgentOutboxAddressedAgents(\n  agents: readonly DeepAgentNamedAgent[]\n): string[] | undefined {\n  const refs = namedAgentRefs(agents);\n  return refs.length === 0 ? undefined : refs;\n}\n\n/**\n * The chips for refs a message carries, named as this page last named those agents: the person's\n * own assistant as the menu names it, a collab agent the page never named as \"Untitled agent\",\n * and any other ref not at all.\n */\nfunction namedAgentsForRefsSeen(refs: readonly string[]): DeepAgentNamedAgent[] {\n  const agents: DeepAgentNamedAgent[] = [];\n  for (const ref of refs) {\n    const seen = namedAgentsSeen.get(ref);\n    if (seen) agents.push(seen);\n    else if (ref === OWN_ASSISTANT_AGENT_REF) {\n      agents.push({ ref, name: OWN_ASSISTANT_DISPLAY_NAME, assetId: null });\n    } else if (ref.startsWith(COLLAB_AGENT_REF_PREFIX)) {\n      agents.push({ ref, name: 'Untitled agent', assetId: ref.slice(COLLAB_AGENT_REF_PREFIX.length) });\n    }\n  }\n  return agents;\n}\n\n/**\n * A waiting message went back to the composer (Cancel, or the ask's Edit): the agents it named\n * (`message.metadata.addressedAgents`) come back as chips with its text, after any named since.\n * The message keeps only refs, so each chip is named by `namedAgentsForRefs` (a host's agent list,\n * as its `@` menu names them), else as this page last named it. Returns the agents put back.\n */\nexport function giveBackDeepAgentOutboxNamedAgents(\n  entry: Pick<ChatOutboxEntry, 'threadId' | 'metadata'>,\n  {\n    namedAgentsForRefs = namedAgentsForRefsSeen,\n  }: { namedAgentsForRefs?: (refs: readonly string[]) => readonly DeepAgentNamedAgent[] } = {}\n): readonly DeepAgentNamedAgent[] {\n  const refs = readAddressedAgents(entry.metadata);\n  if (!refs || refs.length === 0) return NO_NAMED_AGENTS;\n  return namedAgentsForRefs(refs).filter((agent) =>\n    addDeepAgentNamedAgent({ threadId: entry.threadId, agent })\n  );\n}\n\n// ── What a composer's `@` menu offers ───────────────────────────────────────\n\n/**\n * Whether the `@` menu's Agents section is offered to Athena admins alone, for now (#50245). One\n * switch for every chat that names agents (Olympus's composer, the SDK's `AthenaChat`): while it\n * is `true`, only an admin is offered the section, and only an admin's root search finds an agent.\n * It decides who is offered the menu, nothing more: agora checks every name a message carries.\n */\nexport const CHAT_AGENT_NAMING_ADMIN_ONLY = true;\n\n/** Whether a viewer is offered the `@` menu's Agents section ({@link CHAT_AGENT_NAMING_ADMIN_ONLY}). */\nexport function chatAgentNamingOffered({ isAdmin }: { isAdmin: boolean }): boolean {\n  return !CHAT_AGENT_NAMING_ADMIN_ONLY || isAdmin;\n}\n\n/** An agent a composer's `@` menu offers to name. */\nexport interface DeepAgentOfferedAgent extends DeepAgentNamedAgent {\n  /** A Lucide icon name for the menu row. */\n  icon: string;\n}\n\n/** What the person's own assistant is called in the menu and on its chip. */\nexport const OWN_ASSISTANT_DISPLAY_NAME = 'Athena';\n\n/** The person's own assistant, as the menu offers it. */\nexport const OWN_ASSISTANT_OFFERED_AGENT: DeepAgentOfferedAgent = Object.freeze({\n  ref: OWN_ASSISTANT_AGENT_REF,\n  name: OWN_ASSISTANT_DISPLAY_NAME,\n  assetId: null,\n  icon: 'Bot',\n});\n\n/** A collab agent as the menu offers it: its ref, its name (else \"Untitled agent\"), its icon (else a bot). */\nexport function collabAgentOfferedAgent({\n  assetId,\n  name,\n  icon,\n}: {\n  assetId: string;\n  name: string;\n  icon?: string | null;\n}): DeepAgentOfferedAgent {\n  return {\n    ref: `${COLLAB_AGENT_REF_PREFIX}${assetId}`,\n    name: name || 'Untitled agent',\n    assetId,\n    icon: icon || 'Bot',\n  };\n}\n\n/**\n * The agents a composer's `@` menu offers to name: the person's own assistant\n * ({@link OWN_ASSISTANT_OFFERED_AGENT}), then `collabAgents` (the collab agents the composer's agent\n * picker lists) in their order, each once, minus the ones already named; none once eight are named.\n */\nexport function offeredDeepAgentNamedAgents({\n  collabAgents,\n  named,\n}: {\n  collabAgents: readonly DeepAgentOfferedAgent[];\n  named: readonly DeepAgentNamedAgent[];\n}): DeepAgentOfferedAgent[] {\n  if (named.length >= MAX_DEEP_AGENT_NAMED_AGENTS) return [];\n  const taken = new Set(named.map((agent) => agent.ref));\n  const offered: DeepAgentOfferedAgent[] = [];\n  for (const agent of [OWN_ASSISTANT_OFFERED_AGENT, ...collabAgents]) {\n    if (taken.has(agent.ref)) continue;\n    taken.add(agent.ref);\n    offered.push(agent);\n  }\n  return offered;\n}\n\n/** What the composer says when a choice would name more agents than one message takes. */\nexport function namedAgentsLimitMessage(leftOut: readonly string[]): string {\n  const names = new Intl.ListFormat('en', { style: 'long', type: 'conjunction' }).format(leftOut);\n  return `A message names at most ${MAX_DEEP_AGENT_NAMED_AGENTS} agents, so ${names} ${\n    leftOut.length === 1 ? \"wasn't\" : \"weren't\"\n  } added.`;\n}\n\n/**\n * Name `agents` for `threadId`'s next message, in the order given, after those already named.\n * Returns the names of the ones left out because eight were named; an agent named already is\n * not left out, it simply stays where it is.\n */\nexport function nameDeepAgentMentionedAgents({\n  threadId,\n  agents,\n}: {\n  threadId: string;\n  agents: readonly DeepAgentNamedAgent[];\n}): string[] {\n  const leftOut: string[] = [];\n  for (const agent of agents) {\n    const named = readDeepAgentNamedAgents(threadId);\n    if (named.some((entry) => entry.ref === agent.ref.trim())) continue;\n    if (named.length >= MAX_DEEP_AGENT_NAMED_AGENTS) {\n      leftOut.push(agent.name);\n      continue;\n    }\n    addDeepAgentNamedAgent({\n      threadId,\n      agent: { ref: agent.ref, name: agent.name, assetId: agent.assetId },\n    });\n  }\n  return leftOut;\n}\n\n// ── The signed-in identity ──────────────────────────────────────────────────\n\n// process-local: client-only — the signed-in identity this page's names were made under.\nlet namedAgentsIdentity: string | null = null;\n\n/** Drop every chip, staged send and remembered name in this page. */\nexport function forgetAllDeepAgentNamedAgents(): void {\n  stagedForSend.clear();\n  sentTextNamedAgents.clear();\n  withdrawalRestores.clear();\n  namedAgentsSeen.clear();\n  namedAgentsIdentity = null;\n  deepAgentNamedAgentsStore.setState(() => ({ byThread: {} }));\n}\n\n/**\n * `identity` is signed in (Olympus's `DeepAgentSessionLoginReset`, the SDK's `AthenaChat`): names\n * this page made under another identity (an account switch in the page or another tab, an\n * impersonation starting or ending, someone else signing in without a reload) are not this\n * person's to send, so they all go.\n */\nexport function keepDeepAgentNamedAgentsForIdentity(identity: string): void {\n  if (namedAgentsIdentity !== null && namedAgentsIdentity !== identity) {\n    forgetAllDeepAgentNamedAgents();\n  }\n  namedAgentsIdentity = identity;\n}\n"],"names":[],"mappings":"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"}

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 device noun at the start of a sentence (\"This browser can…\"). */\nfunction deviceAtStart(device: DeviceNoun): string {\n  return `${device.charAt(0).toUpperCase()}${device.slice(1)}`;\n}\n\n/**\n * The sentence a promise ends with when the device can remove what it keeps before it syncs\n * (`evictable`: a browser that hasn't granted persistent storage, a private window): \"before then\"\n * after a sentence that says when it syncs, \"before it syncs\" after one that doesn't.\n */\nfunction removableBeforeSync({\n  device,\n  count,\n  before = 'then',\n}: {\n  device: DeviceNoun;\n  count: number;\n  before?: 'then' | 'syncing';\n}): string {\n  const what = count === 1 ? 'it' : 'them';\n  const when = before === 'then' ? 'then' : count === 1 ? 'it syncs' : 'they sync';\n  return `${deviceAtStart(device)} can remove ${what} before ${when}.`;\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  evictable,\n}: {\n  keeping: OfflineKeeping;\n  device: DeviceNoun;\n  when: string;\n  evictable: boolean;\n}): string {\n  switch (keeping) {\n    case 'device':\n      return evictable\n        ? `You can keep working. Changes are kept on ${device} and sync ${when}. ${removableBeforeSync({ device, count: 2 })}`\n        : `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 * `evictable`: the device may remove what it keeps before it syncs (a browser that hasn't granted\n * persistent storage, a private window); only `keeping` `device` says so (default `false`).\n */\nexport function connectionCopy({\n  state,\n  device,\n  waiting = 0,\n  keeping = 'device',\n  evictable = false,\n}: {\n  state: ConnectionState;\n  device: DeviceNoun;\n  waiting?: number;\n  keeping?: OfflineKeeping;\n  evictable?: boolean;\n}): StatusCopy | null {\n  const atRisk = evictable && keeping === 'device';\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              atRisk ? ` ${removableBeforeSync({ device, count: waiting, before: 'syncing' })}` : ''\n            }`,\n          }\n        : null;\n    case 'offline':\n      return {\n        title: 'You’re offline',\n        detail: keepingPromise({\n          keeping,\n          device,\n          when: 'when you’re back online',\n          evictable: atRisk,\n        }),\n      };\n    case 'unreachable':\n      return {\n        title: 'Can’t reach Athena',\n        detail: keepingPromise({ keeping, device, when: 'when Athena is back', evictable: atRisk }),\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 * For `on-device`, `evictable` says the device may remove the changes before they sync (default\n * `false`).\n */\nexport function documentSyncCopy({\n  state,\n  device,\n  delay = 'unconfirmed',\n  keeping = 'device',\n  reachable = true,\n  evictable = false,\n}: {\n  state: DocumentSyncState;\n  device: DeviceNoun;\n  delay?: SavingDelayCause;\n  keeping?: Exclude<OfflineKeeping, 'none'>;\n  reachable?: boolean;\n  evictable?: 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      const copy = onDeviceCopy({ device, reachable });\n      return evictable\n        ? { ...copy, detail: `${copy.detail} ${removableBeforeSync({ device, count: 2 })}` }\n        : copy;\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/**\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/** What a document says while it holds changes an older version of Athena made on the device. */\nexport interface OlderVersionChangesCopy extends StatusCopy {\n  /** Saves this device's version as a file of the person's own, those changes included (Word's). */\n  saveCopy: string;\n  /** Sets this device's version aside, kept on the device to compare, and opens Athena's. */\n  useAthenaVersion: string;\n  /** Athena's version couldn't be opened: another window of the device has the document open. */\n  openElsewhere: string;\n}\n\n/**\n * What a document says while its local copy holds changes an older version of Athena made on this\n * device, below its room's write floor (`older-version`, `@athenaintel/local-copy/room-copy`): such\n * a version deletes what newer ones store, so those changes are never uploaded. Word's way out,\n * as when it can't save a cloud document (\"You can save a copy to prevent losing your work\",\n * `strman`): Save a Copy, and Athena's version, which keeps this device's version on it to compare\n * and copy from until the person discards it. `saveCopy: false` for an editor that offers no Save\n * a Copy of the live document (the phone's page): its kept version downloads instead.\n */\nexport function olderVersionChangesCopy({\n  device,\n  noun,\n  saveCopy = true,\n}: {\n  device: DeviceNoun;\n  /** What the person calls the document (\"document\", \"spreadsheet\"). */\n  noun: string;\n  /** Whether the editor offers Save a Copy beside Athena's version. */\n  saveCopy?: boolean;\n}): OlderVersionChangesCopy {\n  const made = `You changed this ${noun} on ${device} in an older version of Athena, so those changes can’t be uploaded.`;\n  return {\n    title: 'Changes made in an older version of Athena',\n    detail: saveCopy\n      ? `${made} To keep them, save a copy, or use Athena’s version: yours stays on ${device} to compare and copy from.`\n      : `${made} Use Athena’s version to keep yours on ${device}, where you can compare it, copy from it or download it.`,\n    saveCopy: 'Save a Copy',\n    useAthenaVersion: 'Use Athena’s version',\n    openElsewhere: `This ${noun} is open in another window. Close it there, then try again.`,\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 * What saving a copy of a Word document says when the copy was made on the\n * device while Athena can't be reached, for a document whose original Word file\n * Athena keeps (one imported from Word): the copy is made all the same, from the\n * document as the device holds it, over the original file kept with it, so it\n * keeps that file's parts but writes its body from what the editor shows.\n * Athena's own copy, made from the original file, keeps everything, so saving\n * a copy again with a connection makes that one.\n */\nexport function wordCopyMadeOnDevice({ device }: { device: DeviceNoun }): StatusCopy {\n  return {\n    title: `Copy made on ${device}`,\n    detail: `Athena can’t be reached, so the copy holds the document as it is on ${device}. Anything in the original Word file that Athena doesn’t show may be missing from it: save a copy again when you’re back online for the complete file.`,\n  };\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 * How a document's changes could be lost before they reach Athena:\n *\n * - `device`: saved on the device until they reach Athena (no connection, or a review the person\n *   has not finished), but the device can remove them before then (a browser that hasn't granted\n *   persistent storage, a private window);\n * - `held`: saved on the device and can't be sent (the person can only view the document now, or\n *   Athena refused it), and the device can remove them;\n * - `memory`: kept only until the tab or app closes (the device keeps no copy).\n */\nexport type ChangesAtRisk = 'device' | 'held' | 'memory';\n\n/**\n * What an editor says above a document whose changes could be lost before they reach Athena, with\n * the copy it offers of them (Word's \"Upload pending\" and \"Changes not saved\"), by\n * {@link ChangesAtRisk}.\n */\nexport function changesAtRiskCopy({\n  risk,\n  device,\n}: {\n  risk: ChangesAtRisk;\n  device: DeviceNoun;\n}): StatusCopy & { download: string; downloadFailed: string } {\n  const actions = {\n    download: 'Download a copy',\n    downloadFailed: 'Couldn’t download a copy. Try again.',\n  };\n  switch (risk) {\n    case 'memory':\n      return {\n        title: 'Changes not saved',\n        detail: `Your changes are kept only until you close ${openContainer(device)}. Download a copy to keep them.`,\n        ...actions,\n      };\n    case 'held':\n      return {\n        title: 'Changes not saved',\n        detail: `Your changes can’t be sent, and they’re saved only on ${device}, which can remove them. Download a copy to keep them.`,\n        ...actions,\n      };\n    case 'device':\n      return {\n        title: 'Upload pending',\n        detail: `Your changes are saved only on ${device} until they reach Athena, and ${device} can remove them before then. Download a copy to keep them.`,\n        ...actions,\n      };\n  }\n}\n\n/**\n * The action that asks the device to keep what it holds until it syncs, where asking shows the\n * person a question of the device's own (Firefox asks whether the site may store data in\n * persistent storage): the app says why first (`changesAtRiskCopy`) and asks only on this press.\n */\nexport function keepOnDeviceAction({ device }: { device: DeviceNoun }): string {\n  return `Keep them on ${device}`;\n}\n\n/** A browser whose own way of keeping a site's data longer the words point to. */\nexport type SaferStorageBrowser = 'safari-mac' | 'safari-ios';\n\n/**\n * Where changes made offline in Safari are kept longer: Safari keeps a site added to the Dock or\n * the Home Screen as an app of its own, which it is likelier to let keep its data, and the desktop\n * app keeps them in storage of its own.\n */\nexport function saferStorageHint({ browser }: { browser: SaferStorageBrowser }): string {\n  return browser === 'safari-mac'\n    ? 'To keep changes made offline safer in Safari, add Athena to the Dock (File ▸ Add to Dock), or use Athena Desktop.'\n    : 'To keep changes made offline safer, add Athena to your Home Screen (Share ▸ Add to Home Screen).';\n}\n\n/**\n * What the app says when it finds that changes it kept on the device never reached Athena and the\n * device no longer has them (the browser removed them before they synced), naming how many\n * documents; each document's row says when its changes were made (`lostChangesItemCopy`).\n */\nexport function lostChangesCopy({\n  device,\n  documents,\n}: {\n  device: DeviceNoun;\n  documents: number;\n}): StatusCopy & { why: string; open: string; dismiss: string } {\n  const which = documents === 1 ? 'a document' : plural(documents, 'document', 'documents');\n  return {\n    title: 'Changes not saved',\n    detail: `Changes you made to ${which} on ${device} never reached Athena, and ${device} no longer has them.`,\n    why: 'Browsers can remove what a site keeps when they run short of space, or when the site hasn’t been opened for a while.',\n    open: 'Open',\n    dismiss: 'Dismiss',\n  };\n}\n\n/** One document's row under `lostChangesCopy`: the words before when its changes were made. */\nexport function lostChangesItemCopy({ device }: { device: DeviceNoun }): string {\n  return `Changed on ${device}`;\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/**\n * The state of one item in the \"Waiting to sync\" list, and the line that explains it. For an item\n * saved on the device (`waiting`, `when-opened`), `evictable` says the device may remove it before\n * it syncs (default `false`).\n */\nexport function waitingItemCopy({\n  state,\n  device,\n  evictable = false,\n}: {\n  state: WaitingItemState;\n  device: DeviceNoun;\n  evictable?: boolean;\n}): LabelCopy {\n  const removable = evictable ? ` ${removableBeforeSync({ device, count: 1 })}` : '';\n  switch (state) {\n    case 'waiting':\n      return {\n        label: 'Waiting to sync',\n        detail: `Saved on ${device}. It syncs when Athena is back.${removable}`,\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.${removable}`,\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":";;AA6TO,MAAM,6BAA6B;AAgI1C,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 device noun at the start of a sentence (\"This browser can…\"). */\nfunction deviceAtStart(device: DeviceNoun): string {\n  return `${device.charAt(0).toUpperCase()}${device.slice(1)}`;\n}\n\n/**\n * The sentence a promise ends with when the device can remove what it keeps before it syncs\n * (`evictable`: a browser that hasn't granted persistent storage, a private window): \"before then\"\n * after a sentence that says when it syncs, \"before it syncs\" after one that doesn't.\n */\nfunction removableBeforeSync({\n  device,\n  count,\n  before = 'then',\n}: {\n  device: DeviceNoun;\n  count: number;\n  before?: 'then' | 'syncing';\n}): string {\n  const what = count === 1 ? 'it' : 'them';\n  const when = before === 'then' ? 'then' : count === 1 ? 'it syncs' : 'they sync';\n  return `${deviceAtStart(device)} can remove ${what} before ${when}.`;\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  evictable,\n}: {\n  keeping: OfflineKeeping;\n  device: DeviceNoun;\n  when: string;\n  evictable: boolean;\n}): string {\n  switch (keeping) {\n    case 'device':\n      return evictable\n        ? `You can keep working. Changes are kept on ${device} and sync ${when}. ${removableBeforeSync({ device, count: 2 })}`\n        : `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 * `evictable`: the device may remove what it keeps before it syncs (a browser that hasn't granted\n * persistent storage, a private window); only `keeping` `device` says so (default `false`).\n */\nexport function connectionCopy({\n  state,\n  device,\n  waiting = 0,\n  keeping = 'device',\n  evictable = false,\n}: {\n  state: ConnectionState;\n  device: DeviceNoun;\n  waiting?: number;\n  keeping?: OfflineKeeping;\n  evictable?: boolean;\n}): StatusCopy | null {\n  const atRisk = evictable && keeping === 'device';\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              atRisk ? ` ${removableBeforeSync({ device, count: waiting, before: 'syncing' })}` : ''\n            }`,\n          }\n        : null;\n    case 'offline':\n      return {\n        title: 'You’re offline',\n        detail: keepingPromise({\n          keeping,\n          device,\n          when: 'when you’re back online',\n          evictable: atRisk,\n        }),\n      };\n    case 'unreachable':\n      return {\n        title: 'Can’t reach Athena',\n        detail: keepingPromise({ keeping, device, when: 'when Athena is back', evictable: atRisk }),\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 * For `on-device`, `evictable` says the device may remove the changes before they sync (default\n * `false`).\n */\nexport function documentSyncCopy({\n  state,\n  device,\n  delay = 'unconfirmed',\n  keeping = 'device',\n  reachable = true,\n  evictable = false,\n}: {\n  state: DocumentSyncState;\n  device: DeviceNoun;\n  delay?: SavingDelayCause;\n  keeping?: Exclude<OfflineKeeping, 'none'>;\n  reachable?: boolean;\n  evictable?: 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      const copy = onDeviceCopy({ device, reachable });\n      return evictable\n        ? { ...copy, detail: `${copy.detail} ${removableBeforeSync({ device, count: 2 })}` }\n        : copy;\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/**\n * How long a chat message sent while Athena answers may go unaccepted before it counts as waiting\n * to sync. Athena accepts a send when it takes it, not when its turn ends: 99% of follow-up messages\n * within 3.4 s of the send, and 99% of a chat's first, which also dials, within 5.7 s (production\n * `chat_ttft`, 30 days to 2026-11-07). A send still unaccepted after this is stuck, not on its way.\n */\nexport const UNACCEPTED_SEND_STALL_MS = 8_000;\n\n/** Where a chat message a chat outbox lists stands, for {@link messageWaitsToSync}. */\nexport interface OutboxMessageStanding {\n  /** Athena answers (the app's reachability, never the socket alone). */\n  reachable: boolean;\n  /**\n   * On its way to Athena: sent, or queued to go. `false` while the outbox holds it: typed while\n   * Athena couldn't be reached, behind a message that waits, asking after a day, or failed.\n   */\n  sending: boolean;\n  /** Athena received it, before its answer reached the outbox. */\n  received?: boolean;\n  /** When it was sent (epoch ms); for one typed while Athena couldn't be reached, when it was typed. */\n  sentAt: number;\n}\n\n/**\n * When a message on its way starts counting as waiting to sync, should Athena not have accepted it\n * by then ({@link UNACCEPTED_SEND_STALL_MS} after it was sent, while Athena answers); `null` when no\n * time passing changes whether it counts.\n */\nexport function messageStartsWaitingAt({\n  reachable,\n  sending,\n  received = false,\n  sentAt,\n}: OutboxMessageStanding): number | null {\n  return reachable && sending && !received ? sentAt + UNACCEPTED_SEND_STALL_MS : null;\n}\n\n/**\n * Whether a chat message a chat outbox lists counts as waiting to sync, for the status line's\n * count and the \"Waiting to sync\" list: one the outbox holds, always; one on its way, at once while\n * Athena can't be reached, and while it answers only once it went unaccepted past\n * {@link UNACCEPTED_SEND_STALL_MS}; one Athena received, never. A send that goes as usual, however\n * long its turn runs, shows no status line.\n */\nexport function messageWaitsToSync(standing: OutboxMessageStanding & { now: number }): boolean {\n  const startsAt = messageStartsWaitingAt(standing);\n  if (startsAt !== null) return standing.now >= startsAt;\n  return !(standing.sending && standing.received === true);\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/** What a document says while it holds changes an older version of Athena made on the device. */\nexport interface OlderVersionChangesCopy extends StatusCopy {\n  /** Saves this device's version as a file of the person's own, those changes included (Word's). */\n  saveCopy: string;\n  /** Sets this device's version aside, kept on the device to compare, and opens Athena's. */\n  useAthenaVersion: string;\n  /** Athena's version couldn't be opened: another window of the device has the document open. */\n  openElsewhere: string;\n}\n\n/**\n * What a document says while its local copy holds changes an older version of Athena made on this\n * device, below its room's write floor (`older-version`, `@athenaintel/local-copy/room-copy`): such\n * a version deletes what newer ones store, so those changes are never uploaded. Word's way out,\n * as when it can't save a cloud document (\"You can save a copy to prevent losing your work\",\n * `strman`): Save a Copy, and Athena's version, which keeps this device's version on it to compare\n * and copy from until the person discards it. `saveCopy: false` for an editor that offers no Save\n * a Copy of the live document. `keepsAside: false` where the device keeps no version of it aside\n * (copies off, an embed): Athena's version then replaces the changes, which the person confirms\n * first (`olderVersionDiscardCopy`). `atRisk`: the device can lose them before the person chooses\n * (`ChangesAtRisk`), said here so the document shows one strip, never a second \"Changes not saved\".\n */\nexport function olderVersionChangesCopy({\n  device,\n  noun,\n  saveCopy = true,\n  keepsAside = true,\n  atRisk = null,\n}: {\n  device: DeviceNoun;\n  /** What the person calls the document (\"document\", \"spreadsheet\"). */\n  noun: string;\n  /** Whether the editor offers Save a Copy beside Athena's version. */\n  saveCopy?: boolean;\n  /** Whether Athena's version keeps the device's aside, as a version to compare and copy from. */\n  keepsAside?: boolean;\n  /** How the device could lose the changes before the person chooses, or `null`. */\n  atRisk?: ChangesAtRisk | null;\n}): OlderVersionChangesCopy {\n  const made = `You changed this ${noun} on ${device} in an older version of Athena, so those changes can’t be uploaded.`;\n  const keep = !keepsAside\n    ? `${made} To keep them, save a copy: Athena’s version replaces them on ${device}.`\n    : saveCopy\n      ? `${made} To keep them, save a copy, or use Athena’s version: yours stays on ${device} to compare and copy from.`\n      : `${made} Use Athena’s version to keep yours on ${device}, where you can compare it, copy from it or download it.`;\n  const risk =\n    atRisk === null\n      ? ''\n      : atRisk === 'memory'\n        ? ` Until you choose, they’re kept only until you close ${openContainer(device)}.`\n        : ` Until you choose, they’re saved only on ${device}, which can remove them.`;\n  return {\n    title: 'Changes made in an older version of Athena',\n    detail: `${keep}${risk}`,\n    saveCopy: 'Save a Copy',\n    useAthenaVersion: 'Use Athena’s version',\n    openElsewhere: `This ${noun} is open in another window. Close it there, then try again.`,\n  };\n}\n\n/**\n * What the device asks before Athena's version replaces changes an older version of Athena made,\n * where it keeps no version of them aside (`olderVersionChangesCopy`'s `keepsAside: false`): they\n * are deleted then, so a copy saved first is the only way to keep them.\n */\nexport function olderVersionDiscardCopy({ device }: { device: DeviceNoun }): StatusCopy & {\n  confirm: string;\n  cancel: string;\n} {\n  return {\n    title: 'Use Athena’s version?',\n    detail: `The changes made in an older version of Athena are deleted from ${device} and can’t be recovered. To keep them, save a copy first.`,\n    confirm: 'Use Athena’s version',\n    cancel: 'Cancel',\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 * What saving a copy of a Word document says when the copy was made on the\n * device while Athena can't be reached, for a document whose original Word file\n * Athena keeps (one imported from Word): the copy is made all the same, from the\n * document as the device holds it, over the original file kept with it, so it\n * keeps that file's parts but writes its body from what the editor shows.\n * Athena's own copy, made from the original file, keeps everything, so saving\n * a copy again with a connection makes that one.\n */\nexport function wordCopyMadeOnDevice({ device }: { device: DeviceNoun }): StatusCopy {\n  return {\n    title: `Copy made on ${device}`,\n    detail: `Athena can’t be reached, so the copy holds the document as it is on ${device}. Anything in the original Word file that Athena doesn’t show may be missing from it: save a copy again when you’re back online for the complete file.`,\n  };\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 choice to always keep an item on the device, as OneDrive's \"Always Keep\n * on This Device\" (for the item's menu and its toggle in a list). Kept, it\n * stays however long it goes unopened; otherwise the device keeps what was\n * opened in the last `keptDays` days while there is room, and an item turned\n * off counts its days from then. `menuLabel` is the label in a desktop menu's\n * title case (\"Always Keep on This Mac\").\n */\nexport function alwaysKeepCopy({\n  kept,\n  device,\n  keptDays,\n}: {\n  kept: boolean;\n  device: DeviceNoun;\n  keptDays: number;\n}): LabelCopy & { menuLabel: string } {\n  const titled = device.replace(/(^|\\s)\\S/g, (letter) => letter.toUpperCase());\n  return {\n    label: `Always keep on ${device}`,\n    menuLabel: `Always Keep on ${titled}`,\n    detail: kept\n      ? `Kept on ${device} however long it goes unopened, so it always opens without a connection. Turned off, it stays while you open it at least every ${keptDays} days and there’s room, counting from then.`\n      : `Kept on ${device} while you open it at least every ${keptDays} days and there’s room. Turn this on to keep it however long it goes unopened.`,\n  };\n}\n\n/**\n * What a toast says when always keeping an item on the device could not be\n * turned on or off (`alwaysKeepCopy`): the item was no longer kept there\n * (`gone`: nothing to keep until it is opened once online), or the change\n * failed and can be tried again.\n */\nexport function alwaysKeepFailedCopy({\n  kept,\n  gone,\n  device,\n}: {\n  /** What the person asked for: on (`true`) or off. */\n  kept: boolean;\n  gone: boolean;\n  device: DeviceNoun;\n}): string {\n  if (gone) {\n    return `This isn’t kept on ${device} any more. Open it once while online to keep it here.`;\n  }\n  return `Always keep on ${device} couldn’t be turned ${kept ? 'on' : 'off'}. Try again.`;\n}\n\n/**\n * A history Athena keeps in full (a person's dictations), shown while Athena\n * can't be reached: the list holds only what is kept on the device, and the\n * rest comes back once online. `items` names what the list holds, plural.\n */\nexport function historyOnDeviceCopy({\n  items,\n  device,\n}: {\n  items: string;\n  device: DeviceNoun;\n}): string {\n  return `Showing the ${items} kept on ${device}. Your full history shows when you’re back online.`;\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 * How a document's changes could be lost before they reach Athena:\n *\n * - `device`: saved on the device until they reach Athena (no connection, or a review the person\n *   has not finished), but the device can remove them before then (a browser that hasn't granted\n *   persistent storage, a private window);\n * - `held`: saved on the device and can't be sent (the person can only view the document now, or\n *   Athena refused it), and the device can remove them;\n * - `memory`: kept only until the tab or app closes (the device keeps no copy).\n */\nexport type ChangesAtRisk = 'device' | 'held' | 'memory';\n\n/**\n * What an editor says above a document whose changes could be lost before they reach Athena, with\n * the copy it offers of them (Word's \"Upload pending\" and \"Changes not saved\"), by\n * {@link ChangesAtRisk}.\n */\nexport function changesAtRiskCopy({\n  risk,\n  device,\n}: {\n  risk: ChangesAtRisk;\n  device: DeviceNoun;\n}): StatusCopy & { download: string; downloadFailed: string } {\n  const actions = {\n    download: 'Download a copy',\n    downloadFailed: 'Couldn’t download a copy. Try again.',\n  };\n  switch (risk) {\n    case 'memory':\n      return {\n        title: 'Changes not saved',\n        detail: `Your changes are kept only until you close ${openContainer(device)}. Download a copy to keep them.`,\n        ...actions,\n      };\n    case 'held':\n      return {\n        title: 'Changes not saved',\n        detail: `Your changes can’t be sent, and they’re saved only on ${device}, which can remove them. Download a copy to keep them.`,\n        ...actions,\n      };\n    case 'device':\n      return {\n        title: 'Upload pending',\n        detail: `Your changes are saved only on ${device} until they reach Athena, and ${device} can remove them before then. Download a copy to keep them.`,\n        ...actions,\n      };\n  }\n}\n\n/**\n * The action that asks the device to keep what it holds until it syncs, where asking shows the\n * person a question of the device's own (Firefox asks whether the site may store data in\n * persistent storage): the app says why first (`changesAtRiskCopy`) and asks only on this press.\n */\nexport function keepOnDeviceAction({ device }: { device: DeviceNoun }): string {\n  return `Keep them on ${device}`;\n}\n\n/** A browser whose own way of keeping a site's data longer the words point to. */\nexport type SaferStorageBrowser = 'safari-mac' | 'safari-ios';\n\n/**\n * Where changes made offline in Safari are kept longer: Safari keeps a site added to the Dock or\n * the Home Screen as an app of its own, which it is likelier to let keep its data, and the desktop\n * app keeps them in storage of its own.\n */\nexport function saferStorageHint({ browser }: { browser: SaferStorageBrowser }): string {\n  return browser === 'safari-mac'\n    ? 'To keep changes made offline safer in Safari, add Athena to the Dock (File ▸ Add to Dock), or use Athena Desktop.'\n    : 'To keep changes made offline safer, add Athena to your Home Screen (Share ▸ Add to Home Screen).';\n}\n\n/**\n * What the app says when it finds that changes it kept on the device never reached Athena and the\n * device no longer has them (the browser removed them before they synced), naming how many\n * documents; each document's row says when its changes were made (`lostChangesItemCopy`).\n */\nexport function lostChangesCopy({\n  device,\n  documents,\n}: {\n  device: DeviceNoun;\n  documents: number;\n}): StatusCopy & { why: string; open: string; dismiss: string } {\n  const which = documents === 1 ? 'a document' : plural(documents, 'document', 'documents');\n  return {\n    title: 'Changes not saved',\n    detail: `Changes you made to ${which} on ${device} never reached Athena, and ${device} no longer has them.`,\n    why: 'Browsers can remove what a site keeps when they run short of space, or when the site hasn’t been opened for a while.',\n    open: 'Open',\n    dismiss: 'Dismiss',\n  };\n}\n\n/** One document's row under `lostChangesCopy`: the words before when its changes were made. */\nexport function lostChangesItemCopy({ device }: { device: DeviceNoun }): string {\n  return `Changed on ${device}`;\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/**\n * The state of one item in the \"Waiting to sync\" list, and the line that explains it. For an item\n * saved on the device (`waiting`, `when-opened`), `evictable` says the device may remove it before\n * it syncs (default `false`).\n */\nexport function waitingItemCopy({\n  state,\n  device,\n  evictable = false,\n}: {\n  state: WaitingItemState;\n  device: DeviceNoun;\n  evictable?: boolean;\n}): LabelCopy {\n  const removable = evictable ? ` ${removableBeforeSync({ device, count: 1 })}` : '';\n  switch (state) {\n    case 'waiting':\n      return {\n        label: 'Waiting to sync',\n        detail: `Saved on ${device}. It syncs when Athena is back.${removable}`,\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.${removable}`,\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":";;AA6TO,MAAM,6BAA6B;AAqN1C,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;;;;;;"}