@athenaintel/react 0.57.2 → 0.59.0

package/dist/keryx-http/src/update-attributions.d.ts

@@ -38,13 +38,22 @@ export declare const UPDATE_ATTRIBUTIONS_TRAILER_V1 = 1;
 /**
  * Run `run` with every update it writes into `doc` marked with `attributions`. Synchronous only:
  * the scope ends when `run` returns. Nested scopes restore the outer one.
+ *
+ * A transaction `run` begins while another transaction's events are delivered (an editor binding
+ * writing the fix a remote change needs, from inside that change's observers) is queued by Yjs, and
+ * its update is emitted, and sent, after `run` returns. Such a transaction is marked as it begins,
+ * so its update carries `attributions` too: a housekeeping write never goes out as the person's.
  */
 export declare function runWithDocUpdateAttributions<T>({ doc, attributions, run, }: {
     doc: object;
     attributions: readonly UpdateAttribution[];
     run: () => T;
 }): T;
-/** The attributions the update being written into `doc` right now carries, if any. */
+/**
+ * The attributions the update being written into `doc` right now carries, if any: those of the
+ * scope that began the transaction whose update `doc` is emitting, else those of the scope open
+ * now.
+ */
 export declare function docUpdateAttributions(doc: object): readonly UpdateAttribution[] | undefined;
 /** The lib0 varUint at `start` in `bytes` and where the next field begins; `null` past the end. */
 export declare function readVarUint({ bytes, start, }: {

package/dist/keryx-http/src/update-attributions.js

@@ -9,6 +9,27 @@ function docScopes() {
   const host = globalThis;
   return host[DOC_SCOPES] ?? (host[DOC_SCOPES] = /* @__PURE__ */ new WeakMap());
 }
+const TRANSACTION_MARKS = Symbol.for("@athenaintel/keryx-http/update-attribution-transactions");
+function transactionMarks() {
+  const host = globalThis;
+  return host[TRANSACTION_MARKS] ?? (host[TRANSACTION_MARKS] = { marked: /* @__PURE__ */ new WeakMap(), emitting: /* @__PURE__ */ new WeakMap(), followed: /* @__PURE__ */ new WeakSet() });
+}
+function hasTransactionEvents(doc) {
+  const events = doc;
+  return typeof events.on === "function" && typeof events.off === "function";
+}
+function markTransactionsBegun(doc, attributions) {
+  if (!hasTransactionEvents(doc)) return null;
+  const marks = transactionMarks();
+  if (!marks.followed.has(doc)) {
+    marks.followed.add(doc);
+    doc.on("afterTransactionCleanup", (transaction) => marks.emitting.set(doc, transaction));
+    doc.on("afterAllTransactions", () => marks.emitting.delete(doc));
+  }
+  const mark = (transaction) => marks.marked.set(transaction, attributions);
+  doc.on("beforeTransaction", mark);
+  return () => doc.off("beforeTransaction", mark);
+}
 function runWithDocUpdateAttributions({
   doc,
   attributions,
@@ -17,15 +38,19 @@ function runWithDocUpdateAttributions({
   const scopes = docScopes();
   const outer = scopes.get(doc);
   scopes.set(doc, attributions);
+  const stopMarking = markTransactionsBegun(doc, attributions);
   try {
     return run();
   } finally {
+    stopMarking == null ? void 0 : stopMarking();
     if (outer === void 0) scopes.delete(doc);
     else scopes.set(doc, outer);
   }
 }
 function docUpdateAttributions(doc) {
-  return docScopes().get(doc);
+  const marks = transactionMarks();
+  const emitting = marks.emitting.get(doc);
+  return (emitting === void 0 ? void 0 : marks.marked.get(emitting)) ?? docScopes().get(doc);
 }
 function readVarUint({
   bytes,

package/dist/keryx-http/src/update-attributions.js.map

@@ -1 +1 @@
-{"version":3,"file":"update-attributions.js","sources":["../../../../keryx-http/src/update-attributions.ts"],"sourcesContent":["/**\n * Attributions one Keryx socket update carries of its own.\n *\n * A Keryx connection's attributions are fixed when its socket opens, so every update a client\n * sends is attributed to the person whose client it is. A write the client makes on its own (the\n * sheet leader re-issuing `=AOP` formulas or re-pushing `=IMPORTRANGE` values, a restored result,\n * an editor binding re-keying what an older binding stored) read as that person's edit and woke\n * \"people only\" subscriptions. Keryx reads a trailer after the update in a sync update message\n * (`readUpdateAttributions` in `patches/@y%2Fhub@0.10.1.patch`): `varUint(1)`, `varUint(n)`, then\n * `n` pairs of `varString` key and value. It accepts only `origin: background`, which it counts as\n * system work (`actorOf` in `keryx/src/compaction-activity.ts`), and the pairs that name a Quick\n * Edit step (`@athenaintel/keryx-http/quick-edit`: `session_id`/`run_kind` on the apply,\n * `quick_edit_undo`/`quick_edit_redo` with `quick_edit_op` on an undo or redo), each value in\n * exactly its shape. A Keryx without that hunk reads the update and ignores the bytes after it, so\n * a trailer never costs an update; a pair it does not allow is dropped and the rest kept.\n *\n * A writer marks its writes by making them inside {@link runWithDocUpdateAttributions} for the\n * doc; the transport's socket ({@link attributingWebSocket}) appends the trailer to each sync\n * update it sends while that scope is open. Both Keryx transports wrap their sockets with it:\n * Olympus's rooms (`KeryxYjsProviderV14`) and `@athenaintel/react/collab`'s `connectGenericDoc`\n * (Midas, the phone's editor page). y-websocket sends a local update from inside the doc's\n * `update` event, which fires inside the write itself, so the trailer always rides on the update\n * the scope wrote. A write made while the socket is closed is not sent then: it reaches Keryx in\n * the reconnect's sync step 2, which can carry no trailer. A transport that hands its socket the\n * room's {@link UnconfirmedAttributedWrites} (`@athenaintel/keryx-http/unconfirmed-update-attributions`)\n * sends each such write ahead of that sync step 2 as its own marked update; without one it stays\n * the person's.\n */\n\n/** One custom attribution, as Keryx stores it on the items an update wrote. */\nexport interface UpdateAttribution {\n  k: string;\n  v: string;\n}\n\n/** The pair a housekeeping write carries; Agora and Keryx spell it the same way. */\nexport const BACKGROUND_UPDATE_ATTRIBUTIONS: readonly UpdateAttribution[] = [\n  { k: 'origin', v: 'background' },\n];\n\n/** The trailer format Keryx reads (`updateAttributionsTrailerV1`). */\nexport const UPDATE_ATTRIBUTIONS_TRAILER_V1 = 1;\n\n/** y-protocols: a sync message, and its update sub-type. */\nconst MESSAGE_SYNC = 0;\nconst MESSAGE_SYNC_UPDATE = 2;\n\n/**\n * The open scopes live on `globalThis`, not in module scope, because two copies of this module can\n * run in one page: `@athenaintel/react` bundles it into its dist (this package is private, so the\n * published SDK must inline it) while a host may import it from this package. A scope a writer\n * opens through one copy must be the one the transport's socket reads through the other.\n */\nconst DOC_SCOPES = Symbol.for('@athenaintel/keryx-http/update-attribution-scopes');\n\ntype DocScopesHost = typeof globalThis & {\n  [DOC_SCOPES]?: WeakMap<object, readonly UpdateAttribution[]>;\n};\n\n// process-local: browser-only scopes, each keyed by the doc it guards and cleared in the same synchronous call that set it\nfunction docScopes(): WeakMap<object, readonly UpdateAttribution[]> {\n  const host = globalThis as DocScopesHost;\n  return (host[DOC_SCOPES] ??= new WeakMap());\n}\n\n/**\n * Run `run` with every update it writes into `doc` marked with `attributions`. Synchronous only:\n * the scope ends when `run` returns. Nested scopes restore the outer one.\n */\nexport function runWithDocUpdateAttributions<T>({\n  doc,\n  attributions,\n  run,\n}: {\n  doc: object;\n  attributions: readonly UpdateAttribution[];\n  run: () => T;\n}): T {\n  const scopes = docScopes();\n  const outer = scopes.get(doc);\n  scopes.set(doc, attributions);\n  try {\n    return run();\n  } finally {\n    if (outer === undefined) scopes.delete(doc);\n    else scopes.set(doc, outer);\n  }\n}\n\n/** The attributions the update being written into `doc` right now carries, if any. */\nexport function docUpdateAttributions(doc: object): readonly UpdateAttribution[] | undefined {\n  return docScopes().get(doc);\n}\n\n/** The lib0 varUint at `start` in `bytes` and where the next field begins; `null` past the end. */\nexport function readVarUint({\n  bytes,\n  start,\n}: {\n  bytes: Uint8Array;\n  start: number;\n}): { value: number; next: number } | null {\n  let value = 0;\n  let multiplier = 1;\n  for (let pos = start; pos < bytes.length; pos += 1) {\n    const byte = bytes[pos];\n    if (byte === undefined) return null;\n    value += (byte & 0x7f) * multiplier;\n    if (byte < 0x80) return { value, next: pos + 1 };\n    multiplier *= 0x80;\n    if (multiplier > Number.MAX_SAFE_INTEGER) return null;\n  }\n  return null;\n}\n\n/** Append `value` to `out` as a lib0 varUint. */\nexport function writeVarUint({ out, value }: { out: number[]; value: number }): void {\n  let rest = value;\n  while (rest > 0x7f) {\n    out.push(0x80 | (rest % 0x80));\n    rest = Math.floor(rest / 0x80);\n  }\n  out.push(rest);\n}\n\n/** Exactly one sync update message, with nothing after the update. */\nfunction isBareSyncUpdate(message: Uint8Array): boolean {\n  const type = readVarUint({ bytes: message, start: 0 });\n  if (type?.value !== MESSAGE_SYNC) return false;\n  const syncType = readVarUint({ bytes: message, start: type.next });\n  if (syncType?.value !== MESSAGE_SYNC_UPDATE) return false;\n  const length = readVarUint({ bytes: message, start: syncType.next });\n  return length !== null && length.next + length.value === message.length;\n}\n\n/**\n * `message` with the trailer for `attributions` appended, when it is a bare sync update message;\n * any other message (sync step 1 or 2, awareness, one that already ends in a trailer) is returned\n * as it is.\n */\nexport function withUpdateAttributionsTrailer({\n  message,\n  attributions,\n}: {\n  message: Uint8Array;\n  attributions: readonly UpdateAttribution[];\n}): Uint8Array {\n  if (attributions.length === 0 || !isBareSyncUpdate(message)) return message;\n  const trailer: number[] = [];\n  writeVarUint({ out: trailer, value: UPDATE_ATTRIBUTIONS_TRAILER_V1 });\n  writeVarUint({ out: trailer, value: attributions.length });\n  const utf8 = new TextEncoder();\n  for (const { k, v } of attributions) {\n    for (const text of [k, v]) {\n      const bytes = utf8.encode(text);\n      writeVarUint({ out: trailer, value: bytes.length });\n      for (const byte of bytes) trailer.push(byte);\n    }\n  }\n  const out = new Uint8Array(message.length + trailer.length);\n  out.set(message, 0);\n  out.set(trailer, message.length);\n  return out;\n}\n\n/** What {@link attributingWebSocket} needs of a socket: the `send` y-websocket writes frames with. */\nexport interface SendingSocket {\n  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;\n}\n\n/** One socket of a room, as the room's attributed writes Keryx has not acknowledged see it. */\nexport interface AttributedWritesSocket {\n  /** Keryx sent `frame` on the socket: what it carries, Keryx holds. */\n  received(frame: Uint8Array): void;\n  /** The socket sends `frame` (now, or once Keryx has sent what it holds; see the implementation). */\n  send(frame: Uint8Array): void;\n}\n\n/**\n * The room's attributed writes Keryx has not acknowledged yet, as its sockets see them\n * (`UnconfirmedUpdateAttributions` in `@athenaintel/keryx-http/unconfirmed-update-attributions`).\n */\nexport interface UnconfirmedAttributedWrites {\n  /**\n   * A socket opened, sending through `send`. `hears`: the socket hands it every frame Keryx sends\n   * (`received`), ahead of the transport.\n   */\n  connect(params: { send: (frame: Uint8Array) => void; hears: boolean }): AttributedWritesSocket;\n}\n\n/** The bytes of a binary frame a socket received, or `null` for one that is not (a string, a `Blob`). */\nfunction receivedBytes(data: unknown): Uint8Array | null {\n  if (data instanceof ArrayBuffer) return new Uint8Array(data);\n  if (ArrayBuffer.isView(data))\n    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n  return null;\n}\n\n/**\n * Hands `onFrame` every binary frame `socket` receives; whether it can. A listener added before\n * y-websocket sets `onmessage` runs ahead of it. A socket without `addEventListener` hands nothing.\n */\nfunction listenToFrames({\n  socket,\n  onFrame,\n}: {\n  socket: SendingSocket;\n  onFrame: (frame: Uint8Array) => void;\n}): boolean {\n  if (!('addEventListener' in socket) || typeof socket.addEventListener !== 'function') {\n    return false;\n  }\n  socket.addEventListener('message', (event: { data?: unknown }) => {\n    const frame = receivedBytes(event.data);\n    if (frame) onFrame(frame);\n  });\n  return true;\n}\n\n/**\n * `Base` with `send` appending the trailer of `attributionsFor()` to each sync update it sends.\n * With the room's `unconfirmed` attributed writes, each socket also tells them every frame Keryx\n * sends and sends its frames through them, so a sync step 2 goes out behind the kept writes it\n * carries. A `Proxy` keeps the constructor's statics and type, so it drops in as y-websocket's\n * `WebSocketPolyfill`.\n */\nexport function attributingWebSocket<TBase extends new (...args: never[]) => SendingSocket>({\n  Base,\n  attributionsFor,\n  unconfirmed,\n}: {\n  Base: TBase;\n  attributionsFor: () => readonly UpdateAttribution[] | undefined;\n  unconfirmed?: UnconfirmedAttributedWrites;\n}): TBase {\n  // No WebSocket where the provider is built (server render, a test without one): nothing to wrap,\n  // and the transport fails at connect as it always did.\n  if (typeof Base !== 'function') return Base;\n  return new Proxy(Base, {\n    construct(target, args) {\n      const socket: SendingSocket = Reflect.construct(target, args);\n      const send = socket.send.bind(socket);\n      let connection: AttributedWritesSocket | null = null;\n      if (unconfirmed) {\n        const hears = listenToFrames({ socket, onFrame: (frame) => connection?.received(frame) });\n        connection = unconfirmed.connect({ send, hears });\n      }\n      socket.send = (data) => {\n        if (!(data instanceof Uint8Array)) {\n          send(data);\n          return;\n        }\n        const attributions = attributionsFor();\n        const message = attributions\n          ? withUpdateAttributionsTrailer({ message: data, attributions })\n          : data;\n        if (connection) connection.send(message);\n        else send(message);\n      };\n      return socket;\n    },\n  });\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"update-attributions.js","sources":["../../../../keryx-http/src/update-attributions.ts"],"sourcesContent":["/**\n * Attributions one Keryx socket update carries of its own.\n *\n * A Keryx connection's attributions are fixed when its socket opens, so every update a client\n * sends is attributed to the person whose client it is. A write the client makes on its own (the\n * sheet leader re-issuing `=AOP` formulas or re-pushing `=IMPORTRANGE` values, a restored result,\n * an editor binding re-keying what an older binding stored) read as that person's edit and woke\n * \"people only\" subscriptions. Keryx reads a trailer after the update in a sync update message\n * (`readUpdateAttributions` in `patches/@y%2Fhub@0.10.1.patch`): `varUint(1)`, `varUint(n)`, then\n * `n` pairs of `varString` key and value. It accepts only `origin: background`, which it counts as\n * system work (`actorOf` in `keryx/src/compaction-activity.ts`), and the pairs that name a Quick\n * Edit step (`@athenaintel/keryx-http/quick-edit`: `session_id`/`run_kind` on the apply,\n * `quick_edit_undo`/`quick_edit_redo` with `quick_edit_op` on an undo or redo), each value in\n * exactly its shape. A Keryx without that hunk reads the update and ignores the bytes after it, so\n * a trailer never costs an update; a pair it does not allow is dropped and the rest kept.\n *\n * A writer marks its writes by making them inside {@link runWithDocUpdateAttributions} for the\n * doc; the transport's socket ({@link attributingWebSocket}) appends the trailer to each sync\n * update it sends while that scope is open. Both Keryx transports wrap their sockets with it:\n * Olympus's rooms (`KeryxYjsProviderV14`) and `@athenaintel/react/collab`'s `connectGenericDoc`\n * (Midas, the phone's editor page). y-websocket sends a local update from inside the doc's\n * `update` event, which fires inside the write itself, so the trailer always rides on the update\n * the scope wrote. A write made while the socket is closed is not sent then: it reaches Keryx in\n * the reconnect's sync step 2, which can carry no trailer. A transport that hands its socket the\n * room's {@link UnconfirmedAttributedWrites} (`@athenaintel/keryx-http/unconfirmed-update-attributions`)\n * sends each such write ahead of that sync step 2 as its own marked update; without one it stays\n * the person's.\n */\n\n/** One custom attribution, as Keryx stores it on the items an update wrote. */\nexport interface UpdateAttribution {\n  k: string;\n  v: string;\n}\n\n/** The pair a housekeeping write carries; Agora and Keryx spell it the same way. */\nexport const BACKGROUND_UPDATE_ATTRIBUTIONS: readonly UpdateAttribution[] = [\n  { k: 'origin', v: 'background' },\n];\n\n/** The trailer format Keryx reads (`updateAttributionsTrailerV1`). */\nexport const UPDATE_ATTRIBUTIONS_TRAILER_V1 = 1;\n\n/** y-protocols: a sync message, and its update sub-type. */\nconst MESSAGE_SYNC = 0;\nconst MESSAGE_SYNC_UPDATE = 2;\n\n/**\n * The open scopes live on `globalThis`, not in module scope, because two copies of this module can\n * run in one page: `@athenaintel/react` bundles it into its dist (this package is private, so the\n * published SDK must inline it) while a host may import it from this package. A scope a writer\n * opens through one copy must be the one the transport's socket reads through the other.\n */\nconst DOC_SCOPES = Symbol.for('@athenaintel/keryx-http/update-attribution-scopes');\n\ntype DocScopesHost = typeof globalThis & {\n  [DOC_SCOPES]?: WeakMap<object, readonly UpdateAttribution[]>;\n};\n\n// process-local: browser-only scopes, each keyed by the doc it guards and cleared in the same synchronous call that set it\nfunction docScopes(): WeakMap<object, readonly UpdateAttribution[]> {\n  const host = globalThis as DocScopesHost;\n  return (host[DOC_SCOPES] ??= new WeakMap());\n}\n\n/**\n * The transactions a scope began, by the attributions their update carries, and the transaction\n * whose update each doc is emitting now: on `globalThis` for the same reason as {@link DOC_SCOPES}.\n */\nconst TRANSACTION_MARKS = Symbol.for('@athenaintel/keryx-http/update-attribution-transactions');\n\ninterface TransactionMarks {\n  /** A transaction a scope began, by the attributions its update carries. */\n  readonly marked: WeakMap<object, readonly UpdateAttribution[]>;\n  /** The transaction whose update each doc emits now (from its cleanup to the end of the drain). */\n  readonly emitting: WeakMap<object, object>;\n  /** The docs whose emitting transaction is followed. */\n  readonly followed: WeakSet<object>;\n}\n\ntype TransactionMarksHost = typeof globalThis & { [TRANSACTION_MARKS]?: TransactionMarks };\n\n// process-local: browser-only, keyed weakly by the doc and its transactions, which drop them with them\nfunction transactionMarks(): TransactionMarks {\n  const host = globalThis as TransactionMarksHost;\n  return (host[TRANSACTION_MARKS] ??= { marked: new WeakMap(), emitting: new WeakMap(), followed: new WeakSet() });\n}\n\n/** What a scope listens to on a doc: Yjs 13's and `@y/y`'s `on`/`off` alike. */\ninterface TransactionEvents {\n  on(name: string, listener: (transaction: object) => void): void;\n  off(name: string, listener: (transaction: object) => void): void;\n}\n\nfunction hasTransactionEvents(doc: object): doc is TransactionEvents {\n  const events = doc as Partial<TransactionEvents>;\n  return typeof events.on === 'function' && typeof events.off === 'function';\n}\n\n/**\n * Mark every transaction of `doc` that begins until the returned function is called with\n * `attributions`, and follow which transaction's update `doc` emits. Yjs emits a transaction's\n * update right after its `afterTransactionCleanup`, and sends none outside a drain.\n */\nfunction markTransactionsBegun(doc: object, attributions: readonly UpdateAttribution[]): (() => void) | null {\n  if (!hasTransactionEvents(doc)) return null;\n  const marks = transactionMarks();\n  if (!marks.followed.has(doc)) {\n    marks.followed.add(doc);\n    doc.on('afterTransactionCleanup', (transaction) => marks.emitting.set(doc, transaction));\n    doc.on('afterAllTransactions', () => marks.emitting.delete(doc));\n  }\n  const mark = (transaction: object) => marks.marked.set(transaction, attributions);\n  doc.on('beforeTransaction', mark);\n  return () => doc.off('beforeTransaction', mark);\n}\n\n/**\n * Run `run` with every update it writes into `doc` marked with `attributions`. Synchronous only:\n * the scope ends when `run` returns. Nested scopes restore the outer one.\n *\n * A transaction `run` begins while another transaction's events are delivered (an editor binding\n * writing the fix a remote change needs, from inside that change's observers) is queued by Yjs, and\n * its update is emitted, and sent, after `run` returns. Such a transaction is marked as it begins,\n * so its update carries `attributions` too: a housekeeping write never goes out as the person's.\n */\nexport function runWithDocUpdateAttributions<T>({\n  doc,\n  attributions,\n  run,\n}: {\n  doc: object;\n  attributions: readonly UpdateAttribution[];\n  run: () => T;\n}): T {\n  const scopes = docScopes();\n  const outer = scopes.get(doc);\n  scopes.set(doc, attributions);\n  const stopMarking = markTransactionsBegun(doc, attributions);\n  try {\n    return run();\n  } finally {\n    stopMarking?.();\n    if (outer === undefined) scopes.delete(doc);\n    else scopes.set(doc, outer);\n  }\n}\n\n/**\n * The attributions the update being written into `doc` right now carries, if any: those of the\n * scope that began the transaction whose update `doc` is emitting, else those of the scope open\n * now.\n */\nexport function docUpdateAttributions(doc: object): readonly UpdateAttribution[] | undefined {\n  const marks = transactionMarks();\n  const emitting = marks.emitting.get(doc);\n  return (emitting === undefined ? undefined : marks.marked.get(emitting)) ?? docScopes().get(doc);\n}\n\n/** The lib0 varUint at `start` in `bytes` and where the next field begins; `null` past the end. */\nexport function readVarUint({\n  bytes,\n  start,\n}: {\n  bytes: Uint8Array;\n  start: number;\n}): { value: number; next: number } | null {\n  let value = 0;\n  let multiplier = 1;\n  for (let pos = start; pos < bytes.length; pos += 1) {\n    const byte = bytes[pos];\n    if (byte === undefined) return null;\n    value += (byte & 0x7f) * multiplier;\n    if (byte < 0x80) return { value, next: pos + 1 };\n    multiplier *= 0x80;\n    if (multiplier > Number.MAX_SAFE_INTEGER) return null;\n  }\n  return null;\n}\n\n/** Append `value` to `out` as a lib0 varUint. */\nexport function writeVarUint({ out, value }: { out: number[]; value: number }): void {\n  let rest = value;\n  while (rest > 0x7f) {\n    out.push(0x80 | (rest % 0x80));\n    rest = Math.floor(rest / 0x80);\n  }\n  out.push(rest);\n}\n\n/** Exactly one sync update message, with nothing after the update. */\nfunction isBareSyncUpdate(message: Uint8Array): boolean {\n  const type = readVarUint({ bytes: message, start: 0 });\n  if (type?.value !== MESSAGE_SYNC) return false;\n  const syncType = readVarUint({ bytes: message, start: type.next });\n  if (syncType?.value !== MESSAGE_SYNC_UPDATE) return false;\n  const length = readVarUint({ bytes: message, start: syncType.next });\n  return length !== null && length.next + length.value === message.length;\n}\n\n/**\n * `message` with the trailer for `attributions` appended, when it is a bare sync update message;\n * any other message (sync step 1 or 2, awareness, one that already ends in a trailer) is returned\n * as it is.\n */\nexport function withUpdateAttributionsTrailer({\n  message,\n  attributions,\n}: {\n  message: Uint8Array;\n  attributions: readonly UpdateAttribution[];\n}): Uint8Array {\n  if (attributions.length === 0 || !isBareSyncUpdate(message)) return message;\n  const trailer: number[] = [];\n  writeVarUint({ out: trailer, value: UPDATE_ATTRIBUTIONS_TRAILER_V1 });\n  writeVarUint({ out: trailer, value: attributions.length });\n  const utf8 = new TextEncoder();\n  for (const { k, v } of attributions) {\n    for (const text of [k, v]) {\n      const bytes = utf8.encode(text);\n      writeVarUint({ out: trailer, value: bytes.length });\n      for (const byte of bytes) trailer.push(byte);\n    }\n  }\n  const out = new Uint8Array(message.length + trailer.length);\n  out.set(message, 0);\n  out.set(trailer, message.length);\n  return out;\n}\n\n/** What {@link attributingWebSocket} needs of a socket: the `send` y-websocket writes frames with. */\nexport interface SendingSocket {\n  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;\n}\n\n/** One socket of a room, as the room's attributed writes Keryx has not acknowledged see it. */\nexport interface AttributedWritesSocket {\n  /** Keryx sent `frame` on the socket: what it carries, Keryx holds. */\n  received(frame: Uint8Array): void;\n  /** The socket sends `frame` (now, or once Keryx has sent what it holds; see the implementation). */\n  send(frame: Uint8Array): void;\n}\n\n/**\n * The room's attributed writes Keryx has not acknowledged yet, as its sockets see them\n * (`UnconfirmedUpdateAttributions` in `@athenaintel/keryx-http/unconfirmed-update-attributions`).\n */\nexport interface UnconfirmedAttributedWrites {\n  /**\n   * A socket opened, sending through `send`. `hears`: the socket hands it every frame Keryx sends\n   * (`received`), ahead of the transport.\n   */\n  connect(params: { send: (frame: Uint8Array) => void; hears: boolean }): AttributedWritesSocket;\n}\n\n/** The bytes of a binary frame a socket received, or `null` for one that is not (a string, a `Blob`). */\nfunction receivedBytes(data: unknown): Uint8Array | null {\n  if (data instanceof ArrayBuffer) return new Uint8Array(data);\n  if (ArrayBuffer.isView(data))\n    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n  return null;\n}\n\n/**\n * Hands `onFrame` every binary frame `socket` receives; whether it can. A listener added before\n * y-websocket sets `onmessage` runs ahead of it. A socket without `addEventListener` hands nothing.\n */\nfunction listenToFrames({\n  socket,\n  onFrame,\n}: {\n  socket: SendingSocket;\n  onFrame: (frame: Uint8Array) => void;\n}): boolean {\n  if (!('addEventListener' in socket) || typeof socket.addEventListener !== 'function') {\n    return false;\n  }\n  socket.addEventListener('message', (event: { data?: unknown }) => {\n    const frame = receivedBytes(event.data);\n    if (frame) onFrame(frame);\n  });\n  return true;\n}\n\n/**\n * `Base` with `send` appending the trailer of `attributionsFor()` to each sync update it sends.\n * With the room's `unconfirmed` attributed writes, each socket also tells them every frame Keryx\n * sends and sends its frames through them, so a sync step 2 goes out behind the kept writes it\n * carries. A `Proxy` keeps the constructor's statics and type, so it drops in as y-websocket's\n * `WebSocketPolyfill`.\n */\nexport function attributingWebSocket<TBase extends new (...args: never[]) => SendingSocket>({\n  Base,\n  attributionsFor,\n  unconfirmed,\n}: {\n  Base: TBase;\n  attributionsFor: () => readonly UpdateAttribution[] | undefined;\n  unconfirmed?: UnconfirmedAttributedWrites;\n}): TBase {\n  // No WebSocket where the provider is built (server render, a test without one): nothing to wrap,\n  // and the transport fails at connect as it always did.\n  if (typeof Base !== 'function') return Base;\n  return new Proxy(Base, {\n    construct(target, args) {\n      const socket: SendingSocket = Reflect.construct(target, args);\n      const send = socket.send.bind(socket);\n      let connection: AttributedWritesSocket | null = null;\n      if (unconfirmed) {\n        const hears = listenToFrames({ socket, onFrame: (frame) => connection?.received(frame) });\n        connection = unconfirmed.connect({ send, hears });\n      }\n      socket.send = (data) => {\n        if (!(data instanceof Uint8Array)) {\n          send(data);\n          return;\n        }\n        const attributions = attributionsFor();\n        const message = attributions\n          ? withUpdateAttributionsTrailer({ message: data, attributions })\n          : data;\n        if (connection) connection.send(message);\n        else send(message);\n      };\n      return socket;\n    },\n  });\n}\n"],"names":[],"mappings":"AAoCO,MAAM,iCAA+D;AAAA,EAC1E,EAAE,GAAG,UAAU,GAAG,aAAA;AACpB;AAGO,MAAM,iCAAiC;AAG9C,MAAM,eAAe;AACrB,MAAM,sBAAsB;AAQ5B,MAAM,aAAa,OAAO,IAAI,mDAAmD;AAOjF,SAAS,YAA2D;AAClE,QAAM,OAAO;AACb,SAAQ,wCAAqB,oBAAI,QAAA;AACnC;AAMA,MAAM,oBAAoB,OAAO,IAAI,yDAAyD;AAc9F,SAAS,mBAAqC;AAC5C,QAAM,OAAO;AACb,SAAQ,sDAA4B,EAAE,QAAQ,oBAAI,QAAA,GAAW,8BAAc,QAAA,GAAW,UAAU,oBAAI,UAAQ;AAC9G;AAQA,SAAS,qBAAqB,KAAuC;AACnE,QAAM,SAAS;AACf,SAAO,OAAO,OAAO,OAAO,cAAc,OAAO,OAAO,QAAQ;AAClE;AAOA,SAAS,sBAAsB,KAAa,cAAiE;AAC3G,MAAI,CAAC,qBAAqB,GAAG,EAAG,QAAO;AACvC,QAAM,QAAQ,iBAAA;AACd,MAAI,CAAC,MAAM,SAAS,IAAI,GAAG,GAAG;AAC5B,UAAM,SAAS,IAAI,GAAG;AACtB,QAAI,GAAG,2BAA2B,CAAC,gBAAgB,MAAM,SAAS,IAAI,KAAK,WAAW,CAAC;AACvF,QAAI,GAAG,wBAAwB,MAAM,MAAM,SAAS,OAAO,GAAG,CAAC;AAAA,EACjE;AACA,QAAM,OAAO,CAAC,gBAAwB,MAAM,OAAO,IAAI,aAAa,YAAY;AAChF,MAAI,GAAG,qBAAqB,IAAI;AAChC,SAAO,MAAM,IAAI,IAAI,qBAAqB,IAAI;AAChD;AAWO,SAAS,6BAAgC;AAAA,EAC9C;AAAA,EACA;AAAA,EACA;AACF,GAIM;AACJ,QAAM,SAAS,UAAA;AACf,QAAM,QAAQ,OAAO,IAAI,GAAG;AAC5B,SAAO,IAAI,KAAK,YAAY;AAC5B,QAAM,cAAc,sBAAsB,KAAK,YAAY;AAC3D,MAAI;AACF,WAAO,IAAA;AAAA,EACT,UAAA;AACE;AACA,QAAI,UAAU,OAAW,QAAO,OAAO,GAAG;AAAA,QACrC,QAAO,IAAI,KAAK,KAAK;AAAA,EAC5B;AACF;AAOO,SAAS,sBAAsB,KAAuD;AAC3F,QAAM,QAAQ,iBAAA;AACd,QAAM,WAAW,MAAM,SAAS,IAAI,GAAG;AACvC,UAAQ,aAAa,SAAY,SAAY,MAAM,OAAO,IAAI,QAAQ,MAAM,YAAY,IAAI,GAAG;AACjG;AAGO,SAAS,YAAY;AAAA,EAC1B;AAAA,EACA;AACF,GAG2C;AACzC,MAAI,QAAQ;AACZ,MAAI,aAAa;AACjB,WAAS,MAAM,OAAO,MAAM,MAAM,QAAQ,OAAO,GAAG;AAClD,UAAM,OAAO,MAAM,GAAG;AACtB,QAAI,SAAS,OAAW,QAAO;AAC/B,cAAU,OAAO,OAAQ;AACzB,QAAI,OAAO,IAAM,QAAO,EAAE,OAAO,MAAM,MAAM,EAAA;AAC7C,kBAAc;AACd,QAAI,aAAa,OAAO,iBAAkB,QAAO;AAAA,EACnD;AACA,SAAO;AACT;AAGO,SAAS,aAAa,EAAE,KAAK,SAAiD;AACnF,MAAI,OAAO;AACX,SAAO,OAAO,KAAM;AAClB,QAAI,KAAK,MAAQ,OAAO,GAAK;AAC7B,WAAO,KAAK,MAAM,OAAO,GAAI;AAAA,EAC/B;AACA,MAAI,KAAK,IAAI;AACf;AAGA,SAAS,iBAAiB,SAA8B;AACtD,QAAM,OAAO,YAAY,EAAE,OAAO,SAAS,OAAO,GAAG;AACrD,OAAI,6BAAM,WAAU,aAAc,QAAO;AACzC,QAAM,WAAW,YAAY,EAAE,OAAO,SAAS,OAAO,KAAK,MAAM;AACjE,OAAI,qCAAU,WAAU,oBAAqB,QAAO;AACpD,QAAM,SAAS,YAAY,EAAE,OAAO,SAAS,OAAO,SAAS,MAAM;AACnE,SAAO,WAAW,QAAQ,OAAO,OAAO,OAAO,UAAU,QAAQ;AACnE;AAOO,SAAS,8BAA8B;AAAA,EAC5C;AAAA,EACA;AACF,GAGe;AACb,MAAI,aAAa,WAAW,KAAK,CAAC,iBAAiB,OAAO,EAAG,QAAO;AACpE,QAAM,UAAoB,CAAA;AAC1B,eAAa,EAAE,KAAK,SAAS,OAAO,gCAAgC;AACpE,eAAa,EAAE,KAAK,SAAS,OAAO,aAAa,QAAQ;AACzD,QAAM,OAAO,IAAI,YAAA;AACjB,aAAW,EAAE,GAAG,EAAA,KAAO,cAAc;AACnC,eAAW,QAAQ,CAAC,GAAG,CAAC,GAAG;AACzB,YAAM,QAAQ,KAAK,OAAO,IAAI;AAC9B,mBAAa,EAAE,KAAK,SAAS,OAAO,MAAM,QAAQ;AAClD,iBAAW,QAAQ,MAAO,SAAQ,KAAK,IAAI;AAAA,IAC7C;AAAA,EACF;AACA,QAAM,MAAM,IAAI,WAAW,QAAQ,SAAS,QAAQ,MAAM;AAC1D,MAAI,IAAI,SAAS,CAAC;AAClB,MAAI,IAAI,SAAS,QAAQ,MAAM;AAC/B,SAAO;AACT;AA4BA,SAAS,cAAc,MAAkC;AACvD,MAAI,gBAAgB,YAAa,QAAO,IAAI,WAAW,IAAI;AAC3D,MAAI,YAAY,OAAO,IAAI;AACzB,WAAO,IAAI,WAAW,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU;AACrE,SAAO;AACT;AAMA,SAAS,eAAe;AAAA,EACtB;AAAA,EACA;AACF,GAGY;AACV,MAAI,EAAE,sBAAsB,WAAW,OAAO,OAAO,qBAAqB,YAAY;AACpF,WAAO;AAAA,EACT;AACA,SAAO,iBAAiB,WAAW,CAAC,UAA8B;AAChE,UAAM,QAAQ,cAAc,MAAM,IAAI;AACtC,QAAI,eAAe,KAAK;AAAA,EAC1B,CAAC;AACD,SAAO;AACT;AASO,SAAS,qBAA4E;AAAA,EAC1F;AAAA,EACA;AAAA,EACA;AACF,GAIU;AAGR,MAAI,OAAO,SAAS,WAAY,QAAO;AACvC,SAAO,IAAI,MAAM,MAAM;AAAA,IACrB,UAAU,QAAQ,MAAM;AACtB,YAAM,SAAwB,QAAQ,UAAU,QAAQ,IAAI;AAC5D,YAAM,OAAO,OAAO,KAAK,KAAK,MAAM;AACpC,UAAI,aAA4C;AAChD,UAAI,aAAa;AACf,cAAM,QAAQ,eAAe,EAAE,QAAQ,SAAS,CAAC,UAAU,yCAAY,SAAS,QAAQ;AACxF,qBAAa,YAAY,QAAQ,EAAE,MAAM,OAAO;AAAA,MAClD;AACA,aAAO,OAAO,CAAC,SAAS;AACtB,YAAI,EAAE,gBAAgB,aAAa;AACjC,eAAK,IAAI;AACT;AAAA,QACF;AACA,cAAM,eAAe,gBAAA;AACrB,cAAM,UAAU,eACZ,8BAA8B,EAAE,SAAS,MAAM,aAAA,CAAc,IAC7D;AACJ,YAAI,WAAY,YAAW,KAAK,OAAO;AAAA,kBAC7B,OAAO;AAAA,MACnB;AACA,aAAO;AAAA,IACT;AAAA,EAAA,CACD;AACH;"}

package/dist/offline/chat-outbox.cjs

@@ -1,57 +1,293 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const chatOutboxStore = require("../agent-runtime/src/chat-outbox-store.cjs");
+const chatOutboxStorage = require("../agent-runtime/src/chat-outbox-storage.cjs");
 const chatOutbox = require("../agent-runtime/src/chat-outbox.cjs");
-const ownerStores = /* @__PURE__ */ new Map();
+const chatOutboxLegacy = require("../agent-runtime/src/chat-outbox-legacy.cjs");
+const quotaSafeLocalStorageSession = require("../agent-runtime/src/quota-safe-local-storage-session.cjs");
+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 chatOutboxStorage.listChatOutboxes({
+    backend: chatOutboxStorage.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: chatOutboxStorage.chatSessionMemoryBackend(),
+    namespace: chatOutboxStorage.chatSessionMemoryNamespace(ownerId),
+    principal: quotaSafeLocalStorageSession.sessionPrincipal(ownerId)
+  };
+}
+function sealedSource(owner, namespace) {
+  return {
+    backend: chatOutboxStorage.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 = quotaSafeLocalStorageSession.sessionPrincipal(ownerId);
+    const sealedAvailable = canKeepSealedSessions();
+    const namespace = sealedAvailable ? chatOutboxStorage.chatSessionNamespace({ environment: SDK_CHAT_SESSION_ENVIRONMENT, ownerId }).then(async (resolved) => {
+      await chatOutboxStorage.adoptUnscopedChatSessions({
+        backend: chatOutboxStorage.chatSessionBackend(),
+        namespace: resolved,
+        principal
+      }).catch(() => 0);
+      return resolved;
+    }).catch(() => null) : Promise.resolve(null);
+    const keys = sessionKeys(current);
+    const codec = chatOutboxStorage.createSealedSessionCodec({ getKey: keys.getKey, scope: ownerId });
+    const drainCodec = chatOutboxStorage.createSealedSessionCodec({
+      getKey: (purpose) => keys.getKey(purpose === "write" ? "read" : purpose),
+      scope: ownerId
+    });
+    const legacy = chatOutboxLegacy.createLegacyChatOutboxReader({
+      ownerId,
+      getKey: () => current.current.getKey("read")
+    });
+    const directory = mergedDirectory({
+      memory: chatOutboxStorage.createChatOutboxDirectory(memorySource(ownerId)),
+      sealed: namespace.then(
+        (resolved) => resolved === null ? null : chatOutboxStorage.createChatOutboxDirectory(sealedSource({ codec, legacy, principal }, resolved))
+      )
+    });
     owner = {
+      ownerId,
+      principal,
+      codec,
+      drainCodec,
+      legacy,
+      namespace,
+      memoryScope: ownerId,
       host: current,
-      store: chatOutboxStore.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 ? chatOutboxStorage.countChatOutboxMessages(sealed) : 0,
+    chatOutboxStorage.countChatOutboxMessages(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 < chatOutbox.CHAT_OUTBOX_CLAIM_LEASE_MS ? "sending" : now - entry.queuedAt > chatOutbox.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 > chatOutbox.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 ? chatOutboxStorage.listChatOutboxes(sealed) : EMPTY_LISTING,
+    chatOutboxStorage.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 chatOutboxStorage.clearChatOutboxes(sealed);
+  else await owner.legacy.clear();
+  await chatOutboxStorage.clearChatOutboxes(memorySource(ownerId));
+  owner.directory.refresh();
 }
-function clearUnopenableChatOutbox(ownerId) {
-  return chatOutboxStore.createIndexedDbChatOutboxStore({ ownerId, getKey: async () => null }).clear();
+async function clearUnopenableChatOutbox(ownerId) {
+  const owner = ownerStorage(ownerId);
+  owner.forgetKeys();
+  const sealed = await sealedSourceOf(owner);
+  if (sealed) await chatOutboxStorage.clearChatOutboxes(sealed);
+  else await owner.legacy.clear();
+  owner.directory.refresh();
 }
-exports.chatOutboxStoreFor = chatOutboxStoreFor;
+exports.chatOutboxStorageFor = chatOutboxStorageFor;
 exports.clearChatOutbox = clearChatOutbox;
 exports.clearUnopenableChatOutbox = clearUnopenableChatOutbox;
 exports.countChatOutboxMessages = countChatOutboxMessages;
 exports.listChatOutboxMessages = listChatOutboxMessages;
+exports.resolveChatSessionKeeping = resolveChatSessionKeeping;
 exports.subscribeChatOutbox = subscribeChatOutbox;
 //# sourceMappingURL=chat-outbox.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"chat-outbox.cjs","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":["createIndexedDbChatOutboxStore","CHAT_OUTBOX_CLAIM_LEASE_MS","CHAT_OUTBOX_ASK_AFTER_MS"],"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,OAAOA,gBAAAA,+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,KAAKC,WAAAA,6BACxB,YACA,MAAM,MAAM,WAAWC,WAAAA,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,SAAOF,gBAAAA,+BAA+B,EAAE,SAAS,QAAQ,YAAY,KAAA,CAAM,EAAE,MAAA;AAC/E;;;;;;;"}
+{"version":3,"file":"chat-outbox.cjs","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":["listChatOutboxes","chatSessionBackend","chatSessionMemoryBackend","chatSessionMemoryNamespace","sessionPrincipal","directory","chatSessionNamespace","adoptUnscopedChatSessions","createSealedSessionCodec","createLegacyChatOutboxReader","createChatOutboxDirectory","countChatOutboxSource","CHAT_OUTBOX_ASK_AFTER_MS","clearChatOutboxes"],"mappings":"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"}