@graffiti-garden/implementation-decentralized 0.1.3 → 0.1.4

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

@@ -0,0 +1,186 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 cache_exports = {};
+__export(cache_exports, {
+  canUseIDB: () => canUseIDB,
+  createCache: () => createCache,
+  getMessageCacheKey: () => getMessageCacheKey,
+  getMessageIdsCacheKey: () => getMessageIdsCacheKey,
+  replayQuery: () => replayQuery,
+  storeQueryPage: () => storeQueryPage
+});
+module.exports = __toCommonJS(cache_exports);
+var import_dag_cbor = require("@ipld/dag-cbor");
+var import_messages = require("./messages");
+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 replayQuery(cache, inboxUrl, messageIdsCacheKey, query, numSeen = 0) {
+  const messageIds = query.messageIds.slice(numSeen);
+  return 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;
+    })
+  );
+}
+async function storeQueryPage(cache, inboxUrl, messageIdsCacheKey, previous, page) {
+  await cache.messages.setMany(
+    page.messages.map((message) => [
+      getMessageCacheKey(inboxUrl, message[import_messages.LABELED_MESSAGE_ID_KEY]),
+      message
+    ])
+  );
+  const query = {
+    cursor: page.cursor,
+    version: previous?.version ?? crypto.randomUUID(),
+    messageIds: [
+      ...previous?.messageIds ?? [],
+      ...page.messages.map((message) => message[import_messages.LABELED_MESSAGE_ID_KEY])
+    ],
+    generation: crypto.randomUUID(),
+    hasMore: page.hasMore,
+    waitTil: page.waitTil
+  };
+  await cache.messageIds.set(messageIdsCacheKey, query);
+  return query;
+}
+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)
+    }
+  };
+}
+//# sourceMappingURL=cache.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/1-services/4-inboxes/cache.ts"],
+  "sourcesContent": ["import { encode as dagCborEncode } from \"@ipld/dag-cbor\";\nimport { LABELED_MESSAGE_ID_KEY, type LabeledMessageBase } from \"./messages\";\n\n// One record per inbox query. Messages live in the separate message cache;\n// this record tracks their IDs and where to continue fetching from the server.\nexport type CacheQueryValue = {\n  // Server continuation state for the next page.\n  cursor: string;\n  // Identifies this local query history, not a server version. It stays the\n  // same as pages arrive; a reset creates a new one so old caller cursors expire.\n  version: string;\n  // All message IDs fetched for this query so far, in order. A caller's\n  // numSeen cursor indexes into this list to replay only unseen messages.\n  messageIds: string[];\n  waitTil?: number;\n  // Changes on every cached page write, even if the page is empty and neither\n  // messageIds nor cursor changes. A tab waiting on the query lock can use this\n  // to detect and reuse a page fetched by another tab. Older entries lack it.\n  generation?: string;\n  // Whether the server has another page; needed when reusing another tab's\n  // cached page. Older cache entries lack this and are refreshed on next query.\n  hasMore?: boolean;\n};\n\nexport async function canUseIDB(): Promise<boolean> {\n  try {\n    if (!globalThis.indexedDB) return false;\n\n    // Small probe database\n    await new Promise<void>((resolve, reject) => {\n      const req = indexedDB.open(\"__idb_probe__\", 1);\n      req.onupgradeneeded = () => req.result.createObjectStore(\"k\");\n      req.onsuccess = () => {\n        req.result.close();\n        resolve();\n      };\n      req.onerror = () => reject(req.error);\n    });\n\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nexport type Cache = {\n  messages: {\n    get(k: string): Promise<LabeledMessageBase | null | undefined>;\n    set(k: string, value: LabeledMessageBase | null): Promise<void>;\n    setMany(entries: [string, LabeledMessageBase][]): Promise<void>;\n    del(k: string): Promise<void>;\n  };\n  messageIds: {\n    get(k: string): Promise<CacheQueryValue | undefined>;\n    set(k: string, value: CacheQueryValue): Promise<void>;\n    del(k: string): Promise<void>;\n  };\n};\n\nexport function getMessageCacheKey(inboxUrl: string, messageId: string) {\n  return `${encodeURIComponent(inboxUrl)}:${encodeURIComponent(messageId)}`;\n}\n\nexport async function replayQuery(\n  cache: Cache,\n  inboxUrl: string,\n  messageIdsCacheKey: string,\n  query: CacheQueryValue,\n  numSeen = 0,\n): Promise<LabeledMessageBase[]> {\n  // Filter out all messageIds before\n  // the number already seen\n  const messageIds = query.messageIds.slice(numSeen);\n\n  // Get all the messages pointed to in the cache\n  return Promise.all(\n    messageIds.map(async (id) => {\n      const message = await cache.messages.get(getMessageCacheKey(inboxUrl, id));\n      if (!message) {\n        // Something is very wrong with the cache,\n        // it refers to message IDs that are not cached\n        try {\n          await cache.messageIds.del(messageIdsCacheKey);\n        } catch {}\n        throw new Error(\"Cache out of sync - perhaps clear browser storage\");\n      }\n      return message;\n    }),\n  );\n}\n\nexport async function storeQueryPage(\n  cache: Cache,\n  inboxUrl: string,\n  messageIdsCacheKey: string,\n  previous: CacheQueryValue | undefined,\n  page: {\n    messages: LabeledMessageBase[];\n    cursor: string;\n    hasMore: boolean;\n    waitTil?: number;\n  },\n): Promise<CacheQueryValue> {\n  // First cache the messages with their labels\n  await cache.messages.setMany(\n    page.messages.map((message) => [\n      getMessageCacheKey(inboxUrl, message[LABELED_MESSAGE_ID_KEY]),\n      message,\n    ]),\n  );\n  // Then store all the messageids\n  const query = {\n    cursor: page.cursor,\n    version: previous?.version ?? crypto.randomUUID(),\n    messageIds: [\n      ...(previous?.messageIds ?? []),\n      ...page.messages.map((message) => message[LABELED_MESSAGE_ID_KEY]),\n    ],\n    generation: crypto.randomUUID(),\n    hasMore: page.hasMore,\n    waitTil: page.waitTil,\n  };\n  await cache.messageIds.set(messageIdsCacheKey, query);\n  return query;\n}\n\nexport async function getMessageIdsCacheKey(\n  inboxUrl: string,\n  type: \"query\" | \"export\",\n  body?: Uint8Array,\n): Promise<string> {\n  const cacheIdData = dagCborEncode({\n    inboxUrl,\n    type,\n    body: body ?? null,\n  });\n  return crypto.subtle\n    .digest(\"SHA-256\", new Uint8Array(cacheIdData))\n    .then((bytes) =>\n      Array.from(new Uint8Array(bytes))\n        .map((byte) => byte.toString(16).padStart(2, \"0\"))\n        .join(\"\"),\n    );\n}\n\nasync function resetCacheDB() {\n  await new Promise<void>((resolve) => {\n    const req = indexedDB.deleteDatabase(\"graffiti-inbox-cache\");\n    req.onsuccess = () => resolve();\n    req.onerror = () => resolve(); // best effort\n    req.onblocked = () => resolve(); // best effort\n  });\n}\n\nexport async function createCache(): Promise<Cache> {\n  if (await canUseIDB()) {\n    const { openDB } = await import(\"idb\");\n    const db = await openDB(\"graffiti-inbox-cache\", 1, {\n      upgrade(db) {\n        if (!db.objectStoreNames.contains(\"m\")) db.createObjectStore(\"m\");\n        if (!db.objectStoreNames.contains(\"q\")) db.createObjectStore(\"q\");\n      },\n    });\n\n    return {\n      messages: {\n        get: async (k) => {\n          try {\n            return db.get(\"m\", k);\n          } catch (error) {\n            console.error(\"Error getting message from cache:\", error);\n            console.error(\"resetting cache...\");\n            await resetCacheDB();\n            return undefined;\n          }\n        },\n        set: async (k, v) => {\n          await db.put(\"m\", v, k);\n        },\n        setMany: async (entries) => {\n          if (entries.length === 0) return;\n          const tx = db.transaction(\"m\", \"readwrite\");\n          await Promise.all([\n            ...entries.map(([k, v]) => tx.store.put(v, k)),\n            tx.done,\n          ]);\n        },\n        del: (k) => db.delete(\"m\", k),\n      },\n      messageIds: {\n        get: async (k) => {\n          try {\n            return await db.get(\"q\", k);\n          } catch (error) {\n            console.error(\"Error getting message IDs from cache:\", error);\n            console.error(\"resetting cache...\");\n            await resetCacheDB();\n            return undefined;\n          }\n        },\n        set: async (k, v) => {\n          await db.put(\"q\", v, k);\n        },\n        del: (k) => db.delete(\"q\", k),\n      },\n    };\n  }\n\n  const m = new Map<string, LabeledMessageBase | null>();\n  const q = new Map<string, CacheQueryValue>();\n\n  return {\n    messages: {\n      get: async (k) => m.get(k),\n      set: async (k, v) => void m.set(k, v),\n      setMany: async (entries) => {\n        for (const [k, v] of entries) m.set(k, v);\n      },\n      del: async (k) => void m.delete(k),\n    },\n    messageIds: {\n      get: async (k) => q.get(k),\n      set: async (k, v) => void q.set(k, v),\n      del: async (k) => void q.delete(k),\n    },\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAAwC;AACxC,sBAAgE;AAuBhE,eAAsB,YAA8B;AAClD,MAAI;AACF,QAAI,CAAC,WAAW,UAAW,QAAO;AAGlC,UAAM,IAAI,QAAc,CAAC,SAAS,WAAW;AAC3C,YAAM,MAAM,UAAU,KAAK,iBAAiB,CAAC;AAC7C,UAAI,kBAAkB,MAAM,IAAI,OAAO,kBAAkB,GAAG;AAC5D,UAAI,YAAY,MAAM;AACpB,YAAI,OAAO,MAAM;AACjB,gBAAQ;AAAA,MACV;AACA,UAAI,UAAU,MAAM,OAAO,IAAI,KAAK;AAAA,IACtC,CAAC;AAED,WAAO;AAAA,EACT,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAgBO,SAAS,mBAAmB,UAAkB,WAAmB;AACtE,SAAO,GAAG,mBAAmB,QAAQ,CAAC,IAAI,mBAAmB,SAAS,CAAC;AACzE;AAEA,eAAsB,YACpB,OACA,UACA,oBACA,OACA,UAAU,GACqB;AAG/B,QAAM,aAAa,MAAM,WAAW,MAAM,OAAO;AAGjD,SAAO,QAAQ;AAAA,IACb,WAAW,IAAI,OAAO,OAAO;AAC3B,YAAM,UAAU,MAAM,MAAM,SAAS,IAAI,mBAAmB,UAAU,EAAE,CAAC;AACzE,UAAI,CAAC,SAAS;AAGZ,YAAI;AACF,gBAAM,MAAM,WAAW,IAAI,kBAAkB;AAAA,QAC/C,QAAQ;AAAA,QAAC;AACT,cAAM,IAAI,MAAM,mDAAmD;AAAA,MACrE;AACA,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AACF;AAEA,eAAsB,eACpB,OACA,UACA,oBACA,UACA,MAM0B;AAE1B,QAAM,MAAM,SAAS;AAAA,IACnB,KAAK,SAAS,IAAI,CAAC,YAAY;AAAA,MAC7B,mBAAmB,UAAU,QAAQ,sCAAsB,CAAC;AAAA,MAC5D;AAAA,IACF,CAAC;AAAA,EACH;AAEA,QAAM,QAAQ;AAAA,IACZ,QAAQ,KAAK;AAAA,IACb,SAAS,UAAU,WAAW,OAAO,WAAW;AAAA,IAChD,YAAY;AAAA,MACV,GAAI,UAAU,cAAc,CAAC;AAAA,MAC7B,GAAG,KAAK,SAAS,IAAI,CAAC,YAAY,QAAQ,sCAAsB,CAAC;AAAA,IACnE;AAAA,IACA,YAAY,OAAO,WAAW;AAAA,IAC9B,SAAS,KAAK;AAAA,IACd,SAAS,KAAK;AAAA,EAChB;AACA,QAAM,MAAM,WAAW,IAAI,oBAAoB,KAAK;AACpD,SAAO;AACT;AAEA,eAAsB,sBACpB,UACA,MACA,MACiB;AACjB,QAAM,kBAAc,gBAAAA,QAAc;AAAA,IAChC;AAAA,IACA;AAAA,IACA,MAAM,QAAQ;AAAA,EAChB,CAAC;AACD,SAAO,OAAO,OACX,OAAO,WAAW,IAAI,WAAW,WAAW,CAAC,EAC7C;AAAA,IAAK,CAAC,UACL,MAAM,KAAK,IAAI,WAAW,KAAK,CAAC,EAC7B,IAAI,CAAC,SAAS,KAAK,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAChD,KAAK,EAAE;AAAA,EACZ;AACJ;AAEA,eAAe,eAAe;AAC5B,QAAM,IAAI,QAAc,CAAC,YAAY;AACnC,UAAM,MAAM,UAAU,eAAe,sBAAsB;AAC3D,QAAI,YAAY,MAAM,QAAQ;AAC9B,QAAI,UAAU,MAAM,QAAQ;AAC5B,QAAI,YAAY,MAAM,QAAQ;AAAA,EAChC,CAAC;AACH;AAEA,eAAsB,cAA8B;AAClD,MAAI,MAAM,UAAU,GAAG;AACrB,UAAM,EAAE,OAAO,IAAI,MAAM,OAAO,KAAK;AACrC,UAAM,KAAK,MAAM,OAAO,wBAAwB,GAAG;AAAA,MACjD,QAAQC,KAAI;AACV,YAAI,CAACA,IAAG,iBAAiB,SAAS,GAAG,EAAG,CAAAA,IAAG,kBAAkB,GAAG;AAChE,YAAI,CAACA,IAAG,iBAAiB,SAAS,GAAG,EAAG,CAAAA,IAAG,kBAAkB,GAAG;AAAA,MAClE;AAAA,IACF,CAAC;AAED,WAAO;AAAA,MACL,UAAU;AAAA,QACR,KAAK,OAAO,MAAM;AAChB,cAAI;AACF,mBAAO,GAAG,IAAI,KAAK,CAAC;AAAA,UACtB,SAAS,OAAO;AACd,oBAAQ,MAAM,qCAAqC,KAAK;AACxD,oBAAQ,MAAM,oBAAoB;AAClC,kBAAM,aAAa;AACnB,mBAAO;AAAA,UACT;AAAA,QACF;AAAA,QACA,KAAK,OAAO,GAAG,MAAM;AACnB,gBAAM,GAAG,IAAI,KAAK,GAAG,CAAC;AAAA,QACxB;AAAA,QACA,SAAS,OAAO,YAAY;AAC1B,cAAI,QAAQ,WAAW,EAAG;AAC1B,gBAAM,KAAK,GAAG,YAAY,KAAK,WAAW;AAC1C,gBAAM,QAAQ,IAAI;AAAA,YAChB,GAAG,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,IAAI,GAAG,CAAC,CAAC;AAAA,YAC7C,GAAG;AAAA,UACL,CAAC;AAAA,QACH;AAAA,QACA,KAAK,CAAC,MAAM,GAAG,OAAO,KAAK,CAAC;AAAA,MAC9B;AAAA,MACA,YAAY;AAAA,QACV,KAAK,OAAO,MAAM;AAChB,cAAI;AACF,mBAAO,MAAM,GAAG,IAAI,KAAK,CAAC;AAAA,UAC5B,SAAS,OAAO;AACd,oBAAQ,MAAM,yCAAyC,KAAK;AAC5D,oBAAQ,MAAM,oBAAoB;AAClC,kBAAM,aAAa;AACnB,mBAAO;AAAA,UACT;AAAA,QACF;AAAA,QACA,KAAK,OAAO,GAAG,MAAM;AACnB,gBAAM,GAAG,IAAI,KAAK,GAAG,CAAC;AAAA,QACxB;AAAA,QACA,KAAK,CAAC,MAAM,GAAG,OAAO,KAAK,CAAC;AAAA,MAC9B;AAAA,IACF;AAAA,EACF;AAEA,QAAM,IAAI,oBAAI,IAAuC;AACrD,QAAM,IAAI,oBAAI,IAA6B;AAE3C,SAAO;AAAA,IACL,UAAU;AAAA,MACR,KAAK,OAAO,MAAM,EAAE,IAAI,CAAC;AAAA,MACzB,KAAK,OAAO,GAAG,MAAM,KAAK,EAAE,IAAI,GAAG,CAAC;AAAA,MACpC,SAAS,OAAO,YAAY;AAC1B,mBAAW,CAAC,GAAG,CAAC,KAAK,QAAS,GAAE,IAAI,GAAG,CAAC;AAAA,MAC1C;AAAA,MACA,KAAK,OAAO,MAAM,KAAK,EAAE,OAAO,CAAC;AAAA,IACnC;AAAA,IACA,YAAY;AAAA,MACV,KAAK,OAAO,MAAM,EAAE,IAAI,CAAC;AAAA,MACzB,KAAK,OAAO,GAAG,MAAM,KAAK,EAAE,IAAI,GAAG,CAAC;AAAA,MACpC,KAAK,OAAO,MAAM,KAAK,EAAE,OAAO,CAAC;AAAA,IACnC;AAAA,EACF;AACF;",
+  "names": ["dagCborEncode", "db"]
+}

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

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var messages_exports = {};
+__export(messages_exports, {
+  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,
+  MessageResultSchema: () => MessageResultSchema,
+  SendResponseSchema: () => SendResponseSchema,
+  TagsSchema: () => TagsSchema,
+  Uint8ArraySchema: () => Uint8ArraySchema
+});
+module.exports = __toCommonJS(messages_exports);
+var import_mini = require("zod/mini");
+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)()
+});
+//# sourceMappingURL=messages.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/1-services/4-inboxes/messages.ts"],
+  "sourcesContent": ["import type { JSONSchema, GraffitiObject } from \"@graffiti-garden/api\";\nimport {\n  type infer as infer_,\n  string,\n  url,\n  array,\n  optional,\n  nullable,\n  strictObject,\n  looseObject,\n  custom,\n  number,\n  boolean,\n} from \"zod/mini\";\n\nconst GraffitiObjectSchema = strictObject({\n  value: looseObject({}),\n  channels: array(string()),\n  allowed: optional(nullable(array(url()))),\n  url: url(),\n  actor: url(),\n});\nexport const Uint8ArraySchema = custom<Uint8Array>(\n  (v): v is Uint8Array => v instanceof Uint8Array,\n);\nexport const TagsSchema = array(Uint8ArraySchema);\n\nexport const MESSAGE_TAGS_KEY = \"t\";\nexport const MESSAGE_OBJECT_KEY = \"o\";\nexport const MESSAGE_METADATA_KEY = \"m\";\nexport const MessageBaseSchema = strictObject({\n  [MESSAGE_TAGS_KEY]: TagsSchema,\n  [MESSAGE_OBJECT_KEY]: GraffitiObjectSchema,\n  [MESSAGE_METADATA_KEY]: Uint8ArraySchema,\n});\ntype MessageBase = infer_<typeof MessageBaseSchema>;\n\nexport const LABELED_MESSAGE_ID_KEY = \"id\";\nexport const LABELED_MESSAGE_MESSAGE_KEY = \"m\";\nexport const LABELED_MESSAGE_LABEL_KEY = \"l\";\nexport const LabeledMessageBaseSchema = strictObject({\n  [LABELED_MESSAGE_ID_KEY]: string(),\n  [LABELED_MESSAGE_MESSAGE_KEY]: MessageBaseSchema,\n  [LABELED_MESSAGE_LABEL_KEY]: number(),\n});\nexport type LabeledMessageBase = infer_<typeof LabeledMessageBaseSchema>;\n\nexport type Message<Schema extends JSONSchema> = MessageBase & {\n  [MESSAGE_OBJECT_KEY]: GraffitiObject<Schema>;\n};\nexport type LabeledMessage<Schema extends JSONSchema> = LabeledMessageBase & {\n  [LABELED_MESSAGE_MESSAGE_KEY]: {\n    [MESSAGE_OBJECT_KEY]: GraffitiObject<Schema>;\n  };\n};\n\nexport const SendResponseSchema = strictObject({ id: string() });\n\nexport const MessageResultSchema = strictObject({\n  results: array(LabeledMessageBaseSchema),\n  hasMore: boolean(),\n  cursor: string(),\n});\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,kBAYO;AAEP,MAAM,2BAAuB,0BAAa;AAAA,EACxC,WAAO,yBAAY,CAAC,CAAC;AAAA,EACrB,cAAU,uBAAM,oBAAO,CAAC;AAAA,EACxB,aAAS,0BAAS,0BAAS,uBAAM,iBAAI,CAAC,CAAC,CAAC;AAAA,EACxC,SAAK,iBAAI;AAAA,EACT,WAAO,iBAAI;AACb,CAAC;AACM,MAAM,uBAAmB;AAAA,EAC9B,CAAC,MAAuB,aAAa;AACvC;AACO,MAAM,iBAAa,mBAAM,gBAAgB;AAEzC,MAAM,mBAAmB;AACzB,MAAM,qBAAqB;AAC3B,MAAM,uBAAuB;AAC7B,MAAM,wBAAoB,0BAAa;AAAA,EAC5C,CAAC,gBAAgB,GAAG;AAAA,EACpB,CAAC,kBAAkB,GAAG;AAAA,EACtB,CAAC,oBAAoB,GAAG;AAC1B,CAAC;AAGM,MAAM,yBAAyB;AAC/B,MAAM,8BAA8B;AACpC,MAAM,4BAA4B;AAClC,MAAM,+BAA2B,0BAAa;AAAA,EACnD,CAAC,sBAAsB,OAAG,oBAAO;AAAA,EACjC,CAAC,2BAA2B,GAAG;AAAA,EAC/B,CAAC,yBAAyB,OAAG,oBAAO;AACtC,CAAC;AAYM,MAAM,yBAAqB,0BAAa,EAAE,QAAI,oBAAO,EAAE,CAAC;AAExD,MAAM,0BAAsB,0BAAa;AAAA,EAC9C,aAAS,mBAAM,wBAAwB;AAAA,EACvC,aAAS,qBAAQ;AAAA,EACjB,YAAQ,oBAAO;AACjB,CAAC;",
+  "names": []
+}

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

@@ -18,13 +18,15 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var inboxes_tests_exports = {};
 __export(inboxes_tests_exports, {
-  inboxTests: () => inboxTests
+  inboxTests: () => inboxTests,
+  inboxUnitTests: () => inboxUnitTests
 });
 module.exports = __toCommonJS(inboxes_tests_exports);
 var import_vitest = require("vitest");
 var import_inboxes = require("./4-inboxes");
 var import_utilities = require("./utilities");
 var import_utils = require("@noble/hashes/utils.js");
+var import_api = require("@graffiti-garden/api");
 var import_dag_cbor = require("@ipld/dag-cbor");
 function inboxTests(inboxEndpoint, inboxToken) {
   (0, import_vitest.describe)("Inboxes", async () => {
@@ -49,10 +51,10 @@ function inboxTests(inboxEndpoint, inboxToken) {
         t: tags
       };
       const messageId = await inboxes.send(inboxEndpoint, sending);
-      const message = await inboxes.get(inboxEndpoint, messageId, inboxToken);
-      (0, import_vitest.assert)(message !== null);
-      (0, import_vitest.expect)(message.m).toEqual(sending);
-      (0, import_vitest.expect)(message.l).toEqual(0);
+      const message2 = await inboxes.get(inboxEndpoint, messageId, inboxToken);
+      (0, import_vitest.assert)(message2 !== null);
+      (0, import_vitest.expect)(message2.m).toEqual(sending);
+      (0, import_vitest.expect)(message2.l).toEqual(0);
       const iterator = inboxes.query(inboxEndpoint, tags, {}, inboxToken);
       const result = await iterator.next();
       (0, import_vitest.assert)(!result.done);
@@ -69,10 +71,10 @@ function inboxTests(inboxEndpoint, inboxToken) {
       (0, import_vitest.expect)(result2.value.l).toEqual(42);
       const endResult2 = await iterator2.next();
       (0, import_vitest.expect)(endResult2.done).toBe(true);
-      const message2 = await inboxes.get(inboxEndpoint, messageId, inboxToken);
-      (0, import_vitest.assert)(message2 !== null);
-      (0, import_vitest.expect)(message2.m).toEqual(sending);
-      (0, import_vitest.expect)(message2.l).toEqual(42);
+      const message22 = await inboxes.get(inboxEndpoint, messageId, inboxToken);
+      (0, import_vitest.assert)(message22 !== null);
+      (0, import_vitest.expect)(message22.m).toEqual(sending);
+      (0, import_vitest.expect)(message22.l).toEqual(42);
     });
     (0, import_vitest.test)("query with continue", async () => {
       const tags = [(0, import_utils.randomBytes)(), (0, import_utils.randomBytes)()];
@@ -164,4 +166,332 @@ function inboxTests(inboxEndpoint, inboxToken) {
     }, 1e5);
   });
 }
+const inboxUrl = "https://example.test/inbox";
+const message = {
+  id: "message-1",
+  m: {
+    t: [new Uint8Array([1])],
+    o: {
+      url: "https://example.test/object",
+      actor: "did:example:author",
+      channels: ["test"],
+      value: {}
+    },
+    m: new Uint8Array([2])
+  },
+  l: 0
+};
+function cborResponse(value) {
+  return new Response(new Uint8Array((0, import_dag_cbor.encode)(value)).slice(), {
+    headers: { "Content-Type": "application/cbor" }
+  });
+}
+function queryPage(results, cursor, hasMore = false) {
+  return cborResponse({ results, hasMore, cursor });
+}
+class TestInboxes extends import_inboxes.Inboxes {
+  async prepareCache() {
+    await this.cache;
+  }
+  async deleteCachedQuery(key) {
+    await (await this.cache).messageIds.del(key);
+  }
+  async fetchQueryBatch() {
+    const batch = await this.fetchMessageBatch(
+      "https://example.test/inbox",
+      "query",
+      void 0
+    );
+    await batch.response.arrayBuffer();
+    return batch;
+  }
+}
+function enableLockPath(request) {
+  import_vitest.vi.stubGlobal("indexedDB", {
+    open: () => {
+      const probe = {};
+      queueMicrotask(() => {
+        probe.result = { close() {
+        } };
+        probe.onsuccess?.();
+      });
+      return probe;
+    }
+  });
+  import_vitest.vi.stubGlobal("window", { navigator: { locks: { request } } });
+}
+function inboxUnitTests() {
+  (0, import_vitest.describe)("Inboxes unit", () => {
+    (0, import_vitest.afterEach)(() => {
+      import_vitest.vi.unstubAllGlobals();
+      import_vitest.vi.restoreAllMocks();
+    });
+    (0, import_vitest.describe)("inbox stream lock and network failures", () => {
+      (0, import_vitest.test)("backs off for five seconds after an initial request failure", async () => {
+        const failure = new Error("offline");
+        const fetch2 = import_vitest.vi.fn(() => Promise.reject(failure));
+        import_vitest.vi.stubGlobal("fetch", fetch2);
+        import_vitest.vi.spyOn(console, "error").mockImplementation(() => {
+        });
+        const realSetTimeout = globalThis.setTimeout;
+        const timer = import_vitest.vi.spyOn(globalThis, "setTimeout").mockImplementation(
+          ((handler, delay, ...args) => realSetTimeout(
+            handler,
+            delay === 5e3 ? 0 : delay,
+            ...args
+          ))
+        );
+        await (0, import_vitest.expect)(new import_inboxes.Inboxes().query(inboxUrl, [], {}).next()).rejects.toBe(
+          failure
+        );
+        (0, import_vitest.expect)(fetch2).toHaveBeenCalledOnce();
+        (0, import_vitest.expect)(timer).toHaveBeenCalledWith(import_vitest.expect.any(Function), 5e3);
+      });
+      (0, import_vitest.test)("a rejected lock request rejects the stream", async () => {
+        const inboxes = new TestInboxes();
+        await inboxes.prepareCache();
+        const error = new Error("lock request failed");
+        enableLockPath(import_vitest.vi.fn(() => Promise.reject(error)));
+        await (0, import_vitest.expect)(
+          inboxes.query("https://example.test/inbox", [], {}).next()
+        ).rejects.toBe(error);
+      });
+      (0, import_vitest.test)("waiting for another tab's lock has a deadline", async () => {
+        const inboxes = new TestInboxes();
+        await inboxes.prepareCache();
+        const timeoutError = new DOMException("timed out", "TimeoutError");
+        import_vitest.vi.spyOn(AbortSignal, "timeout").mockReturnValue(
+          AbortSignal.abort(timeoutError)
+        );
+        const request = import_vitest.vi.fn(
+          (_key, _options) => Promise.reject(timeoutError)
+        );
+        enableLockPath(request);
+        await (0, import_vitest.expect)(
+          inboxes.query("https://example.test/inbox", [], {}).next()
+        ).rejects.toThrow("Timed out waiting for another tab's inbox query");
+        (0, import_vitest.expect)(request).toHaveBeenCalledOnce();
+      });
+      (0, import_vitest.test)("a stalled request is aborted", async () => {
+        const realTimeout = AbortSignal.timeout;
+        import_vitest.vi.spyOn(AbortSignal, "timeout").mockImplementation(() => realTimeout(5));
+        import_vitest.vi.stubGlobal(
+          "fetch",
+          import_vitest.vi.fn(
+            (_url, options) => new Promise((_resolve, reject) => {
+              const signal = options.signal;
+              signal.addEventListener("abort", () => reject(signal.reason), {
+                once: true
+              });
+            })
+          )
+        );
+        await (0, import_vitest.expect)(new TestInboxes().fetchQueryBatch()).rejects.toMatchObject({
+          name: "TimeoutError"
+        });
+      });
+      (0, import_vitest.test)("the deadline remains active while reading a response body", async () => {
+        const realTimeout = AbortSignal.timeout;
+        import_vitest.vi.spyOn(AbortSignal, "timeout").mockImplementation(() => realTimeout(5));
+        import_vitest.vi.stubGlobal(
+          "fetch",
+          import_vitest.vi.fn((_url, options) => {
+            const signal = options.signal;
+            const body = new ReadableStream({
+              start(controller) {
+                signal.addEventListener("abort", () => controller.error(signal.reason), {
+                  once: true
+                });
+              }
+            });
+            return Promise.resolve(new Response(body));
+          })
+        );
+        await (0, import_vitest.expect)(new TestInboxes().fetchQueryBatch()).rejects.toMatchObject({
+          name: "TimeoutError"
+        });
+      });
+    });
+    (0, import_vitest.describe)("inbox query cache", () => {
+      (0, import_vitest.test)("fetches the next page while the current message is yielded", async () => {
+        const inboxes = new TestInboxes();
+        await inboxes.prepareCache();
+        let held = 0;
+        enableLockPath(import_vitest.vi.fn(async (key, _options, callback) => {
+          held++;
+          try {
+            return await callback({ name: key, mode: "exclusive" });
+          } finally {
+            held--;
+          }
+        }));
+        let prefetchAborted = false;
+        const fetch2 = import_vitest.vi.fn((_url, options) => {
+          if (fetch2.mock.calls.length === 1) {
+            return Promise.resolve(queryPage([message], "cursor-1", true));
+          }
+          return new Promise((_resolve, reject) => {
+            const signal = options.signal;
+            signal.addEventListener("abort", () => {
+              prefetchAborted = true;
+              reject(signal.reason);
+            }, { once: true });
+          });
+        });
+        import_vitest.vi.stubGlobal("fetch", fetch2);
+        const iterator = inboxes.query(inboxUrl, [new Uint8Array([1])], {});
+        (0, import_vitest.expect)((await iterator.next()).value).toEqual(message);
+        await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(fetch2).toHaveBeenCalledTimes(2));
+        (0, import_vitest.expect)(fetch2.mock.calls[1][0]).toBe(`${inboxUrl}/query?cursor=cursor-1`);
+        await iterator.return("");
+        (0, import_vitest.expect)(prefetchAborted).toBe(true);
+        await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(held).toBe(0));
+      });
+      (0, import_vitest.test)("reports a cursor that expires after the first page", async () => {
+        const fetch2 = import_vitest.vi.fn().mockResolvedValueOnce(queryPage([message], "cursor-1", true)).mockResolvedValueOnce(new Response("stale", { status: 410 }));
+        import_vitest.vi.stubGlobal("fetch", fetch2);
+        const iterator = new import_inboxes.Inboxes().query(inboxUrl, [new Uint8Array([1])], {});
+        (0, import_vitest.expect)((await iterator.next()).value).toEqual(message);
+        await (0, import_vitest.expect)(iterator.next()).rejects.toBeInstanceOf(
+          import_api.GraffitiErrorCursorExpired
+        );
+        (0, import_vitest.expect)(fetch2).toHaveBeenCalledTimes(2);
+      });
+      (0, import_vitest.test)("does not replay messages after another tab resets the cache", async () => {
+        const inboxes = new TestInboxes();
+        await inboxes.prepareCache();
+        let markPrefetchStarted;
+        const prefetchStarted = new Promise((resolve) => {
+          markPrefetchStarted = resolve;
+        });
+        let releasePrefetch;
+        const pause = new Promise((resolve) => {
+          releasePrefetch = resolve;
+        });
+        let lockCalls = 0;
+        let cacheKey = "";
+        enableLockPath(import_vitest.vi.fn(async (name, _options, work) => {
+          cacheKey = name.slice("graffiti:inbox:".length);
+          if (++lockCalls === 2) {
+            markPrefetchStarted();
+            await pause;
+          }
+          return work({ name, mode: "exclusive" });
+        }));
+        import_vitest.vi.stubGlobal("fetch", import_vitest.vi.fn(async () => queryPage([message], "cursor-1", true)));
+        const iterator = inboxes.query(inboxUrl, [new Uint8Array([1])], {});
+        (0, import_vitest.expect)((await iterator.next()).value).toEqual(message);
+        await prefetchStarted;
+        await inboxes.deleteCachedQuery(cacheKey);
+        releasePrefetch();
+        await (0, import_vitest.expect)(iterator.next()).rejects.toBeInstanceOf(
+          import_api.GraffitiErrorCursorExpired
+        );
+      });
+      (0, import_vitest.test)("a later query reads messages from the cached server cursor", async () => {
+        const fetch2 = import_vitest.vi.fn().mockResolvedValueOnce(queryPage([message], "cursor-1")).mockResolvedValueOnce(queryPage([], "cursor-2"));
+        import_vitest.vi.stubGlobal("fetch", fetch2);
+        const inboxes = new import_inboxes.Inboxes();
+        const tags = [new Uint8Array([1])];
+        const first = inboxes.query(inboxUrl, tags, {});
+        (0, import_vitest.expect)((await first.next()).value).toEqual(message);
+        (0, import_vitest.expect)((await first.next()).done).toBe(true);
+        const second = inboxes.query(inboxUrl, tags, {});
+        (0, import_vitest.expect)((await second.next()).value).toEqual(message);
+        (0, import_vitest.expect)((await second.next()).done).toBe(true);
+        (0, import_vitest.expect)(fetch2).toHaveBeenCalledTimes(2);
+        (0, import_vitest.expect)(fetch2.mock.calls[1][0]).toBe(`${inboxUrl}/query?cursor=cursor-1`);
+      });
+      (0, import_vitest.test)("does not hold the query lock while a message is yielded", async () => {
+        const inboxes = new TestInboxes();
+        await inboxes.prepareCache();
+        let held = false;
+        enableLockPath(import_vitest.vi.fn(async (key, _options, callback) => {
+          held = true;
+          try {
+            return await callback({ name: key, mode: "exclusive" });
+          } finally {
+            held = false;
+          }
+        }));
+        import_vitest.vi.stubGlobal("fetch", import_vitest.vi.fn(async () => queryPage([message], "cursor-1")));
+        const iterator = inboxes.query(inboxUrl, [new Uint8Array([1])], {});
+        try {
+          (0, import_vitest.expect)((await iterator.next()).value).toEqual(message);
+          (0, import_vitest.expect)(held).toBe(false);
+        } finally {
+          await iterator.return("");
+        }
+      });
+      (0, import_vitest.test)("closing a yielded query leaves no lock held", async () => {
+        const inboxes = new TestInboxes();
+        await inboxes.prepareCache();
+        let held = false;
+        enableLockPath(import_vitest.vi.fn(async (key, _options, callback) => {
+          held = true;
+          try {
+            return await callback({ name: key, mode: "exclusive" });
+          } finally {
+            held = false;
+          }
+        }));
+        import_vitest.vi.stubGlobal("fetch", import_vitest.vi.fn(async () => queryPage([message], "cursor-1")));
+        const iterator = inboxes.query(inboxUrl, [new Uint8Array([1])], {});
+        (0, import_vitest.expect)((await iterator.next()).value).toEqual(message);
+        (0, import_vitest.expect)(held).toBe(false);
+        await iterator.return("");
+        (0, import_vitest.expect)(held).toBe(false);
+      });
+      (0, import_vitest.test)("concurrent queries reuse a page fetched under the lock", async () => {
+        const inboxes = new TestInboxes();
+        await inboxes.prepareCache();
+        let releasePrevious = Promise.resolve();
+        let requests = 0;
+        let bothRequested;
+        const ready = new Promise((resolve) => {
+          bothRequested = resolve;
+        });
+        enableLockPath(import_vitest.vi.fn(async (key, _options, callback) => {
+          requests++;
+          if (requests === 2) bothRequested();
+          const previous = releasePrevious;
+          let release;
+          releasePrevious = new Promise((resolve) => {
+            release = resolve;
+          });
+          await previous;
+          try {
+            return await callback({ name: key, mode: "exclusive" });
+          } finally {
+            release();
+          }
+        }));
+        const nextMessage = { ...message, id: "message-2" };
+        const fetch2 = import_vitest.vi.fn(async () => {
+          await ready;
+          return fetch2.mock.calls.length === 1 ? queryPage([message], "cursor-1", true) : queryPage([nextMessage], "cursor-2");
+        });
+        import_vitest.vi.stubGlobal("fetch", fetch2);
+        const tags = [new Uint8Array([1])];
+        const first = inboxes.query(inboxUrl, tags, {});
+        const second = inboxes.query(inboxUrl, tags, {});
+        const [firstResult, secondResult] = await Promise.all([
+          first.next(),
+          second.next()
+        ]);
+        (0, import_vitest.expect)(firstResult.value).toEqual(message);
+        (0, import_vitest.expect)(secondResult.value).toEqual(message);
+        const [firstNext, secondNext] = await Promise.all([
+          first.next(),
+          second.next()
+        ]);
+        (0, import_vitest.expect)(firstNext.value).toEqual(nextMessage);
+        (0, import_vitest.expect)(secondNext.value).toEqual(nextMessage);
+        (0, import_vitest.expect)(fetch2).toHaveBeenCalledTimes(2);
+        (0, import_vitest.expect)((await first.next()).done).toBe(true);
+        (0, import_vitest.expect)((await second.next()).done).toBe(true);
+      });
+    });
+  });
+}
 //# sourceMappingURL=4-inboxes-tests.js.map