@graffiti-garden/implementation-decentralized 0.1.3 → 0.1.5

package/dist/cjs/1-services/4-inboxes.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,47 +15,44 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var inboxes_exports = {};
 __export(inboxes_exports, {
   Inboxes: () => Inboxes,
-  LABELED_MESSAGE_ID_KEY: () => LABELED_MESSAGE_ID_KEY,
-  LABELED_MESSAGE_LABEL_KEY: () => LABELED_MESSAGE_LABEL_KEY,
-  LABELED_MESSAGE_MESSAGE_KEY: () => LABELED_MESSAGE_MESSAGE_KEY,
-  LabeledMessageBaseSchema: () => LabeledMessageBaseSchema,
-  MESSAGE_METADATA_KEY: () => MESSAGE_METADATA_KEY,
-  MESSAGE_OBJECT_KEY: () => MESSAGE_OBJECT_KEY,
-  MESSAGE_TAGS_KEY: () => MESSAGE_TAGS_KEY,
-  MessageBaseSchema: () => MessageBaseSchema,
-  TagsSchema: () => TagsSchema,
-  Uint8ArraySchema: () => Uint8ArraySchema
+  LABELED_MESSAGE_ID_KEY: () => import_messages2.LABELED_MESSAGE_ID_KEY,
+  LABELED_MESSAGE_LABEL_KEY: () => import_messages2.LABELED_MESSAGE_LABEL_KEY,
+  LABELED_MESSAGE_MESSAGE_KEY: () => import_messages2.LABELED_MESSAGE_MESSAGE_KEY,
+  LabeledMessageBaseSchema: () => import_messages2.LabeledMessageBaseSchema,
+  MESSAGE_METADATA_KEY: () => import_messages2.MESSAGE_METADATA_KEY,
+  MESSAGE_OBJECT_KEY: () => import_messages2.MESSAGE_OBJECT_KEY,
+  MESSAGE_TAGS_KEY: () => import_messages2.MESSAGE_TAGS_KEY,
+  MessageBaseSchema: () => import_messages2.MessageBaseSchema,
+  TagsSchema: () => import_messages2.TagsSchema,
+  Uint8ArraySchema: () => import_messages2.Uint8ArraySchema
 });
 module.exports = __toCommonJS(inboxes_exports);
 var import_utilities = require("./utilities");
 var import_api = require("@graffiti-garden/api");
 var import_dag_cbor = require("@ipld/dag-cbor");
 var import_mini = require("zod/mini");
+var import_messages = require("./4-inboxes/messages");
+var import_cache = require("./4-inboxes/cache");
+var import_messages2 = require("./4-inboxes/messages");
+const INBOX_REQUEST_TIMEOUT_MS = 3e4;
+const INBOX_LOCK_WAIT_TIMEOUT_MS = 3e4;
 class Inboxes {
   getAuthorizationEndpoint = import_utilities.getAuthorizationEndpoint;
   cache_ = null;
   get cache() {
     if (!this.cache_) {
-      this.cache_ = createCache();
+      this.cache_ = (0, import_cache.createCache)();
     }
     return this.cache_;
   }
   async send(inboxUrl, message) {
     (0, import_utilities.verifyHTTPSEndpoint)(inboxUrl);
-    const url2 = `${inboxUrl}/send`;
-    const response = await (0, import_utilities.fetchWithErrorHandling)(url2, {
+    const url = `${inboxUrl}/send`;
+    const response = await (0, import_utilities.fetchWithErrorHandling)(url, {
       method: "PUT",
       headers: {
         "Content-Type": "application/cbor"
@@ -66,18 +61,18 @@ class Inboxes {
     });
     const blob = await response.blob();
     const cbor = (0, import_dag_cbor.decode)(await blob.arrayBuffer());
-    const parsed = SendResponseSchema.parse(cbor);
+    const parsed = import_messages.SendResponseSchema.parse(cbor);
     return parsed.id;
   }
   async get(inboxUrl, messageId, inboxToken) {
-    const messageCacheKey = getMessageCacheKey(inboxUrl, messageId);
+    const messageCacheKey = (0, import_cache.getMessageCacheKey)(inboxUrl, messageId);
     const cache = await this.cache;
     const cached = await cache.messages.get(messageCacheKey);
     if (cached !== void 0) return cached;
-    const url2 = `${inboxUrl}/message/${messageId}`;
+    const url = `${inboxUrl}/message/${messageId}`;
     let response = null;
     try {
-      response = await (0, import_utilities.fetchWithErrorHandling)(url2, {
+      response = await (0, import_utilities.fetchWithErrorHandling)(url, {
         method: "GET",
         headers: {
           ...inboxToken ? {
@@ -94,15 +89,15 @@ class Inboxes {
     }
     const blob = await response.blob();
     const cbor = (0, import_dag_cbor.decode)(await blob.arrayBuffer());
-    const parsed = LabeledMessageBaseSchema.parse(cbor);
+    const parsed = import_messages.LabeledMessageBaseSchema.parse(cbor);
     await cache.messages.set(messageCacheKey, parsed);
     return parsed;
   }
   async label(inboxUrl, messageId, label, inboxToken) {
     (0, import_utilities.verifyHTTPSEndpoint)(inboxUrl);
     if (inboxToken) {
-      const url2 = `${inboxUrl}/label/${messageId}`;
-      await (0, import_utilities.fetchWithErrorHandling)(url2, {
+      const url = `${inboxUrl}/label/${messageId}`;
+      await (0, import_utilities.fetchWithErrorHandling)(url, {
         method: "PUT",
         headers: {
           "Content-Type": "application/cbor",
@@ -112,7 +107,7 @@ class Inboxes {
       });
     }
     const cache = await this.cache;
-    const messageCacheKey = getMessageCacheKey(inboxUrl, messageId);
+    const messageCacheKey = (0, import_cache.getMessageCacheKey)(inboxUrl, messageId);
     const result = await cache.messages.get(messageCacheKey);
     if (result) {
       await cache.messages.set(messageCacheKey, {
@@ -122,6 +117,7 @@ class Inboxes {
     }
   }
   async fetchMessageBatch(inboxUrl, type, body, inboxToken, cursor, signal) {
+    const timeout = AbortSignal.timeout(INBOX_REQUEST_TIMEOUT_MS);
     const response = await (0, import_utilities.fetchWithErrorHandling)(
       `${inboxUrl}/${type}${cursor ? `?cursor=${encodeURIComponent(cursor)}` : ""}`,
       {
@@ -133,7 +129,7 @@ class Inboxes {
           } : {}
         },
         body,
-        signal
+        signal: signal ? AbortSignal.any([signal, timeout]) : timeout
       }
     );
     const retryAfterHeader = response.headers.get("Retry-After");
@@ -141,421 +137,236 @@ class Inboxes {
     const waitTil = retryAfter && Number.isFinite(retryAfter) ? Date.now() + retryAfter * 1e3 : void 0;
     return { response, waitTil };
   }
-  async *yieldFromCache(cache, inboxUrl, messageIdsCacheKey, cachedMessageIds, cacheNumSeen = 0) {
-    const messageIds = cachedMessageIds.messageIds.slice(cacheNumSeen);
-    const messages = await Promise.all(
-      messageIds.map(async (id) => {
-        const message = await cache.messages.get(
-          getMessageCacheKey(inboxUrl, id)
-        );
-        if (!message) {
-          try {
-            await cache.messageIds.del(messageIdsCacheKey);
-          } catch {
-          }
-          throw new Error("Cache out of sync - perhaps clear browser storage");
-        }
-        return message;
-      })
-    );
-    yield* messages;
-  }
-  async *lockedMessageStreamer(...args) {
-    if (typeof window === "undefined" || !await canUseIDB()) {
-      const streamer = this.messageStreamer(...args);
-      while (true) {
-        const next = await streamer.next();
-        if (next.done) return next.value;
-        yield next.value;
-      }
-    }
-    const messageIdsCacheKey = await args[0];
-    const lockKey = `graffiti:inbox:${messageIdsCacheKey}`;
-    let releaseLock = () => {
-    };
-    let hasLock = false;
-    await new Promise((resolvehasLock) => {
-      window.navigator.locks.request(
-        lockKey,
+  async withQueryLock(messageIdsCacheKey, useLock, work, signal) {
+    if (!useLock) return work();
+    const timeout = AbortSignal.timeout(INBOX_LOCK_WAIT_TIMEOUT_MS);
+    let acquired = false;
+    try {
+      return await window.navigator.locks.request(
+        `graffiti:inbox:${messageIdsCacheKey}`,
         {
           mode: "exclusive",
-          ifAvailable: true
+          signal: signal ? AbortSignal.any([signal, timeout]) : timeout
         },
-        async (lock) => {
-          hasLock = !!lock;
-          resolvehasLock();
-          await new Promise((r) => releaseLock = r);
+        async () => {
+          acquired = true;
+          return work();
         }
       );
-    });
-    if (hasLock) {
-      try {
-        const streamer = this.messageStreamer(...args);
-        while (true) {
-          const next = await streamer.next();
-          if (next.done) return next.value;
-          yield next.value;
-        }
-      } finally {
-        releaseLock();
+    } catch (error) {
+      if (!acquired && timeout.aborted) {
+        throw new Error("Timed out waiting for another tab's inbox query", {
+          cause: error
+        });
       }
+      throw error;
     }
-    releaseLock();
-    await window.navigator.locks.request(lockKey, () => {
-    });
-    const inboxUrl = args[1];
-    const objectSchema = args[5] ?? {};
-    const cacheVersion = args[6];
-    const cacheNumSeen = args[7];
-    const cache = await this.cache;
-    const cachedMessageIds = await cache.messageIds.get(messageIdsCacheKey);
-    if (!cachedMessageIds) {
-      throw new Error("Cache not found");
-    }
-    if (cacheVersion !== void 0 && cacheVersion !== cachedMessageIds.version) {
-      throw new import_api.GraffitiErrorCursorExpired("Cursor is stale");
-    }
-    const iterator = this.yieldFromCache(
-      cache,
-      inboxUrl,
-      messageIdsCacheKey,
-      cachedMessageIds,
-      cacheNumSeen
-    );
-    for await (const m of iterator) yield m;
-    const outputCursor = {
-      numSeen: cachedMessageIds.messageIds.length,
-      version: cachedMessageIds.version,
-      messageIdsCacheKey,
-      objectSchema
-    };
-    return JSON.stringify(outputCursor);
   }
-  async *messageStreamer(messageIdsCacheKey_, inboxUrl, type, body, inboxToken, objectSchema = {}, cacheVersion, cacheNumSeen = 0) {
+  async *messageStreamer(source) {
+    const { inboxUrl, inboxToken } = source;
+    const type = source.kind === "export" ? "export" : "query";
+    const objectSchema = source.kind === "query" ? source.schema : source.kind === "continue" ? source.cursor.objectSchema : {};
     const validator = await (0, import_api.compileGraffitiObjectSchema)(objectSchema);
-    const messageIdsCacheKey = await messageIdsCacheKey_;
+    const body = source.kind === "query" ? source.body : void 0;
+    const messageIdsCacheKey = source.kind === "continue" ? source.cursor.messageIdsCacheKey : await (0, import_cache.getMessageIdsCacheKey)(inboxUrl, type, body);
+    const cacheVersion = source.kind === "continue" ? source.cursor.version : void 0;
     const cache = await this.cache;
-    let cachedMessageIds = await cache.messageIds.get(messageIdsCacheKey);
-    if (cacheVersion !== void 0 && cacheVersion !== cachedMessageIds?.version) {
-      throw new import_api.GraffitiErrorCursorExpired("Cursor is stale");
-    }
-    let waitTil = cachedMessageIds?.waitTil;
-    await waitFor(waitTil);
-    const cachedCursor = cachedMessageIds?.cursor;
-    let firstResponse = void 0;
-    try {
-      const out = await this.fetchMessageBatch(
-        inboxUrl,
-        type,
-        body,
-        inboxToken,
-        cachedCursor
-      );
-      firstResponse = out.response;
-      waitTil = out.waitTil;
-    } catch (e) {
-      if (!(e instanceof import_api.GraffitiErrorCursorExpired && cachedCursor)) {
-        console.error(
-          "Unexpected error in stream, waiting 5 seconds before continuing..."
+    const useLock = typeof window !== "undefined" && await (0, import_cache.canUseIDB)();
+    const initialQuery = await cache.messageIds.get(messageIdsCacheKey);
+    let seenGeneration = initialQuery?.generation;
+    let seenVersion = initialQuery?.version;
+    let numSeen = source.kind === "continue" ? source.cursor.numSeen : 0;
+    let firstPage = true;
+    const fetchPage = async (signal) => {
+      while (true) {
+        signal?.throwIfAborted();
+        const step = await this.withQueryLock(
+          messageIdsCacheKey,
+          useLock,
+          async () => {
+            signal?.throwIfAborted();
+            let query = await cache.messageIds.get(messageIdsCacheKey);
+            if (cacheVersion !== void 0 && cacheVersion !== query?.version) {
+              throw new import_api.GraffitiErrorCursorExpired("Cursor is stale");
+            }
+            if (query?.version !== seenVersion) {
+              if (!firstPage) throw new import_api.GraffitiErrorCursorExpired("Cursor is stale");
+              numSeen = 0;
+            }
+            if (query?.generation && query.generation !== seenGeneration) {
+              return { query };
+            }
+            if (query?.waitTil !== void 0 && query.waitTil > Date.now()) {
+              return { waitTil: query.waitTil };
+            }
+            let batch;
+            try {
+              batch = await this.fetchMessageBatch(
+                inboxUrl,
+                type,
+                firstPage ? body : void 0,
+                // Later pages send no body.
+                inboxToken,
+                query?.cursor,
+                signal
+              );
+            } catch (error) {
+              if (!(error instanceof import_api.GraffitiErrorCursorExpired && query?.cursor)) {
+                if (firstPage && !signal?.aborted) {
+                  return { initialFetchError: error };
+                }
+                throw error;
+              }
+              if (!firstPage) throw error;
+              await cache.messageIds.del(messageIdsCacheKey);
+              if (cacheVersion !== void 0) throw error;
+              query = void 0;
+              numSeen = 0;
+              batch = await this.fetchMessageBatch(
+                inboxUrl,
+                type,
+                body,
+                inboxToken,
+                void 0,
+                signal
+              );
+            }
+            const decoded = (0, import_dag_cbor.decode)(
+              new Uint8Array(await batch.response.arrayBuffer())
+            );
+            const { results, hasMore, cursor } = import_messages.MessageResultSchema.parse(decoded);
+            const labeledMessages = results.map(
+              (result) => {
+                const object = result[import_messages.LABELED_MESSAGE_MESSAGE_KEY][import_messages.MESSAGE_OBJECT_KEY];
+                if (!validator(object)) {
+                  throw new Error("Server returned data that does not match schema");
+                }
+                return {
+                  ...result,
+                  [import_messages.LABELED_MESSAGE_MESSAGE_KEY]: {
+                    ...result[import_messages.LABELED_MESSAGE_MESSAGE_KEY],
+                    [import_messages.MESSAGE_OBJECT_KEY]: object
+                  }
+                };
+              }
+            );
+            query = await (0, import_cache.storeQueryPage)(
+              cache,
+              inboxUrl,
+              messageIdsCacheKey,
+              query,
+              {
+                messages: labeledMessages,
+                cursor,
+                hasMore,
+                waitTil: batch.waitTil
+              }
+            );
+            return { query };
+          },
+          signal
         );
-        await new Promise((resolve) => setTimeout(resolve, 5e3));
-        throw e;
-      }
-      await cache.messageIds.del(messageIdsCacheKey);
-      if (cacheVersion === void 0) {
-        cachedMessageIds = void 0;
-      } else {
-        throw e;
+        if ("initialFetchError" in step) {
+          console.error(
+            "Unexpected error in stream, waiting 5 seconds before continuing..."
+          );
+          await new Promise((resolve) => setTimeout(resolve, 5e3));
+          throw step.initialFetchError;
+        }
+        if ("waitTil" in step) {
+          await waitFor(step.waitTil);
+          continue;
+        }
+        return step.query;
       }
-    }
-    if (firstResponse !== void 0 && cachedMessageIds) {
-      const iterator = this.yieldFromCache(
+    };
+    let nextPage;
+    while (true) {
+      const result = nextPage ? await nextPage : await fetchPage().then(
+        (query2) => ({ query: query2 }),
+        (error) => ({ error })
+      );
+      nextPage = void 0;
+      if ("error" in result) throw result.error;
+      const query = result.query;
+      const messages = await (0, import_cache.replayQuery)(
         cache,
         inboxUrl,
         messageIdsCacheKey,
-        cachedMessageIds,
-        cacheNumSeen
+        query,
+        numSeen
       );
-      for await (const m of iterator) yield m;
-    }
-    if (firstResponse === void 0) {
-      const out = await this.fetchMessageBatch(
-        inboxUrl,
-        type,
-        body,
-        inboxToken
-      );
-      firstResponse = out.response;
-      waitTil = out.waitTil;
-    }
-    let response = firstResponse;
-    let cursor;
-    const version = cachedMessageIds?.version ?? crypto.randomUUID();
-    let messageIds = cachedMessageIds?.messageIds ?? [];
-    while (true) {
-      const blob = await response.blob();
-      const decoded = (0, import_dag_cbor.decode)(await blob.arrayBuffer());
-      const {
-        results,
-        hasMore,
-        cursor: nextCursor
-      } = MessageResultSchema.parse(decoded);
-      cursor = nextCursor;
-      const labeledMessages = results.map(
-        (result) => {
-          const object = result[LABELED_MESSAGE_MESSAGE_KEY][MESSAGE_OBJECT_KEY];
-          if (!validator(object)) {
-            throw new Error("Server returned data that does not match schema");
-          }
-          return {
-            ...result,
-            [LABELED_MESSAGE_MESSAGE_KEY]: {
-              ...result[LABELED_MESSAGE_MESSAGE_KEY],
-              [MESSAGE_OBJECT_KEY]: object
-            }
-          };
-        }
-      );
-      await cache.messages.setMany(
-        labeledMessages.map((m) => [
-          getMessageCacheKey(inboxUrl, m[LABELED_MESSAGE_ID_KEY]),
-          m
-        ])
-      );
-      messageIds = [
-        ...messageIds,
-        ...labeledMessages.map(
-          (m) => m[LABELED_MESSAGE_ID_KEY]
-        )
-      ];
-      await cache.messageIds.set(messageIdsCacheKey, {
-        cursor,
-        version,
-        messageIds,
-        waitTil
-      });
-      cacheNumSeen += labeledMessages.length;
+      numSeen = query.messageIds.length;
+      seenGeneration = query.generation;
+      seenVersion = query.version;
+      firstPage = false;
       const prefetchController = new AbortController();
-      const nextPage = hasMore ? waitFor(waitTil).then(() => this.fetchMessageBatch(
-        inboxUrl,
-        type,
-        void 0,
-        // Body is never past the first time
-        inboxToken,
-        cursor,
-        prefetchController.signal
-      )).then((value) => ({ value }), (error) => ({ error })) : null;
+      if (query.hasMore) {
+        nextPage = fetchPage(prefetchController.signal).then(
+          (query2) => ({ query: query2 }),
+          (error) => ({ error })
+        );
+      }
       let consumedPage = false;
       try {
-        for (const m of labeledMessages) yield m;
+        for (const message of messages) {
+          yield message;
+        }
         consumedPage = true;
       } finally {
         if (!consumedPage) prefetchController.abort();
       }
-      if (!hasMore) break;
-      const out = await nextPage;
-      if ("error" in out) throw out.error;
-      response = out.value.response;
-      waitTil = out.value.waitTil;
+      if (!query.hasMore) {
+        const outputCursor = {
+          numSeen,
+          version: query.version,
+          messageIdsCacheKey,
+          objectSchema
+        };
+        return JSON.stringify(outputCursor);
+      }
     }
-    const outputCursor = {
-      numSeen: cacheNumSeen,
-      version,
-      messageIdsCacheKey,
-      objectSchema
-    };
-    return JSON.stringify(outputCursor);
   }
   query(inboxUrl, tags, objectSchema, inboxToken) {
     (0, import_utilities.verifyHTTPSEndpoint)(inboxUrl);
-    const body = (0, import_dag_cbor.encode)({
+    const body = new Uint8Array((0, import_dag_cbor.encode)({
       tags,
       schema: objectSchema
-    });
-    const messageIdsCacheKey = getMessageIdsCacheKey(inboxUrl, "query", body);
-    return this.lockedMessageStreamer(
-      messageIdsCacheKey,
+    }));
+    return this.messageStreamer({
+      kind: "query",
       inboxUrl,
-      "query",
-      new Uint8Array(body),
-      inboxToken,
-      objectSchema
-    );
+      body,
+      schema: objectSchema,
+      inboxToken
+    });
   }
   continueQuery(inboxUrl, cursor, inboxToken) {
     (0, import_utilities.verifyHTTPSEndpoint)(inboxUrl);
     const decodedCursor = JSON.parse(cursor);
-    const { messageIdsCacheKey, numSeen, objectSchema, version } = CursorSchema.parse(decodedCursor);
-    return this.lockedMessageStreamer(
-      Promise.resolve(messageIdsCacheKey),
+    const parsedCursor = CursorSchema.parse(decodedCursor);
+    return this.messageStreamer({
+      kind: "continue",
       inboxUrl,
-      "query",
-      void 0,
-      inboxToken,
-      objectSchema,
-      version,
-      numSeen
-    );
+      cursor: parsedCursor,
+      inboxToken
+    });
   }
   export(inboxUrl, inboxToken) {
     (0, import_utilities.verifyHTTPSEndpoint)(inboxUrl);
-    const messageIdsCacheKey = getMessageIdsCacheKey(inboxUrl, "export");
-    return this.lockedMessageStreamer(
-      messageIdsCacheKey,
+    return this.messageStreamer({
+      kind: "export",
       inboxUrl,
-      "export",
-      void 0,
       inboxToken
-    );
+    });
   }
 }
-const GraffitiObjectSchema = (0, import_mini.strictObject)({
-  value: (0, import_mini.looseObject)({}),
-  channels: (0, import_mini.array)((0, import_mini.string)()),
-  allowed: (0, import_mini.optional)((0, import_mini.nullable)((0, import_mini.array)((0, import_mini.url)()))),
-  url: (0, import_mini.url)(),
-  actor: (0, import_mini.url)()
-});
-const Uint8ArraySchema = (0, import_mini.custom)(
-  (v) => v instanceof Uint8Array
-);
-const TagsSchema = (0, import_mini.array)(Uint8ArraySchema);
-const MESSAGE_TAGS_KEY = "t";
-const MESSAGE_OBJECT_KEY = "o";
-const MESSAGE_METADATA_KEY = "m";
-const MessageBaseSchema = (0, import_mini.strictObject)({
-  [MESSAGE_TAGS_KEY]: TagsSchema,
-  [MESSAGE_OBJECT_KEY]: GraffitiObjectSchema,
-  [MESSAGE_METADATA_KEY]: Uint8ArraySchema
-});
-const LABELED_MESSAGE_ID_KEY = "id";
-const LABELED_MESSAGE_MESSAGE_KEY = "m";
-const LABELED_MESSAGE_LABEL_KEY = "l";
-const LabeledMessageBaseSchema = (0, import_mini.strictObject)({
-  [LABELED_MESSAGE_ID_KEY]: (0, import_mini.string)(),
-  [LABELED_MESSAGE_MESSAGE_KEY]: MessageBaseSchema,
-  [LABELED_MESSAGE_LABEL_KEY]: (0, import_mini.number)()
-});
-const SendResponseSchema = (0, import_mini.strictObject)({ id: (0, import_mini.string)() });
-const MessageResultSchema = (0, import_mini.strictObject)({
-  results: (0, import_mini.array)(LabeledMessageBaseSchema),
-  hasMore: (0, import_mini.boolean)(),
-  cursor: (0, import_mini.string)()
-});
 const CursorSchema = (0, import_mini.strictObject)({
   messageIdsCacheKey: (0, import_mini.string)(),
   version: (0, import_mini.string)(),
   numSeen: (0, import_mini.int)().check((0, import_mini.nonnegative)()),
   objectSchema: (0, import_mini.union)([(0, import_mini.looseObject)({}), (0, import_mini.boolean)()])
 });
-async function canUseIDB() {
-  try {
-    if (!globalThis.indexedDB) return false;
-    await new Promise((resolve, reject) => {
-      const req = indexedDB.open("__idb_probe__", 1);
-      req.onupgradeneeded = () => req.result.createObjectStore("k");
-      req.onsuccess = () => {
-        req.result.close();
-        resolve();
-      };
-      req.onerror = () => reject(req.error);
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getMessageCacheKey(inboxUrl, messageId) {
-  return `${encodeURIComponent(inboxUrl)}:${encodeURIComponent(messageId)}`;
-}
-async function getMessageIdsCacheKey(inboxUrl, type, body) {
-  const cacheIdData = (0, import_dag_cbor.encode)({
-    inboxUrl,
-    type,
-    body: body ?? null
-  });
-  return crypto.subtle.digest("SHA-256", new Uint8Array(cacheIdData)).then(
-    (bytes) => Array.from(new Uint8Array(bytes)).map((byte) => byte.toString(16).padStart(2, "0")).join("")
-  );
-}
-async function resetCacheDB() {
-  await new Promise((resolve) => {
-    const req = indexedDB.deleteDatabase("graffiti-inbox-cache");
-    req.onsuccess = () => resolve();
-    req.onerror = () => resolve();
-    req.onblocked = () => resolve();
-  });
-}
-async function createCache() {
-  if (await canUseIDB()) {
-    const { openDB } = await import("idb");
-    const db = await openDB("graffiti-inbox-cache", 1, {
-      upgrade(db2) {
-        if (!db2.objectStoreNames.contains("m")) db2.createObjectStore("m");
-        if (!db2.objectStoreNames.contains("q")) db2.createObjectStore("q");
-      }
-    });
-    return {
-      messages: {
-        get: async (k) => {
-          try {
-            return db.get("m", k);
-          } catch (error) {
-            console.error("Error getting message from cache:", error);
-            console.error("resetting cache...");
-            await resetCacheDB();
-            return void 0;
-          }
-        },
-        set: async (k, v) => {
-          await db.put("m", v, k);
-        },
-        setMany: async (entries) => {
-          if (entries.length === 0) return;
-          const tx = db.transaction("m", "readwrite");
-          await Promise.all([
-            ...entries.map(([k, v]) => tx.store.put(v, k)),
-            tx.done
-          ]);
-        },
-        del: (k) => db.delete("m", k)
-      },
-      messageIds: {
-        get: async (k) => {
-          try {
-            return await db.get("q", k);
-          } catch (error) {
-            console.error("Error getting message IDs from cache:", error);
-            console.error("resetting cache...");
-            await resetCacheDB();
-            return void 0;
-          }
-        },
-        set: async (k, v) => {
-          await db.put("q", v, k);
-        },
-        del: (k) => db.delete("q", k)
-      }
-    };
-  }
-  const m = /* @__PURE__ */ new Map();
-  const q = /* @__PURE__ */ new Map();
-  return {
-    messages: {
-      get: async (k) => m.get(k),
-      set: async (k, v) => void m.set(k, v),
-      setMany: async (entries) => {
-        for (const [k, v] of entries) m.set(k, v);
-      },
-      del: async (k) => void m.delete(k)
-    },
-    messageIds: {
-      get: async (k) => q.get(k),
-      set: async (k, v) => void q.set(k, v),
-      del: async (k) => void q.delete(k)
-    }
-  };
-}
 async function waitFor(waitTil) {
   if (waitTil !== void 0) {
     const waitFor2 = waitTil - Date.now();