@athenaintel/react 0.57.2 → 0.59.0

package/dist/offline/chat-outbox.d.ts

@@ -1,4 +1,4 @@
-import { type ChatOutboxKeyPurpose, type ChatOutboxSignal, type ChatOutboxStore } from '../agent-runtime/src/index';
+import { type ChatOutboxDirectory, type ChatOutboxSignal, type ChatSessionKeyProvider, createSealedSessionCodec, type LegacyChatOutboxReader } from '../agent-runtime/src/index';
 /**
  * Opt-in: messages typed while Athena can't be reached wait on this device, sealed with the host's
  * key, and are sent once Athena is back while the app is in front, after a countdown the person
@@ -9,9 +9,9 @@ import { type ChatOutboxKeyPurpose, type ChatOutboxSignal, type ChatOutboxStore
  *   messages are never shown or sent: each owner's are sealed under their own key.
  * - `getKey(purpose)` returns the AES-GCM key: `read` opens what is kept (the key if one exists,
  *   never made for this), `write` keeps a new message (only while the deployment lets devices keep
- *   copies). `null` keeps a new message in memory only, for as long as the page stays open. Unlike
- *   the chat history's, this key guards the only copy of what someone wrote: a host must never
- *   replace or drop it except at a sign-out the person chose.
+ *   copies). With no `write` key when a conversation opens, its messages wait in memory only, for
+ *   as long as the page stays open. Unlike the chat history's, this key guards the only copy of
+ *   what someone wrote: a host must never replace or drop it except at a sign-out the person chose.
  * - `reachability` says Athena can be reached: the host's own model (the device online AND agora
  *   answering a health read, as Midas's main process decides it), by default the browser being
  *   online. Either way a conversation whose own channel keeps failing to connect counts as out of
@@ -24,7 +24,7 @@ import { type ChatOutboxKeyPurpose, type ChatOutboxSignal, type ChatOutboxStore
  */
 export interface AthenaChatOutbox {
     ownerId: string;
-    getKey: (purpose: ChatOutboxKeyPurpose) => Promise<CryptoKey | null>;
+    getKey: ChatSessionKeyProvider;
     reachability?: ChatOutboxSignal;
     foreground?: ChatOutboxSignal;
     openThread?: (target: {
@@ -32,12 +32,82 @@ export interface AthenaChatOutbox {
         newChat: boolean;
     }) => void;
 }
-/** The page's chat outbox store for `host`'s owner, made on first use. */
-export declare function chatOutboxStoreFor(host: AthenaChatOutbox): ChatOutboxStore;
+/**
+ * Where a conversation's session (and so its waiting messages) lives when the provider keeps a
+ * chat outbox: `pending` until the owner's namespace and write key are known, then sealed in
+ * IndexedDB, or in page memory where there is no write key (or no IndexedDB).
+ */
+export type AthenaChatSessionKeeping = {
+    kind: 'pending';
+} | {
+    kind: 'sealed';
+    namespace: string;
+    /** The owner's statewire principal ({@link ChatOutboxOwnerStorage.principal}). */
+    principal: string;
+    codec: ChatOutboxOwnerStorage['codec'];
+} | {
+    kind: 'memory';
+    scope: string;
+    /** The owner's statewire principal ({@link ChatOutboxOwnerStorage.principal}). */
+    principal: string;
+    /**
+     * Conversations that already kept messages sealed on this device when the write key went
+     * (the deployment stopped letting devices keep copies): they reopen that record with the
+     * read key, so what waits there can still be sent, edited or discarded.
+     */
+    sealedThreads?: {
+        namespace: string;
+        codec: ChatOutboxOwnerStorage['codec'];
+        threads: ReadonlySet<string>;
+    };
+};
+/**
+ * Where `owner`'s conversations keep their sessions now: sealed when this page can keep sealed
+ * sessions and the host gives a write key, in memory otherwise.
+ */
+export declare function resolveChatSessionKeeping(owner: ChatOutboxOwnerStorage): Promise<Exclude<AthenaChatSessionKeeping, {
+    kind: 'pending';
+}>>;
+/**
+ * Where one owner's waiting messages live in this page: each conversation's statewire session
+ * (sealed in IndexedDB, or in page memory where there is no write key), the previous build's
+ * store until each conversation moves its messages over, and one live list of all of them.
+ */
+export interface ChatOutboxOwnerStorage {
+    ownerId: string;
+    /**
+     * The owner's statewire principal (`user:<ownerId>`): the owner is the account the host names,
+     * and every session record sits under it (`<namespace><principal>:<threadId>`).
+     */
+    principal: string;
+    /** Seals and opens this owner's session records with the latest host's key. */
+    codec: ReturnType<typeof createSealedSessionCodec>;
+    /**
+     * Reopens a record already kept on the device once there is no write key, rewriting it with the
+     * read key only as its waiting messages are sent or discarded (`sealedThreads`).
+     */
+    drainCodec: ReturnType<typeof createSealedSessionCodec>;
+    /** The previous build's sealed store (`athena-chat-outbox:v1`). */
+    legacy: LegacyChatOutboxReader;
+    /** The owner's sealed-session namespace; `null` where this page cannot keep sealed sessions. */
+    namespace: Promise<string | null>;
+    /** The page-memory sessions' scope (`ChatSessionStorage({kind: 'memory', scope})`). */
+    memoryScope: string;
+    /** Every conversation's waiting messages, sealed and in memory. */
+    directory: ChatOutboxDirectory;
+    /** The latest host of this owner: the codec and the legacy reader ask it for the key. */
+    host: {
+        current: AthenaChatOutbox;
+    };
+    /** Drops the keys the codec kept (a sign-out): the next seal asks the host again. */
+    forgetKeys: () => void;
+}
+/** The page's chat outbox storage for `host`'s owner, made on first use. */
+export declare function chatOutboxStorageFor(host: AthenaChatOutbox): ChatOutboxOwnerStorage;
 /**
  * How many messages wait for `ownerId` (kept on the device, including records this build cannot
- * open, and waiting in this page's memory), counted without opening them. Rejects when the
- * device's records cannot be counted at all.
+ * open, and waiting in this page's memory), counted without asking for a key it does not have.
+ * Rejects when the device's records cannot be counted at all.
  */
 export declare function countChatOutboxMessages(ownerId: string): Promise<number>;
 /**
@@ -55,13 +125,21 @@ export interface ChatOutboxMessageSummary {
     /** Typed into a chat that had never started. */
     newChat: boolean;
     /**
-     * Where it stands, as the queue tray shows it: waiting to be sent, being handed to its
-     * conversation now (a window's claim on it still holds), waiting for the person (it waited more
-     * than a day: Send, Edit or Discard), or failed (Retry or Discard; never retried on its own).
+     * Where it stands, as the queue tray shows it: waiting to be sent, handed to its conversation
+     * (released from the outbox and on its way, or sent and not answered yet), waiting for the person
+     * (it waited more than a day: Send, Edit or Discard), or failed (Retry, Edit or Discard; never
+     * retried on its own).
      */
     status: 'waiting' | 'sending' | 'ask' | 'failed';
     /** Kept only in this page's memory: this device could not keep it. */
     inMemory: boolean;
+    /**
+     * When it was typed, or sent where it went at once (epoch ms). A host counts a message `sending`
+     * as waiting to sync only once it goes unaccepted for a while (`messageWaitsToSync` in
+     * `@athenaintel/agent-runtime/offline-status`): the list holds every send until its answer is
+     * written back, an ordinary one on its way included.
+     */
+    queuedAt: number;
 }
 /**
  * The messages waiting for `ownerId` that this page can open (oldest first), each with where it

package/dist/offline/chat-outbox.js

@@ -1,57 +1,293 @@
-import { createIndexedDbChatOutboxStore } from "../agent-runtime/src/chat-outbox-store.js";
-import { CHAT_OUTBOX_CLAIM_LEASE_MS, CHAT_OUTBOX_ASK_AFTER_MS } from "../agent-runtime/src/chat-outbox.js";
-const ownerStores = /* @__PURE__ */ new Map();
+import { clearChatOutboxes, countChatOutboxMessages as countChatOutboxMessages$1, listChatOutboxes, chatSessionNamespace, adoptUnscopedChatSessions, chatSessionBackend, createSealedSessionCodec, createChatOutboxDirectory, chatSessionMemoryNamespace, chatSessionMemoryBackend } from "../agent-runtime/src/chat-outbox-storage.js";
+import { CHAT_OUTBOX_ASK_AFTER_MS } from "../agent-runtime/src/chat-outbox.js";
+import { createLegacyChatOutboxReader } from "../agent-runtime/src/chat-outbox-legacy.js";
+import { sessionPrincipal } from "../agent-runtime/src/quota-safe-local-storage-session.js";
+async function resolveChatSessionKeeping(owner) {
+  const namespace = await owner.namespace;
+  if (namespace !== null) {
+    const writeKey = await owner.host.current.getKey("write").catch(() => null);
+    if (writeKey) return { kind: "sealed", namespace, principal: owner.principal, codec: owner.codec };
+    const threads = await threadsKeptSealed(owner, namespace);
+    if (threads.size > 0) {
+      return {
+        kind: "memory",
+        scope: owner.memoryScope,
+        principal: owner.principal,
+        sealedThreads: { namespace, codec: owner.drainCodec, threads }
+      };
+    }
+  }
+  return { kind: "memory", scope: owner.memoryScope, principal: owner.principal };
+}
+async function threadsKeptSealed(owner, namespace) {
+  const readKey = await owner.host.current.getKey("read").catch(() => null);
+  if (!readKey) return /* @__PURE__ */ new Set();
+  const listing = await listChatOutboxes({
+    backend: chatSessionBackend(),
+    namespace,
+    principal: owner.principal,
+    codec: owner.codec
+  }).catch(() => EMPTY_LISTING);
+  return new Set(
+    listing.threads.filter(({ entries }) => entries.length > 0).map(({ threadId }) => threadId)
+  );
+}
+const SDK_CHAT_SESSION_ENVIRONMENT = "athena-sdk";
+const owners = /* @__PURE__ */ new Map();
 function keylessHost(ownerId) {
   return { ownerId, getKey: async () => null };
 }
-function ownerStore(ownerId, host) {
-  let owner = ownerStores.get(ownerId);
+function canKeepSealedSessions() {
+  return typeof indexedDB !== "undefined" && typeof crypto !== "undefined" && typeof crypto.subtle !== "undefined";
+}
+function memorySource(ownerId) {
+  return {
+    backend: chatSessionMemoryBackend(),
+    namespace: chatSessionMemoryNamespace(ownerId),
+    principal: sessionPrincipal(ownerId)
+  };
+}
+function sealedSource(owner, namespace) {
+  return {
+    backend: chatSessionBackend(),
+    namespace,
+    principal: owner.principal,
+    codec: owner.codec,
+    legacy: owner.legacy
+  };
+}
+const EMPTY_LISTING = { threads: [], unreadable: 0 };
+function mergeListings(a, b) {
+  if (b.threads.length === 0 && b.unreadable === 0) return a;
+  if (a.threads.length === 0 && a.unreadable === 0) return b;
+  const byThread = /* @__PURE__ */ new Map();
+  for (const thread of [...a.threads, ...b.threads]) {
+    const list = byThread.get(thread.threadId) ?? [];
+    for (const entry of thread.entries) if (!list.some(({ id }) => id === entry.id)) list.push(entry);
+    byThread.set(thread.threadId, list);
+  }
+  const threads = [...byThread].map(([threadId, entries]) => ({
+    threadId,
+    entries: entries.sort((x, y) => x.queuedAt - y.queuedAt)
+  })).sort((x, y) => {
+    var _a, _b;
+    return (((_a = x.entries[0]) == null ? void 0 : _a.queuedAt) ?? 0) - (((_b = y.entries[0]) == null ? void 0 : _b.queuedAt) ?? 0);
+  });
+  return { threads, unreadable: a.unreadable + b.unreadable };
+}
+function listingSignature(listing) {
+  return JSON.stringify([
+    listing.unreadable,
+    listing.threads.map(({ threadId, entries }) => [
+      threadId,
+      entries.map(({ id, state, failed, queuedAt, text }) => [id, state, failed, queuedAt, text])
+    ])
+  ]);
+}
+function mergedDirectory({
+  memory,
+  sealed
+}) {
+  let sealedDirectory = null;
+  let cached = null;
+  const listeners = /* @__PURE__ */ new Set();
+  let stops = [];
+  let generation = 0;
+  let heard = listingSignature(EMPTY_LISTING);
+  const notify = () => {
+    const signature = listingSignature(directory.getSnapshot());
+    if (signature === heard) return;
+    heard = signature;
+    for (const listener of [...listeners]) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  };
+  const start = () => {
+    const started = ++generation;
+    stops.push(memory.subscribe(notify));
+    memory.refresh();
+    void sealed.then((directory2) => {
+      sealedDirectory = directory2;
+      if (!directory2 || started !== generation || listeners.size === 0) return;
+      stops.push(directory2.subscribe(notify));
+      directory2.refresh();
+    });
+  };
+  const directory = {
+    getSnapshot() {
+      const memorySnapshot = memory.getSnapshot();
+      const sealedSnapshot = (sealedDirectory == null ? void 0 : sealedDirectory.getSnapshot()) ?? EMPTY_LISTING;
+      if (!cached || cached.memory !== memorySnapshot || cached.sealed !== sealedSnapshot) {
+        cached = {
+          memory: memorySnapshot,
+          sealed: sealedSnapshot,
+          merged: mergeListings(sealedSnapshot, memorySnapshot)
+        };
+      }
+      return cached.merged;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      if (listeners.size === 1) start();
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          generation += 1;
+          for (const stop of stops) stop();
+          stops = [];
+        }
+      };
+    },
+    refresh() {
+      memory.refresh();
+      sealedDirectory == null ? void 0 : sealedDirectory.refresh();
+    }
+  };
+  return directory;
+}
+function sessionKeys(current) {
+  let keysOf = null;
+  const keys = /* @__PURE__ */ new Map();
+  const getKey = (purpose) => {
+    const host = current.current;
+    if (keysOf !== host) {
+      keysOf = host;
+      keys.clear();
+    }
+    let key = keys.get(purpose);
+    if (!key) {
+      const asked = host.getKey(purpose).catch(() => null);
+      key = asked;
+      keys.set(purpose, asked);
+      void asked.then((value) => {
+        if (value === null && keys.get(purpose) === asked) keys.delete(purpose);
+      });
+    }
+    return key;
+  };
+  return { getKey, forget: () => keys.clear() };
+}
+function ownerStorage(ownerId, host) {
+  let owner = owners.get(ownerId);
   if (!owner) {
     const current = { current: host ?? keylessHost(ownerId) };
+    const principal = sessionPrincipal(ownerId);
+    const sealedAvailable = canKeepSealedSessions();
+    const namespace = sealedAvailable ? chatSessionNamespace({ environment: SDK_CHAT_SESSION_ENVIRONMENT, ownerId }).then(async (resolved) => {
+      await adoptUnscopedChatSessions({
+        backend: chatSessionBackend(),
+        namespace: resolved,
+        principal
+      }).catch(() => 0);
+      return resolved;
+    }).catch(() => null) : Promise.resolve(null);
+    const keys = sessionKeys(current);
+    const codec = createSealedSessionCodec({ getKey: keys.getKey, scope: ownerId });
+    const drainCodec = createSealedSessionCodec({
+      getKey: (purpose) => keys.getKey(purpose === "write" ? "read" : purpose),
+      scope: ownerId
+    });
+    const legacy = createLegacyChatOutboxReader({
+      ownerId,
+      getKey: () => current.current.getKey("read")
+    });
+    const directory = mergedDirectory({
+      memory: createChatOutboxDirectory(memorySource(ownerId)),
+      sealed: namespace.then(
+        (resolved) => resolved === null ? null : createChatOutboxDirectory(sealedSource({ codec, legacy, principal }, resolved))
+      )
+    });
     owner = {
+      ownerId,
+      principal,
+      codec,
+      drainCodec,
+      legacy,
+      namespace,
+      memoryScope: ownerId,
       host: current,
-      store: createIndexedDbChatOutboxStore({
-        ownerId,
-        getKey: (_ownerId, purpose) => current.current.getKey(purpose)
-      })
+      directory,
+      forgetKeys: keys.forget
     };
-    ownerStores.set(ownerId, owner);
+    owners.set(ownerId, owner);
   }
   if (host) owner.host.current = host;
-  return owner.store;
+  return owner;
+}
+function chatOutboxStorageFor(host) {
+  return ownerStorage(host.ownerId, host);
 }
-function chatOutboxStoreFor(host) {
-  return ownerStore(host.ownerId, host);
+async function sealedSourceOf(owner) {
+  const namespace = await owner.namespace;
+  return namespace === null ? null : sealedSource(owner, namespace);
 }
-function countChatOutboxMessages(ownerId) {
-  return ownerStore(ownerId).count();
+async function countChatOutboxMessages(ownerId) {
+  const owner = ownerStorage(ownerId);
+  const sealed = await sealedSourceOf(owner);
+  const [kept, inMemory] = await Promise.all([
+    sealed ? countChatOutboxMessages$1(sealed) : 0,
+    countChatOutboxMessages$1(memorySource(ownerId))
+  ]);
+  return kept + inMemory;
 }
 function subscribeChatOutbox(ownerId, listener) {
-  return ownerStore(ownerId).subscribe(listener);
+  return ownerStorage(ownerId).directory.subscribe(listener);
 }
-async function listChatOutboxMessages(ownerId, now = Date.now()) {
-  const records = await ownerStore(ownerId).listAll();
-  return records.map(({ entry, claim, failure, memoryOnly }) => ({
+function summaryOf(entry, { inMemory, now }) {
+  return {
     id: entry.id,
     threadId: entry.threadId,
     text: entry.text,
     newChat: entry.newChat,
-    status: failure ? "failed" : claim && now - claim.at < CHAT_OUTBOX_CLAIM_LEASE_MS ? "sending" : now - entry.queuedAt > CHAT_OUTBOX_ASK_AFTER_MS ? "ask" : "waiting",
-    inMemory: memoryOnly === true
-  }));
+    status: entry.failed ? "failed" : entry.state !== void 0 && entry.state !== "held" ? "sending" : now - entry.queuedAt > CHAT_OUTBOX_ASK_AFTER_MS ? "ask" : "waiting",
+    inMemory,
+    queuedAt: entry.queuedAt
+  };
+}
+async function listChatOutboxMessages(ownerId, now = Date.now()) {
+  const owner = ownerStorage(ownerId);
+  const sealed = await sealedSourceOf(owner);
+  const [kept, inMemory] = await Promise.all([
+    sealed ? listChatOutboxes(sealed) : EMPTY_LISTING,
+    listChatOutboxes(memorySource(ownerId))
+  ]);
+  const summaries = [
+    ...kept.threads.flatMap(
+      ({ entries }) => entries.map((entry) => summaryOf(entry, { inMemory: false, now }))
+    ),
+    ...inMemory.threads.flatMap(
+      ({ entries }) => entries.map((entry) => summaryOf(entry, { inMemory: true, now }))
+    )
+  ];
+  return summaries.sort((a, b) => a.queuedAt - b.queuedAt);
 }
-function clearChatOutbox(ownerId) {
-  return ownerStore(ownerId).clear();
+async function clearChatOutbox(ownerId) {
+  const owner = ownerStorage(ownerId);
+  const sealed = await sealedSourceOf(owner);
+  owner.forgetKeys();
+  if (sealed) await clearChatOutboxes(sealed);
+  else await owner.legacy.clear();
+  await clearChatOutboxes(memorySource(ownerId));
+  owner.directory.refresh();
 }
-function clearUnopenableChatOutbox(ownerId) {
-  return createIndexedDbChatOutboxStore({ ownerId, getKey: async () => null }).clear();
+async function clearUnopenableChatOutbox(ownerId) {
+  const owner = ownerStorage(ownerId);
+  owner.forgetKeys();
+  const sealed = await sealedSourceOf(owner);
+  if (sealed) await clearChatOutboxes(sealed);
+  else await owner.legacy.clear();
+  owner.directory.refresh();
 }
 export {
-  chatOutboxStoreFor,
+  chatOutboxStorageFor,
   clearChatOutbox,
   clearUnopenableChatOutbox,
   countChatOutboxMessages,
   listChatOutboxMessages,
+  resolveChatSessionKeeping,
   subscribeChatOutbox
 };
 //# sourceMappingURL=chat-outbox.js.map

package/dist/offline/chat-outbox.js.map

@@ -1 +1 @@
-{"version":3,"file":"chat-outbox.js","sources":["../../src/offline/chat-outbox.ts"],"sourcesContent":["import {\n  CHAT_OUTBOX_ASK_AFTER_MS,\n  CHAT_OUTBOX_CLAIM_LEASE_MS,\n  type ChatOutboxKeyPurpose,\n  type ChatOutboxSignal,\n  type ChatOutboxStore,\n  createIndexedDbChatOutboxStore,\n} from '@athenaintel/agent-runtime';\n\n/**\n * Opt-in: messages typed while Athena can't be reached wait on this device, sealed with the host's\n * key, and are sent once Athena is back while the app is in front, after a countdown the person\n * can cancel (`@athenaintel/agent-runtime`'s chat outbox, shown at the top of the queue tray).\n * Without it a send goes to the transport as before.\n *\n * - `ownerId` names whose they are (the signed-in person, with the environment). Another owner's\n *   messages are never shown or sent: each owner's are sealed under their own key.\n * - `getKey(purpose)` returns the AES-GCM key: `read` opens what is kept (the key if one exists,\n *   never made for this), `write` keeps a new message (only while the deployment lets devices keep\n *   copies). `null` keeps a new message in memory only, for as long as the page stays open. Unlike\n *   the chat history's, this key guards the only copy of what someone wrote: a host must never\n *   replace or drop it except at a sign-out the person chose.\n * - `reachability` says Athena can be reached: the host's own model (the device online AND agora\n *   answering a health read, as Midas's main process decides it), by default the browser being\n *   online. Either way a conversation whose own channel keeps failing to connect counts as out of\n *   reach too.\n * - `foreground` says the app is in front; by default a visible document. A desktop host passes\n *   `windowInFrontSignal()` (visible and focused).\n * - `openThread` opens another of the person's conversations the tray lists as holding waiting\n *   messages (`newChat`: one that never started). Without it, a provider with a thread list\n *   switches to it; otherwise the tray names it without Open.\n */\nexport interface AthenaChatOutbox {\n  ownerId: string;\n  getKey: (purpose: ChatOutboxKeyPurpose) => Promise<CryptoKey | null>;\n  reachability?: ChatOutboxSignal;\n  foreground?: ChatOutboxSignal;\n  openThread?: (target: { threadId: string; newChat: boolean }) => void;\n}\n\ninterface OwnerStore {\n  store: ChatOutboxStore;\n  /** The latest host for this owner: the store asks it for the key. */\n  host: { current: AthenaChatOutbox };\n}\n\n// process-local: one store per owner in this page, so every provider of the person (a chat in a\n// tab, another in a pane) shares one change bus and one memory of the messages this device could\n// not keep: a thread switch or a closed tab never loses them, and a sign-out counts them.\nconst ownerStores = new Map<string, OwnerStore>();\n\n/** A host that has no key to give (counting and deleting never need one). */\nfunction keylessHost(ownerId: string): AthenaChatOutbox {\n  return { ownerId, getKey: async () => null };\n}\n\nfunction ownerStore(ownerId: string, host?: AthenaChatOutbox): ChatOutboxStore {\n  let owner = ownerStores.get(ownerId);\n  if (!owner) {\n    const current = { current: host ?? keylessHost(ownerId) };\n    owner = {\n      host: current,\n      store: createIndexedDbChatOutboxStore({\n        ownerId,\n        getKey: (_ownerId, purpose) => current.current.getKey(purpose),\n      }),\n    };\n    ownerStores.set(ownerId, owner);\n  }\n  if (host) owner.host.current = host;\n  return owner.store;\n}\n\n/** The page's chat outbox store for `host`'s owner, made on first use. */\nexport function chatOutboxStoreFor(host: AthenaChatOutbox): ChatOutboxStore {\n  return ownerStore(host.ownerId, host);\n}\n\n/**\n * How many messages wait for `ownerId` (kept on the device, including records this build cannot\n * open, and waiting in this page's memory), counted without opening them. Rejects when the\n * device's records cannot be counted at all.\n */\nexport function countChatOutboxMessages(ownerId: string): Promise<number> {\n  return ownerStore(ownerId).count();\n}\n\n/**\n * Calls `listener` after any change to `ownerId`'s waiting messages, this window's or another's\n * (one kept, handed to its conversation, cancelled, failed or retried), so a host can show how many\n * wait (`countChatOutboxMessages`) without asking on a timer. Returns what stops it.\n */\nexport function subscribeChatOutbox(ownerId: string, listener: () => void): () => void {\n  return ownerStore(ownerId).subscribe(listener);\n}\n\n/** A message waiting in an owner's outbox, as a host lists it (its \"Waiting to sync\" list). */\nexport interface ChatOutboxMessageSummary {\n  id: string;\n  threadId: string;\n  /** The text as it will be sent. */\n  text: string;\n  /** Typed into a chat that had never started. */\n  newChat: boolean;\n  /**\n   * Where it stands, as the queue tray shows it: waiting to be sent, being handed to its\n   * conversation now (a window's claim on it still holds), waiting for the person (it waited more\n   * than a day: Send, Edit or Discard), or failed (Retry or Discard; never retried on its own).\n   */\n  status: 'waiting' | 'sending' | 'ask' | 'failed';\n  /** Kept only in this page's memory: this device could not keep it. */\n  inMemory: boolean;\n}\n\n/**\n * The messages waiting for `ownerId` that this page can open (oldest first), each with where it\n * stands, for a host's list of what waits to sync; the tray in the conversation acts on them.\n * Records this page cannot open (no key here, a newer build's) are left out, so a host counts with\n * `countChatOutboxMessages`.\n */\nexport async function listChatOutboxMessages(\n  ownerId: string,\n  now: number = Date.now(),\n): Promise<ChatOutboxMessageSummary[]> {\n  const records = await ownerStore(ownerId).listAll();\n  return records.map(({ entry, claim, failure, memoryOnly }) => ({\n    id: entry.id,\n    threadId: entry.threadId,\n    text: entry.text,\n    newChat: entry.newChat,\n    status: failure\n      ? 'failed'\n      : claim && now - claim.at < CHAT_OUTBOX_CLAIM_LEASE_MS\n        ? 'sending'\n        : now - entry.queuedAt > CHAT_OUTBOX_ASK_AFTER_MS\n          ? 'ask'\n          : 'waiting',\n    inMemory: memoryOnly === true,\n  }));\n}\n\n/** A sign-out the person chose: every message waiting for `ownerId` goes, on the device and in memory. */\nexport function clearChatOutbox(ownerId: string): Promise<void> {\n  return ownerStore(ownerId).clear();\n}\n\n/**\n * Deletes the records kept on this device for `ownerId`, never the messages waiting in this page's\n * memory: for a host whose key for them no longer exists (a chosen sign-out deleted it before the\n * page could delete the records), so nothing can ever open them and they must not be counted.\n */\nexport function clearUnopenableChatOutbox(ownerId: string): Promise<void> {\n  return createIndexedDbChatOutboxStore({ ownerId, getKey: async () => null }).clear();\n}\n"],"names":[],"mappings":";;AAiDA,MAAM,kCAAkB,IAAA;AAGxB,SAAS,YAAY,SAAmC;AACtD,SAAO,EAAE,SAAS,QAAQ,YAAY,KAAA;AACxC;AAEA,SAAS,WAAW,SAAiB,MAA0C;AAC7E,MAAI,QAAQ,YAAY,IAAI,OAAO;AACnC,MAAI,CAAC,OAAO;AACV,UAAM,UAAU,EAAE,SAAS,QAAQ,YAAY,OAAO,EAAA;AACtD,YAAQ;AAAA,MACN,MAAM;AAAA,MACN,OAAO,+BAA+B;AAAA,QACpC;AAAA,QACA,QAAQ,CAAC,UAAU,YAAY,QAAQ,QAAQ,OAAO,OAAO;AAAA,MAAA,CAC9D;AAAA,IAAA;AAEH,gBAAY,IAAI,SAAS,KAAK;AAAA,EAChC;AACA,MAAI,KAAM,OAAM,KAAK,UAAU;AAC/B,SAAO,MAAM;AACf;AAGO,SAAS,mBAAmB,MAAyC;AAC1E,SAAO,WAAW,KAAK,SAAS,IAAI;AACtC;AAOO,SAAS,wBAAwB,SAAkC;AACxE,SAAO,WAAW,OAAO,EAAE,MAAA;AAC7B;AAOO,SAAS,oBAAoB,SAAiB,UAAkC;AACrF,SAAO,WAAW,OAAO,EAAE,UAAU,QAAQ;AAC/C;AA0BA,eAAsB,uBACpB,SACA,MAAc,KAAK,OACkB;AACrC,QAAM,UAAU,MAAM,WAAW,OAAO,EAAE,QAAA;AAC1C,SAAO,QAAQ,IAAI,CAAC,EAAE,OAAO,OAAO,SAAS,kBAAkB;AAAA,IAC7D,IAAI,MAAM;AAAA,IACV,UAAU,MAAM;AAAA,IAChB,MAAM,MAAM;AAAA,IACZ,SAAS,MAAM;AAAA,IACf,QAAQ,UACJ,WACA,SAAS,MAAM,MAAM,KAAK,6BACxB,YACA,MAAM,MAAM,WAAW,2BACrB,QACA;AAAA,IACR,UAAU,eAAe;AAAA,EAAA,EACzB;AACJ;AAGO,SAAS,gBAAgB,SAAgC;AAC9D,SAAO,WAAW,OAAO,EAAE,MAAA;AAC7B;AAOO,SAAS,0BAA0B,SAAgC;AACxE,SAAO,+BAA+B,EAAE,SAAS,QAAQ,YAAY,KAAA,CAAM,EAAE,MAAA;AAC/E;"}
+{"version":3,"file":"chat-outbox.js","sources":["../../src/offline/chat-outbox.ts"],"sourcesContent":["import {\n  adoptUnscopedChatSessions,\n  CHAT_OUTBOX_ASK_AFTER_MS,\n  type ChatOutboxDirectory,\n  type ChatOutboxDirectoryThread,\n  type ChatOutboxListedEntry,\n  type ChatOutboxListing,\n  type ChatOutboxSignal,\n  type ChatOutboxStorageSource,\n  type ChatSessionKeyProvider,\n  type ChatSessionKeyPurpose,\n  chatSessionBackend,\n  chatSessionMemoryBackend,\n  chatSessionMemoryNamespace,\n  chatSessionNamespace,\n  clearChatOutboxes,\n  countChatOutboxMessages as countChatOutboxSource,\n  createChatOutboxDirectory,\n  createLegacyChatOutboxReader,\n  createSealedSessionCodec,\n  type LegacyChatOutboxReader,\n  listChatOutboxes,\n  sessionPrincipal,\n} from '@athenaintel/agent-runtime';\n\n/**\n * Opt-in: messages typed while Athena can't be reached wait on this device, sealed with the host's\n * key, and are sent once Athena is back while the app is in front, after a countdown the person\n * can cancel (`@athenaintel/agent-runtime`'s chat outbox, shown at the top of the queue tray).\n * Without it a send goes to the transport as before.\n *\n * - `ownerId` names whose they are (the signed-in person, with the environment). Another owner's\n *   messages are never shown or sent: each owner's are sealed under their own key.\n * - `getKey(purpose)` returns the AES-GCM key: `read` opens what is kept (the key if one exists,\n *   never made for this), `write` keeps a new message (only while the deployment lets devices keep\n *   copies). With no `write` key when a conversation opens, its messages wait in memory only, for\n *   as long as the page stays open. Unlike the chat history's, this key guards the only copy of\n *   what someone wrote: a host must never replace or drop it except at a sign-out the person chose.\n * - `reachability` says Athena can be reached: the host's own model (the device online AND agora\n *   answering a health read, as Midas's main process decides it), by default the browser being\n *   online. Either way a conversation whose own channel keeps failing to connect counts as out of\n *   reach too.\n * - `foreground` says the app is in front; by default a visible document. A desktop host passes\n *   `windowInFrontSignal()` (visible and focused).\n * - `openThread` opens another of the person's conversations the tray lists as holding waiting\n *   messages (`newChat`: one that never started). Without it, a provider with a thread list\n *   switches to it; otherwise the tray names it without Open.\n */\nexport interface AthenaChatOutbox {\n  ownerId: string;\n  getKey: ChatSessionKeyProvider;\n  reachability?: ChatOutboxSignal;\n  foreground?: ChatOutboxSignal;\n  openThread?: (target: { threadId: string; newChat: boolean }) => void;\n}\n\n/**\n * Where a conversation's session (and so its waiting messages) lives when the provider keeps a\n * chat outbox: `pending` until the owner's namespace and write key are known, then sealed in\n * IndexedDB, or in page memory where there is no write key (or no IndexedDB).\n */\nexport type AthenaChatSessionKeeping =\n  | { kind: 'pending' }\n  | {\n      kind: 'sealed';\n      namespace: string;\n      /** The owner's statewire principal ({@link ChatOutboxOwnerStorage.principal}). */\n      principal: string;\n      codec: ChatOutboxOwnerStorage['codec'];\n    }\n  | {\n      kind: 'memory';\n      scope: string;\n      /** The owner's statewire principal ({@link ChatOutboxOwnerStorage.principal}). */\n      principal: string;\n      /**\n       * Conversations that already kept messages sealed on this device when the write key went\n       * (the deployment stopped letting devices keep copies): they reopen that record with the\n       * read key, so what waits there can still be sent, edited or discarded.\n       */\n      sealedThreads?: {\n        namespace: string;\n        codec: ChatOutboxOwnerStorage['codec'];\n        threads: ReadonlySet<string>;\n      };\n    };\n\n/**\n * Where `owner`'s conversations keep their sessions now: sealed when this page can keep sealed\n * sessions and the host gives a write key, in memory otherwise.\n */\nexport async function resolveChatSessionKeeping(\n  owner: ChatOutboxOwnerStorage,\n): Promise<Exclude<AthenaChatSessionKeeping, { kind: 'pending' }>> {\n  const namespace = await owner.namespace;\n  if (namespace !== null) {\n    const writeKey = await owner.host.current.getKey('write').catch(() => null);\n    if (writeKey) return { kind: 'sealed', namespace, principal: owner.principal, codec: owner.codec };\n    const threads = await threadsKeptSealed(owner, namespace);\n    if (threads.size > 0) {\n      return {\n        kind: 'memory',\n        scope: owner.memoryScope,\n        principal: owner.principal,\n        sealedThreads: { namespace, codec: owner.drainCodec, threads },\n      };\n    }\n  }\n  return { kind: 'memory', scope: owner.memoryScope, principal: owner.principal };\n}\n\n/** Threads whose sealed record holds waiting messages this page can open with the read key. */\nasync function threadsKeptSealed(\n  owner: ChatOutboxOwnerStorage,\n  namespace: string,\n): Promise<ReadonlySet<string>> {\n  const readKey = await owner.host.current.getKey('read').catch(() => null);\n  if (!readKey) return new Set();\n  const listing = await listChatOutboxes({\n    backend: chatSessionBackend(),\n    namespace,\n    principal: owner.principal,\n    codec: owner.codec,\n  }).catch(() => EMPTY_LISTING);\n  return new Set(\n    listing.threads.filter(({ entries }) => entries.length > 0).map(({ threadId }) => threadId),\n  );\n}\n\n/** The environment chat sessions of the SDK are kept under (`ownerId` already names the deployment). */\nconst SDK_CHAT_SESSION_ENVIRONMENT = 'athena-sdk';\n\n/**\n * Where one owner's waiting messages live in this page: each conversation's statewire session\n * (sealed in IndexedDB, or in page memory where there is no write key), the previous build's\n * store until each conversation moves its messages over, and one live list of all of them.\n */\nexport interface ChatOutboxOwnerStorage {\n  ownerId: string;\n  /**\n   * The owner's statewire principal (`user:<ownerId>`): the owner is the account the host names,\n   * and every session record sits under it (`<namespace><principal>:<threadId>`).\n   */\n  principal: string;\n  /** Seals and opens this owner's session records with the latest host's key. */\n  codec: ReturnType<typeof createSealedSessionCodec>;\n  /**\n   * Reopens a record already kept on the device once there is no write key, rewriting it with the\n   * read key only as its waiting messages are sent or discarded (`sealedThreads`).\n   */\n  drainCodec: ReturnType<typeof createSealedSessionCodec>;\n  /** The previous build's sealed store (`athena-chat-outbox:v1`). */\n  legacy: LegacyChatOutboxReader;\n  /** The owner's sealed-session namespace; `null` where this page cannot keep sealed sessions. */\n  namespace: Promise<string | null>;\n  /** The page-memory sessions' scope (`ChatSessionStorage({kind: 'memory', scope})`). */\n  memoryScope: string;\n  /** Every conversation's waiting messages, sealed and in memory. */\n  directory: ChatOutboxDirectory;\n  /** The latest host of this owner: the codec and the legacy reader ask it for the key. */\n  host: { current: AthenaChatOutbox };\n  /** Drops the keys the codec kept (a sign-out): the next seal asks the host again. */\n  forgetKeys: () => void;\n}\n\n// process-local: one storage per owner in this page, so every provider of the person (a chat in a\n// tab, another in a pane) shares one codec (statewire keys a session by it), one live list and the\n// page-memory sessions of conversations this device could not keep.\nconst owners = new Map<string, ChatOutboxOwnerStorage>();\n\n/** A host that has no key to give (counting and deleting never need one). */\nfunction keylessHost(ownerId: string): AthenaChatOutbox {\n  return { ownerId, getKey: async () => null };\n}\n\nfunction canKeepSealedSessions(): boolean {\n  return (\n    typeof indexedDB !== 'undefined' &&\n    typeof crypto !== 'undefined' &&\n    typeof crypto.subtle !== 'undefined'\n  );\n}\n\nfunction memorySource(ownerId: string): ChatOutboxStorageSource {\n  return {\n    backend: chatSessionMemoryBackend(),\n    namespace: chatSessionMemoryNamespace(ownerId),\n    principal: sessionPrincipal(ownerId),\n  };\n}\n\nfunction sealedSource(\n  owner: Pick<ChatOutboxOwnerStorage, 'codec' | 'legacy' | 'principal'>,\n  namespace: string,\n): ChatOutboxStorageSource {\n  return {\n    backend: chatSessionBackend(),\n    namespace,\n    principal: owner.principal,\n    codec: owner.codec,\n    legacy: owner.legacy,\n  };\n}\n\nconst EMPTY_LISTING: ChatOutboxListing = { threads: [], unreadable: 0 };\n\n/** Both listings as one: a thread's entries from either, oldest first; threads by their oldest. */\nfunction mergeListings(a: ChatOutboxListing, b: ChatOutboxListing): ChatOutboxListing {\n  if (b.threads.length === 0 && b.unreadable === 0) return a;\n  if (a.threads.length === 0 && a.unreadable === 0) return b;\n  const byThread = new Map<string, ChatOutboxListedEntry[]>();\n  for (const thread of [...a.threads, ...b.threads]) {\n    const list = byThread.get(thread.threadId) ?? [];\n    for (const entry of thread.entries) if (!list.some(({ id }) => id === entry.id)) list.push(entry);\n    byThread.set(thread.threadId, list);\n  }\n  const threads: ChatOutboxDirectoryThread[] = [...byThread]\n    .map(([threadId, entries]) => ({\n      threadId,\n      entries: entries.sort((x, y) => x.queuedAt - y.queuedAt),\n    }))\n    .sort((x, y) => (x.entries[0]?.queuedAt ?? 0) - (y.entries[0]?.queuedAt ?? 0));\n  return { threads, unreadable: a.unreadable + b.unreadable };\n}\n\n/** What a listing shows, as one string: two reads of the same messages compare equal. */\nfunction listingSignature(listing: ChatOutboxListing): string {\n  return JSON.stringify([\n    listing.unreadable,\n    listing.threads.map(({ threadId, entries }) => [\n      threadId,\n      entries.map(({ id, state, failed, queuedAt, text }) => [id, state, failed, queuedAt, text]),\n    ]),\n  ]);\n}\n\n/**\n * The sealed directory (once the namespace resolves) and the memory one as one directory, with one\n * snapshot object per pair of inner snapshots.\n */\nfunction mergedDirectory({\n  memory,\n  sealed,\n}: {\n  memory: ChatOutboxDirectory;\n  sealed: Promise<ChatOutboxDirectory | null>;\n}): ChatOutboxDirectory {\n  let sealedDirectory: ChatOutboxDirectory | null = null;\n  let cached: { memory: ChatOutboxListing; sealed: ChatOutboxListing; merged: ChatOutboxListing } | null = null;\n  const listeners = new Set<() => void>();\n  let stops: (() => void)[] = [];\n  let generation = 0;\n  // Inner directories hand out a new listing on every read: listeners hear only a change.\n  let heard = listingSignature(EMPTY_LISTING);\n  const notify = () => {\n    const signature = listingSignature(directory.getSnapshot());\n    if (signature === heard) return;\n    heard = signature;\n    for (const listener of [...listeners]) {\n      try {\n        listener();\n      } catch {\n        // A listener's fault never reaches the directory.\n      }\n    }\n  };\n  const start = () => {\n    const started = ++generation;\n    stops.push(memory.subscribe(notify));\n    memory.refresh();\n    void sealed.then((directory) => {\n      sealedDirectory = directory;\n      if (!directory || started !== generation || listeners.size === 0) return;\n      stops.push(directory.subscribe(notify));\n      directory.refresh();\n    });\n  };\n  const directory: ChatOutboxDirectory = {\n    getSnapshot() {\n      const memorySnapshot = memory.getSnapshot();\n      const sealedSnapshot = sealedDirectory?.getSnapshot() ?? EMPTY_LISTING;\n      if (!cached || cached.memory !== memorySnapshot || cached.sealed !== sealedSnapshot) {\n        cached = {\n          memory: memorySnapshot,\n          sealed: sealedSnapshot,\n          merged: mergeListings(sealedSnapshot, memorySnapshot),\n        };\n      }\n      return cached.merged;\n    },\n    subscribe(listener) {\n      listeners.add(listener);\n      if (listeners.size === 1) start();\n      return () => {\n        listeners.delete(listener);\n        if (listeners.size === 0) {\n          generation += 1;\n          for (const stop of stops) stop();\n          stops = [];\n        }\n      };\n    },\n    refresh() {\n      memory.refresh();\n      sealedDirectory?.refresh();\n    },\n  };\n  return directory;\n}\n\n/**\n * The key the sealed sessions use, per purpose, asked of the latest host once and kept while that\n * host stays: a session seals its record on every save, and a host that asks its key of another\n * process (the desktop's main) must not be asked on each one. No key is asked again next time.\n */\nfunction sessionKeys(current: { current: AthenaChatOutbox }): {\n  getKey: ChatSessionKeyProvider;\n  forget: () => void;\n} {\n  let keysOf: AthenaChatOutbox | null = null;\n  const keys = new Map<ChatSessionKeyPurpose, Promise<CryptoKey | null>>();\n  const getKey: ChatSessionKeyProvider = (purpose) => {\n    const host = current.current;\n    if (keysOf !== host) {\n      keysOf = host;\n      keys.clear();\n    }\n    let key = keys.get(purpose);\n    if (!key) {\n      const asked = host.getKey(purpose).catch(() => null);\n      key = asked;\n      keys.set(purpose, asked);\n      void asked.then((value) => {\n        if (value === null && keys.get(purpose) === asked) keys.delete(purpose);\n      });\n    }\n    return key;\n  };\n  return { getKey, forget: () => keys.clear() };\n}\n\nfunction ownerStorage(ownerId: string, host?: AthenaChatOutbox): ChatOutboxOwnerStorage {\n  let owner = owners.get(ownerId);\n  if (!owner) {\n    const current = { current: host ?? keylessHost(ownerId) };\n    const principal = sessionPrincipal(ownerId);\n    const sealedAvailable = canKeepSealedSessions();\n    // The namespace is the owner's: the records statewire 0.24 kept in it without the principal in\n    // the key are theirs, and move under it before anything mounts or lists them.\n    const namespace: Promise<string | null> = sealedAvailable\n      ? chatSessionNamespace({ environment: SDK_CHAT_SESSION_ENVIRONMENT, ownerId })\n          .then(async (resolved) => {\n            await adoptUnscopedChatSessions({\n              backend: chatSessionBackend(),\n              namespace: resolved,\n              principal,\n            }).catch(() => 0);\n            return resolved;\n          })\n          .catch(() => null)\n      : Promise.resolve(null);\n    const keys = sessionKeys(current);\n    const codec = createSealedSessionCodec({ getKey: keys.getKey, scope: ownerId });\n    const drainCodec = createSealedSessionCodec({\n      getKey: (purpose) => keys.getKey(purpose === 'write' ? 'read' : purpose),\n      scope: ownerId,\n    });\n    const legacy = createLegacyChatOutboxReader({\n      ownerId,\n      getKey: () => current.current.getKey('read'),\n    });\n    const directory = mergedDirectory({\n      memory: createChatOutboxDirectory(memorySource(ownerId)),\n      sealed: namespace.then((resolved) =>\n        resolved === null\n          ? null\n          : createChatOutboxDirectory(sealedSource({ codec, legacy, principal }, resolved)),\n      ),\n    });\n    owner = {\n      ownerId,\n      principal,\n      codec,\n      drainCodec,\n      legacy,\n      namespace,\n      memoryScope: ownerId,\n      host: current,\n      directory,\n      forgetKeys: keys.forget,\n    };\n    owners.set(ownerId, owner);\n  }\n  if (host) owner.host.current = host;\n  return owner;\n}\n\n/** The page's chat outbox storage for `host`'s owner, made on first use. */\nexport function chatOutboxStorageFor(host: AthenaChatOutbox): ChatOutboxOwnerStorage {\n  return ownerStorage(host.ownerId, host);\n}\n\n/** The owner's sealed source, or `null` where this page keeps no sealed sessions. */\nasync function sealedSourceOf(owner: ChatOutboxOwnerStorage): Promise<ChatOutboxStorageSource | null> {\n  const namespace = await owner.namespace;\n  return namespace === null ? null : sealedSource(owner, namespace);\n}\n\n/**\n * How many messages wait for `ownerId` (kept on the device, including records this build cannot\n * open, and waiting in this page's memory), counted without asking for a key it does not have.\n * Rejects when the device's records cannot be counted at all.\n */\nexport async function countChatOutboxMessages(ownerId: string): Promise<number> {\n  const owner = ownerStorage(ownerId);\n  const sealed = await sealedSourceOf(owner);\n  const [kept, inMemory] = await Promise.all([\n    sealed ? countChatOutboxSource(sealed) : 0,\n    countChatOutboxSource(memorySource(ownerId)),\n  ]);\n  return kept + inMemory;\n}\n\n/**\n * Calls `listener` after any change to `ownerId`'s waiting messages, this window's or another's\n * (one kept, handed to its conversation, cancelled, failed or retried), so a host can show how many\n * wait (`countChatOutboxMessages`) without asking on a timer. Returns what stops it.\n */\nexport function subscribeChatOutbox(ownerId: string, listener: () => void): () => void {\n  return ownerStorage(ownerId).directory.subscribe(listener);\n}\n\n/** A message waiting in an owner's outbox, as a host lists it (its \"Waiting to sync\" list). */\nexport interface ChatOutboxMessageSummary {\n  id: string;\n  threadId: string;\n  /** The text as it will be sent. */\n  text: string;\n  /** Typed into a chat that had never started. */\n  newChat: boolean;\n  /**\n   * Where it stands, as the queue tray shows it: waiting to be sent, handed to its conversation\n   * (released from the outbox and on its way, or sent and not answered yet), waiting for the person\n   * (it waited more than a day: Send, Edit or Discard), or failed (Retry, Edit or Discard; never\n   * retried on its own).\n   */\n  status: 'waiting' | 'sending' | 'ask' | 'failed';\n  /** Kept only in this page's memory: this device could not keep it. */\n  inMemory: boolean;\n  /**\n   * When it was typed, or sent where it went at once (epoch ms). A host counts a message `sending`\n   * as waiting to sync only once it goes unaccepted for a while (`messageWaitsToSync` in\n   * `@athenaintel/agent-runtime/offline-status`): the list holds every send until its answer is\n   * written back, an ordinary one on its way included.\n   */\n  queuedAt: number;\n}\n\nfunction summaryOf(\n  entry: ChatOutboxListedEntry,\n  { inMemory, now }: { inMemory: boolean; now: number },\n): ChatOutboxMessageSummary {\n  return {\n    id: entry.id,\n    threadId: entry.threadId,\n    text: entry.text,\n    newChat: entry.newChat,\n    status: entry.failed\n      ? 'failed'\n      : entry.state !== undefined && entry.state !== 'held'\n        ? 'sending'\n        : now - entry.queuedAt > CHAT_OUTBOX_ASK_AFTER_MS\n          ? 'ask'\n          : 'waiting',\n    inMemory,\n    queuedAt: entry.queuedAt,\n  };\n}\n\n/**\n * The messages waiting for `ownerId` that this page can open (oldest first), each with where it\n * stands, for a host's list of what waits to sync; the tray in the conversation acts on them.\n * Records this page cannot open (no key here, a newer build's) are left out, so a host counts with\n * `countChatOutboxMessages`.\n */\nexport async function listChatOutboxMessages(\n  ownerId: string,\n  now: number = Date.now(),\n): Promise<ChatOutboxMessageSummary[]> {\n  const owner = ownerStorage(ownerId);\n  const sealed = await sealedSourceOf(owner);\n  const [kept, inMemory] = await Promise.all([\n    sealed ? listChatOutboxes(sealed) : EMPTY_LISTING,\n    listChatOutboxes(memorySource(ownerId)),\n  ]);\n  const summaries = [\n    ...kept.threads.flatMap(({ entries }) =>\n      entries.map((entry) => summaryOf(entry, { inMemory: false, now })),\n    ),\n    ...inMemory.threads.flatMap(({ entries }) =>\n      entries.map((entry) => summaryOf(entry, { inMemory: true, now })),\n    ),\n  ];\n  return summaries.sort((a, b) => a.queuedAt - b.queuedAt);\n}\n\n/** A sign-out the person chose: every message waiting for `ownerId` goes, on the device and in memory. */\nexport async function clearChatOutbox(ownerId: string): Promise<void> {\n  const owner = ownerStorage(ownerId);\n  const sealed = await sealedSourceOf(owner);\n  owner.forgetKeys();\n  if (sealed) await clearChatOutboxes(sealed);\n  else await owner.legacy.clear();\n  await clearChatOutboxes(memorySource(ownerId));\n  owner.directory.refresh();\n}\n\n/**\n * Deletes the records kept on this device for `ownerId`, never the messages waiting in this page's\n * memory: for a host whose key for them no longer exists (a chosen sign-out deleted it before the\n * page could delete the records), so nothing can ever open them and they must not be counted.\n */\nexport async function clearUnopenableChatOutbox(ownerId: string): Promise<void> {\n  const owner = ownerStorage(ownerId);\n  owner.forgetKeys();\n  const sealed = await sealedSourceOf(owner);\n  if (sealed) await clearChatOutboxes(sealed);\n  else await owner.legacy.clear();\n  owner.directory.refresh();\n}\n"],"names":["directory","countChatOutboxSource"],"mappings":"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"}