@athenaintel/react 0.41.2 → 0.42.1

package/dist/agent-runtime/src/chat-outbox-signals.js

@@ -0,0 +1,63 @@
+const host = globalThis;
+function subscribeTo(targets, events, listener) {
+  const bound = targets.filter((target) => target !== void 0);
+  for (const target of bound) for (const event of events) target.addEventListener(event, listener);
+  return () => {
+    for (const target of bound) for (const event of events) target.removeEventListener(event, listener);
+  };
+}
+function browserOnlineSignal() {
+  return {
+    get: () => {
+      var _a;
+      return ((_a = host.navigator) == null ? void 0 : _a.onLine) !== false;
+    },
+    subscribe: (listener) => subscribeTo([typeof host.addEventListener === "function" ? host : void 0], ["online", "offline"], listener)
+  };
+}
+function documentVisibleSignal() {
+  return {
+    get: () => {
+      var _a;
+      return ((_a = host.document) == null ? void 0 : _a.visibilityState) !== "hidden";
+    },
+    subscribe: (listener) => subscribeTo([host.document], ["visibilitychange"], listener)
+  };
+}
+function windowInFrontSignal() {
+  const windowTarget = typeof host.addEventListener === "function" ? host : void 0;
+  return {
+    get: () => {
+      const document = host.document;
+      if (!document) return true;
+      if (document.visibilityState === "hidden") return false;
+      return typeof document.hasFocus === "function" ? document.hasFocus() : true;
+    },
+    subscribe: (listener) => {
+      const stopDocument = subscribeTo([host.document], ["visibilitychange"], listener);
+      const stopWindow = subscribeTo([windowTarget], ["focus", "blur"], listener);
+      return () => {
+        stopDocument();
+        stopWindow();
+      };
+    }
+  };
+}
+function allChatOutboxSignals(...signals) {
+  return {
+    get: () => signals.every((signal) => signal.get()),
+    subscribe: (listener) => {
+      const stops = signals.map((signal) => signal.subscribe(listener));
+      return () => {
+        for (const stop of stops) stop();
+      };
+    }
+  };
+}
+export {
+  allChatOutboxSignals,
+  browserOnlineSignal,
+  documentVisibleSignal,
+  windowInFrontSignal
+};
+//# sourceMappingURL=chat-outbox-signals.js.map

package/dist/agent-runtime/src/chat-outbox-signals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-outbox-signals.js","sources":["../../../../agent-runtime/src/chat-outbox-signals.ts"],"sourcesContent":["import type { ChatOutboxSignal } from \"./chat-outbox\";\n\n/**\n * Default signals for the chat outbox on browser hosts. A host with its own reachability model\n * (Olympus's `athena-reachability`, the mobile app's `connectivity`) passes that instead: \"online\"\n * means the device is online AND agora answers, which the browser alone cannot tell.\n *\n * This package compiles without the DOM lib, so the browser globals are described structurally.\n */\n\ntype EventTargetLike = {\n  addEventListener(type: string, listener: () => void): void;\n  removeEventListener(type: string, listener: () => void): void;\n};\n\ntype BrowserHost = EventTargetLike & {\n  navigator?: { onLine?: boolean };\n  document?: EventTargetLike & { visibilityState?: string; hasFocus?: () => boolean };\n};\n\nconst host = globalThis as unknown as Partial<BrowserHost>;\n\nfunction subscribeTo(\n  targets: readonly (EventTargetLike | undefined)[],\n  events: readonly string[],\n  listener: () => void,\n): () => void {\n  const bound = targets.filter((target): target is EventTargetLike => target !== undefined);\n  for (const target of bound) for (const event of events) target.addEventListener(event, listener);\n  return () => {\n    for (const target of bound) for (const event of events) target.removeEventListener(event, listener);\n  };\n}\n\n/** The browser's own word on the network (`navigator.onLine`); true where there is no browser. */\nexport function browserOnlineSignal(): ChatOutboxSignal {\n  return {\n    get: () => host.navigator?.onLine !== false,\n    subscribe: (listener) =>\n      subscribeTo([typeof host.addEventListener === \"function\" ? (host as EventTargetLike) : undefined], [\"online\", \"offline\"], listener),\n  };\n}\n\n/** A tab in front: the document is visible (a hidden tab never sends). */\nexport function documentVisibleSignal(): ChatOutboxSignal {\n  return {\n    get: () => host.document?.visibilityState !== \"hidden\",\n    subscribe: (listener) => subscribeTo([host.document], [\"visibilitychange\"], listener),\n  };\n}\n\n/**\n * A desktop window in front: visible and focused. An unfocused or minimized window waits until the\n * person comes back to it.\n */\nexport function windowInFrontSignal(): ChatOutboxSignal {\n  const windowTarget = typeof host.addEventListener === \"function\" ? (host as EventTargetLike) : undefined;\n  return {\n    get: () => {\n      const document = host.document;\n      if (!document) return true;\n      if (document.visibilityState === \"hidden\") return false;\n      return typeof document.hasFocus === \"function\" ? document.hasFocus() : true;\n    },\n    subscribe: (listener) => {\n      const stopDocument = subscribeTo([host.document], [\"visibilitychange\"], listener);\n      const stopWindow = subscribeTo([windowTarget], [\"focus\", \"blur\"], listener);\n      return () => {\n        stopDocument();\n        stopWindow();\n      };\n    },\n  };\n}\n\n/** Both signals at once (e.g. a host's reachability AND the browser being online). */\nexport function allChatOutboxSignals(...signals: readonly ChatOutboxSignal[]): ChatOutboxSignal {\n  return {\n    get: () => signals.every((signal) => signal.get()),\n    subscribe: (listener) => {\n      const stops = signals.map((signal) => signal.subscribe(listener));\n      return () => {\n        for (const stop of stops) stop();\n      };\n    },\n  };\n}\n"],"names":[],"mappings":"AAoBA,MAAM,OAAO;AAEb,SAAS,YACP,SACA,QACA,UACY;AACZ,QAAM,QAAQ,QAAQ,OAAO,CAAC,WAAsC,WAAW,MAAS;AACxF,aAAW,UAAU,MAAO,YAAW,SAAS,OAAQ,QAAO,iBAAiB,OAAO,QAAQ;AAC/F,SAAO,MAAM;AACX,eAAW,UAAU,MAAO,YAAW,SAAS,OAAQ,QAAO,oBAAoB,OAAO,QAAQ;AAAA,EACpG;AACF;AAGO,SAAS,sBAAwC;AACtD,SAAO;AAAA,IACL,KAAK,MAAA;AAjBT;AAiBe,yBAAK,cAAL,mBAAgB,YAAW;AAAA;AAAA,IACtC,WAAW,CAAC,aACV,YAAY,CAAC,OAAO,KAAK,qBAAqB,aAAc,OAA2B,MAAS,GAAG,CAAC,UAAU,SAAS,GAAG,QAAQ;AAAA,EAAA;AAExI;AAGO,SAAS,wBAA0C;AACxD,SAAO;AAAA,IACL,KAAK,MAAA;AA1BT;AA0Be,yBAAK,aAAL,mBAAe,qBAAoB;AAAA;AAAA,IAC9C,WAAW,CAAC,aAAa,YAAY,CAAC,KAAK,QAAQ,GAAG,CAAC,kBAAkB,GAAG,QAAQ;AAAA,EAAA;AAExF;AAMO,SAAS,sBAAwC;AACtD,QAAM,eAAe,OAAO,KAAK,qBAAqB,aAAc,OAA2B;AAC/F,SAAO;AAAA,IACL,KAAK,MAAM;AACT,YAAM,WAAW,KAAK;AACtB,UAAI,CAAC,SAAU,QAAO;AACtB,UAAI,SAAS,oBAAoB,SAAU,QAAO;AAClD,aAAO,OAAO,SAAS,aAAa,aAAa,SAAS,aAAa;AAAA,IACzE;AAAA,IACA,WAAW,CAAC,aAAa;AACvB,YAAM,eAAe,YAAY,CAAC,KAAK,QAAQ,GAAG,CAAC,kBAAkB,GAAG,QAAQ;AAChF,YAAM,aAAa,YAAY,CAAC,YAAY,GAAG,CAAC,SAAS,MAAM,GAAG,QAAQ;AAC1E,aAAO,MAAM;AACX,qBAAA;AACA,mBAAA;AAAA,MACF;AAAA,IACF;AAAA,EAAA;AAEJ;AAGO,SAAS,wBAAwB,SAAwD;AAC9F,SAAO;AAAA,IACL,KAAK,MAAM,QAAQ,MAAM,CAAC,WAAW,OAAO,KAAK;AAAA,IACjD,WAAW,CAAC,aAAa;AACvB,YAAM,QAAQ,QAAQ,IAAI,CAAC,WAAW,OAAO,UAAU,QAAQ,CAAC;AAChE,aAAO,MAAM;AACX,mBAAW,QAAQ,MAAO,MAAA;AAAA,MAC5B;AAAA,IACF;AAAA,EAAA;AAEJ;"}

package/dist/agent-runtime/src/chat-outbox-store.cjs

@@ -0,0 +1,509 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const sealedIdb = require("./sealed-idb.cjs");
+const CHAT_OUTBOX_DATABASE = "athena-chat-outbox:v1";
+const CHAT_OUTBOX_FORMAT = 1;
+const DATABASE_VERSION = 1;
+const ENTRIES_STORE = "entries";
+const BY_OWNER = "byOwner";
+const BY_OWNER_THREAD = "byOwnerThread";
+function upgradeOutboxDatabase(db) {
+  if (!db.objectStoreNames.contains(ENTRIES_STORE)) {
+    const store = db.createObjectStore(ENTRIES_STORE, { keyPath: "key" });
+    store.createIndex(BY_OWNER, "owner", { unique: false });
+    store.createIndex(BY_OWNER_THREAD, ["owner", "thread"], { unique: false });
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isOwnFormat(record) {
+  if (!isRecord(record)) return true;
+  const format = record.format;
+  return typeof format !== "number" || format <= CHAT_OUTBOX_FORMAT;
+}
+function readChatOutboxClaim(value) {
+  if (!isRecord(value) || typeof value.by !== "string" || typeof value.at !== "number") return void 0;
+  return { by: value.by, at: value.at };
+}
+const FAILURE_REASONS = /* @__PURE__ */ new Set([
+  "refused",
+  "error",
+  "prepare",
+  "attachment"
+]);
+function readChatOutboxFailure(value) {
+  if (!isRecord(value) || typeof value.at !== "number") return void 0;
+  const reason = typeof value.reason === "string" && FAILURE_REASONS.has(value.reason) ? value.reason : "error";
+  return { reason, at: value.at };
+}
+const readClaim = readChatOutboxClaim;
+function readFiles(value) {
+  if (!Array.isArray(value)) return void 0;
+  const files = [];
+  for (const file of value) {
+    if (!isRecord(file) || typeof file.url !== "string" || typeof file.mediaType !== "string") continue;
+    files.push({
+      url: file.url,
+      mediaType: file.mediaType,
+      ...typeof file.filename === "string" && { filename: file.filename }
+    });
+  }
+  return files.length > 0 ? files : void 0;
+}
+function readAttachments(value) {
+  if (!Array.isArray(value)) return void 0;
+  const attachments = [];
+  for (const attachment of value) {
+    if (!isRecord(attachment) || typeof attachment.assetId !== "string" || attachment.assetId.length === 0) {
+      continue;
+    }
+    attachments.push({
+      assetId: attachment.assetId,
+      title: typeof attachment.title === "string" ? attachment.title : "",
+      ...typeof attachment.mediaType === "string" && { mediaType: attachment.mediaType }
+    });
+  }
+  return attachments.length > 0 ? attachments : void 0;
+}
+function parseChatOutboxEntry(value) {
+  if (!isRecord(value)) return null;
+  const { id, threadId, text, queuedAt } = value;
+  if (typeof id !== "string" || typeof threadId !== "string" || typeof text !== "string") return null;
+  if (typeof queuedAt !== "number" || !Number.isFinite(queuedAt)) return null;
+  const files = readFiles(value.files);
+  const attachments = readAttachments(value.attachments);
+  return {
+    id,
+    threadId,
+    text,
+    queuedAt,
+    newChat: value.newChat === true,
+    ...typeof value.composerMarkdown === "string" && { composerMarkdown: value.composerMarkdown },
+    ...typeof value.composerHtml === "string" && { composerHtml: value.composerHtml },
+    ...isRecord(value.metadata) && { metadata: value.metadata },
+    ...files && { files },
+    ...attachments && { attachments }
+  };
+}
+function byQueuedAt(a, b) {
+  return a.entry.queuedAt - b.entry.queuedAt;
+}
+function createChangeBus(channelName) {
+  const listeners = /* @__PURE__ */ new Set();
+  const ChannelCtor = globalThis.BroadcastChannel;
+  let channel = null;
+  const emit = () => {
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  };
+  return {
+    notify() {
+      emit();
+      try {
+        channel == null ? void 0 : channel.postMessage("changed");
+      } catch {
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      if (!channel && ChannelCtor) {
+        try {
+          channel = new ChannelCtor(channelName);
+          channel.onmessage = emit;
+        } catch {
+          channel = null;
+        }
+      }
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0 && channel) {
+          channel.close();
+          channel = null;
+        }
+      };
+    }
+  };
+}
+function createIndexedDbChatOutboxStore(options) {
+  return withChatOutboxMemoryFallback(createSealedIndexedDbChatOutboxStore(options));
+}
+function createSealedIndexedDbChatOutboxStore({
+  ownerId,
+  getKey,
+  factory = sealedIdb.idbGlobals.indexedDB,
+  databaseName = CHAT_OUTBOX_DATABASE
+}) {
+  const database = sealedIdb.lazySealedDatabase({
+    factory,
+    name: databaseName,
+    version: DATABASE_VERSION,
+    upgrade: upgradeOutboxDatabase
+  });
+  const bus = createChangeBus(`${databaseName}:changes`);
+  const keyOf = async (purpose) => {
+    try {
+      return await getKey(ownerId, purpose);
+    } catch {
+      return null;
+    }
+  };
+  const ownerHash = () => sealedIdb.sha256Hex(ownerId);
+  const threadHash = (threadId) => sealedIdb.sha256Hex(`${ownerId}|${threadId}`);
+  const recordKey = (threadId, id) => sealedIdb.sha256Hex(`${ownerId}|${threadId}|${id}`);
+  const aadOf = (owner, thread, key) => `athena-chat-outbox|${CHAT_OUTBOX_FORMAT}|${owner}|${thread}|${key}`;
+  let queue = Promise.resolve();
+  const enqueue = (task) => {
+    const run = queue.then(task, task);
+    queue = run.catch(() => void 0);
+    return run;
+  };
+  const openRecords = async (records) => {
+    if (records.length === 0) return [];
+    const cryptoKey = await keyOf("read");
+    if (!cryptoKey) return [];
+    const opened = [];
+    for (const record of records) {
+      if (!record || record.format > CHAT_OUTBOX_FORMAT) continue;
+      try {
+        const value = await sealedIdb.openJson({
+          key: cryptoKey,
+          sealed: record.sealed,
+          aad: aadOf(record.owner, record.thread, record.key)
+        });
+        const entry = parseChatOutboxEntry(value);
+        if (!entry) continue;
+        const claim = readClaim(record.claim);
+        const failure = readChatOutboxFailure(record.failure);
+        opened.push({ entry, ...claim && { claim }, ...failure && { failure } });
+      } catch {
+      }
+    }
+    return opened.sort(byQueuedAt);
+  };
+  return {
+    async list(threadId) {
+      try {
+        const db = await database();
+        if (!db) return [];
+        const owner = await ownerHash();
+        const thread = await threadHash(threadId);
+        const records = await sealedIdb.requestToPromise(
+          db.transaction(ENTRIES_STORE, "readonly").objectStore(ENTRIES_STORE).index(BY_OWNER_THREAD).getAll([owner, thread])
+        );
+        return await openRecords(records);
+      } catch {
+        return [];
+      }
+    },
+    async listAll() {
+      try {
+        const db = await database();
+        if (!db) return [];
+        const owner = await ownerHash();
+        const records = await sealedIdb.requestToPromise(
+          db.transaction(ENTRIES_STORE, "readonly").objectStore(ENTRIES_STORE).index(BY_OWNER).getAll(owner)
+        );
+        return await openRecords(records);
+      } catch {
+        return [];
+      }
+    },
+    async count() {
+      const db = await database();
+      if (!db) return 0;
+      const owner = await ownerHash();
+      const keys = await sealedIdb.requestToPromise(
+        db.transaction(ENTRIES_STORE, "readonly").objectStore(ENTRIES_STORE).index(BY_OWNER).getAllKeys(owner)
+      );
+      return keys.length;
+    },
+    put(entry) {
+      return enqueue(async () => {
+        try {
+          const db = await database();
+          if (!db) return false;
+          const cryptoKey = await keyOf("write");
+          if (!cryptoKey) return false;
+          const owner = await ownerHash();
+          const thread = await threadHash(entry.threadId);
+          const key = await recordKey(entry.threadId, entry.id);
+          const sealed = await sealedIdb.sealJson({ key: cryptoKey, value: entry, aad: aadOf(owner, thread, key) });
+          const tx = db.transaction(ENTRIES_STORE, "readwrite");
+          const store = tx.objectStore(ENTRIES_STORE);
+          const existing = await sealedIdb.requestToPromise(store.get(key));
+          let kept = true;
+          if (isOwnFormat(existing)) {
+            store.put({
+              key,
+              owner,
+              thread,
+              at: entry.queuedAt,
+              format: CHAT_OUTBOX_FORMAT,
+              sealed
+            });
+          } else {
+            kept = false;
+          }
+          await sealedIdb.transactionDone(tx);
+          bus.notify();
+          return kept;
+        } catch {
+          return false;
+        }
+      });
+    },
+    remove(threadId, id) {
+      return enqueue(async () => {
+        const db = await database();
+        if (!db) return;
+        const key = await recordKey(threadId, id);
+        const tx = db.transaction(ENTRIES_STORE, "readwrite");
+        const store = tx.objectStore(ENTRIES_STORE);
+        if (isOwnFormat(await sealedIdb.requestToPromise(store.get(key)))) store.delete(key);
+        await sealedIdb.transactionDone(tx);
+        bus.notify();
+      });
+    },
+    claim({ threadId, id, claimant, now, leaseMs }) {
+      return enqueue(async () => {
+        const db = await database();
+        if (!db) return "claimed";
+        const key = await recordKey(threadId, id);
+        const tx = db.transaction(ENTRIES_STORE, "readwrite");
+        const store = tx.objectStore(ENTRIES_STORE);
+        const existing = await sealedIdb.requestToPromise(store.get(key));
+        let result;
+        if (!existing) {
+          result = "gone";
+        } else {
+          const claim = readClaim(existing.claim);
+          if (claim && claim.by !== claimant && now - claim.at < leaseMs) {
+            result = "taken";
+          } else {
+            store.put({ ...existing, claim: { by: claimant, at: now } });
+            result = "claimed";
+          }
+        }
+        await sealedIdb.transactionDone(tx);
+        if (result === "claimed") bus.notify();
+        return result;
+      });
+    },
+    release({ threadId, id, claimant }) {
+      return enqueue(async () => {
+        var _a;
+        const db = await database();
+        if (!db) return;
+        const key = await recordKey(threadId, id);
+        const tx = db.transaction(ENTRIES_STORE, "readwrite");
+        const store = tx.objectStore(ENTRIES_STORE);
+        const existing = await sealedIdb.requestToPromise(store.get(key));
+        if (existing && ((_a = readClaim(existing.claim)) == null ? void 0 : _a.by) === claimant) {
+          const { claim: _claim, ...rest } = existing;
+          store.put(rest);
+        }
+        await sealedIdb.transactionDone(tx);
+        bus.notify();
+      });
+    },
+    markFailed({ threadId, id, claimant, failure }) {
+      return enqueue(async () => {
+        var _a;
+        const db = await database();
+        if (!db) return;
+        const key = await recordKey(threadId, id);
+        const tx = db.transaction(ENTRIES_STORE, "readwrite");
+        const store = tx.objectStore(ENTRIES_STORE);
+        const existing = await sealedIdb.requestToPromise(store.get(key));
+        if (existing && isOwnFormat(existing)) {
+          const { claim, ...rest } = existing;
+          const keepClaim = claim !== void 0 && ((_a = readClaim(claim)) == null ? void 0 : _a.by) !== claimant;
+          store.put({
+            ...rest,
+            ...keepClaim && { claim },
+            failure: { reason: failure.reason, at: failure.at }
+          });
+        }
+        await sealedIdb.transactionDone(tx);
+        bus.notify();
+      });
+    },
+    clearFailure({ threadId, id }) {
+      return enqueue(async () => {
+        const db = await database();
+        if (!db) return;
+        const key = await recordKey(threadId, id);
+        const tx = db.transaction(ENTRIES_STORE, "readwrite");
+        const store = tx.objectStore(ENTRIES_STORE);
+        const existing = await sealedIdb.requestToPromise(store.get(key));
+        if ((existing == null ? void 0 : existing.failure) !== void 0 && isOwnFormat(existing)) {
+          const { failure: _failure, ...rest } = existing;
+          store.put(rest);
+        }
+        await sealedIdb.transactionDone(tx);
+        bus.notify();
+      });
+    },
+    clear() {
+      return enqueue(async () => {
+        const db = await database();
+        if (!db) return;
+        const owner = await ownerHash();
+        const tx = db.transaction(ENTRIES_STORE, "readwrite");
+        const store = tx.objectStore(ENTRIES_STORE);
+        const keys = await sealedIdb.requestToPromise(store.index(BY_OWNER).getAllKeys(owner));
+        for (const key of keys) store.delete(key);
+        await sealedIdb.transactionDone(tx);
+        bus.notify();
+      });
+    },
+    subscribe: (listener) => bus.subscribe(listener)
+  };
+}
+function createRecordMap() {
+  const records = /* @__PURE__ */ new Map();
+  const keyOf = (threadId, id) => `${threadId}\0${id}`;
+  return {
+    records,
+    keyOf,
+    has: (threadId, id) => records.has(keyOf(threadId, id)),
+    sorted: (filter) => [...records.values()].filter(filter).map((record) => ({ ...record })).sort(byQueuedAt),
+    claim({ threadId, id, claimant, now, leaseMs }) {
+      const key = keyOf(threadId, id);
+      const record = records.get(key);
+      if (!record) return "gone";
+      if (record.claim && record.claim.by !== claimant && now - record.claim.at < leaseMs) return "taken";
+      records.set(key, { ...record, claim: { by: claimant, at: now } });
+      return "claimed";
+    },
+    release({ threadId, id, claimant }) {
+      var _a;
+      const key = keyOf(threadId, id);
+      const record = records.get(key);
+      if (((_a = record == null ? void 0 : record.claim) == null ? void 0 : _a.by) !== claimant) return;
+      const { claim: _claim, ...rest } = record;
+      records.set(key, rest);
+    },
+    markFailed({ threadId, id, claimant, failure }) {
+      const key = keyOf(threadId, id);
+      const record = records.get(key);
+      if (!record) return;
+      const { claim, ...rest } = record;
+      records.set(key, { ...rest, ...claim && claim.by !== claimant && { claim }, failure: { ...failure } });
+    },
+    clearFailure({ threadId, id }) {
+      const key = keyOf(threadId, id);
+      const record = records.get(key);
+      if (!(record == null ? void 0 : record.failure)) return;
+      const { failure: _failure, ...rest } = record;
+      records.set(key, rest);
+    }
+  };
+}
+function createListenerSet() {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    notify() {
+      for (const listener of listeners) {
+        try {
+          listener();
+        } catch {
+        }
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function withChatOutboxMemoryFallback(inner) {
+  const memory = createRecordMap();
+  const local = createListenerSet();
+  const remembered = (filter) => memory.sorted(filter).map((record) => ({ ...record, memoryOnly: true }));
+  const merged = (kept, extra) => {
+    const ids = new Set(kept.map((record) => record.entry.id));
+    return [...kept, ...extra.filter((record) => !ids.has(record.entry.id))].sort(byQueuedAt);
+  };
+  return {
+    async list(threadId) {
+      const kept = await inner.list(threadId).catch(() => []);
+      return merged(kept, remembered((record) => record.entry.threadId === threadId));
+    },
+    async listAll() {
+      const kept = await inner.listAll().catch(() => []);
+      return merged(kept, remembered(() => true));
+    },
+    async count() {
+      return await inner.count() + memory.records.size;
+    },
+    async put(entry) {
+      let kept = false;
+      try {
+        kept = await inner.put(entry);
+      } catch {
+        kept = false;
+      }
+      if (kept) return true;
+      memory.records.set(memory.keyOf(entry.threadId, entry.id), { entry });
+      local.notify();
+      return false;
+    },
+    async remove(threadId, id) {
+      if (memory.records.delete(memory.keyOf(threadId, id))) {
+        local.notify();
+        return;
+      }
+      await inner.remove(threadId, id);
+    },
+    async claim(input) {
+      if (!memory.has(input.threadId, input.id)) return inner.claim(input);
+      const result = memory.claim(input);
+      local.notify();
+      return result;
+    },
+    async release(input) {
+      if (!memory.has(input.threadId, input.id)) return inner.release(input);
+      memory.release(input);
+      local.notify();
+    },
+    async markFailed(input) {
+      if (!memory.has(input.threadId, input.id)) return inner.markFailed(input);
+      memory.markFailed(input);
+      local.notify();
+    },
+    async clearFailure(input) {
+      if (!memory.has(input.threadId, input.id)) return inner.clearFailure(input);
+      memory.clearFailure(input);
+      local.notify();
+    },
+    async clear() {
+      memory.records.clear();
+      local.notify();
+      await inner.clear();
+    },
+    subscribe(listener) {
+      const stopLocal = local.subscribe(listener);
+      const stopInner = inner.subscribe(listener);
+      return () => {
+        stopLocal();
+        stopInner();
+      };
+    }
+  };
+}
+exports.CHAT_OUTBOX_DATABASE = CHAT_OUTBOX_DATABASE;
+exports.CHAT_OUTBOX_FORMAT = CHAT_OUTBOX_FORMAT;
+exports.createIndexedDbChatOutboxStore = createIndexedDbChatOutboxStore;
+exports.parseChatOutboxEntry = parseChatOutboxEntry;
+exports.readChatOutboxClaim = readChatOutboxClaim;
+exports.readChatOutboxFailure = readChatOutboxFailure;
+exports.withChatOutboxMemoryFallback = withChatOutboxMemoryFallback;
+//# sourceMappingURL=chat-outbox-store.cjs.map