@keepkit/core 0.28.3 → 0.28.5

package/dist/{chunk-MZFZQIM5.js → chunk-NZLAW4LY.js}

@@ -81,6 +81,12 @@ function isKeepItem(value) {
 function isKeepItemArray(value) {
   return Array.isArray(value) && value.every(isKeepItem);
 }
+function isKeepCollectionDefinition(value) {
+  return isRecord(value) && typeof value.id === "string" && value.id.trim().length > 0 && typeof value.name === "string" && value.name.trim().length > 0 && (value.scope === void 0 || isSyncScope(value.scope));
+}
+function isKeepCollectionMembership(value) {
+  return isRecord(value) && typeof value.collectionId === "string" && value.collectionId.trim().length > 0 && typeof value.itemId === "string" && value.itemId.trim().length > 0 && typeof value.order === "number" && Number.isInteger(value.order) && Number.isFinite(value.order) && value.order >= 0 && (value.scope === void 0 || isSyncScope(value.scope));
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -102,6 +108,28 @@ var ScopedStorageAdapter = class {
     this.scope = scope;
     const scopeKey = getKeepScopeKey(scope);
     this.storageKey = base.storageKey ? base.storageKey.endsWith(scopeKey) && scopeKey ? base.storageKey : `${base.storageKey}${scopeKey}` : void 0;
+    if (base.getCollections && base.setCollection && base.removeCollection) {
+      const getCollections = base.getCollections.bind(base);
+      const setCollection = base.setCollection.bind(base);
+      const removeCollection = base.removeCollection.bind(base);
+      this.getCollections = async () => {
+        const collections = await getCollections();
+        return this.scope ? collections.filter((collection) => isSameKeepScope(collection.scope, this.scope)) : collections;
+      };
+      this.setCollection = (collection) => setCollection({ ...collection, ...this.scope ? { scope: this.scope } : {} });
+      this.removeCollection = (id) => removeCollection(id, this.scope);
+    }
+    if (base.getCollectionMemberships && base.setCollectionMembership && base.removeCollectionMembership) {
+      const getMemberships = base.getCollectionMemberships.bind(base);
+      const setMembership = base.setCollectionMembership.bind(base);
+      const removeMembership = base.removeCollectionMembership.bind(base);
+      this.getCollectionMemberships = async () => {
+        const memberships = await getMemberships();
+        return this.scope ? memberships.filter((membership) => isSameKeepScope(membership.scope, this.scope)) : memberships;
+      };
+      this.setCollectionMembership = (membership) => setMembership({ ...membership, ...this.scope ? { scope: this.scope } : {} });
+      this.removeCollectionMembership = (collectionId, itemId) => removeMembership(collectionId, itemId, this.scope);
+    }
   }
   async getAll() {
     const items = await this.base.getAll();
@@ -211,7 +239,7 @@ var LocalStorageSyncQueueAdapter = class {
     } catch (cause) {
       throw Object.assign(new Error("KeepKit sync queue contains invalid JSON."), { cause });
     }
-    if (!Array.isArray(value) || !value.every(isSyncOperation)) {
+    if (!Array.isArray(value) || !value.every(isSyncQueueOperation)) {
       throw new Error("KeepKit sync queue contains invalid operations.");
     }
     return value;
@@ -241,7 +269,7 @@ var IndexedDBSyncQueueAdapter = class {
     if (!database) return [];
     const transaction = database.transaction(this.storeName, "readonly");
     const value = await requestToPromise(transaction.objectStore(this.storeName).getAll());
-    if (!Array.isArray(value) || !value.every(isSyncOperation)) {
+    if (!Array.isArray(value) || !value.every(isSyncQueueOperation)) {
       throw new Error("KeepKit sync queue contains invalid operations.");
     }
     return value;
@@ -362,6 +390,69 @@ var SyncStorageAdapter = class {
     this.retryDelayMs = Math.max(0, options.retryDelayMs ?? 0);
     this.retryBackoff = Math.max(1, options.retryBackoff ?? 2);
     this.storageKey = this.local.storageKey;
+    if (this.local.getCollections && this.local.setCollection && this.local.removeCollection) {
+      const getCollections = this.local.getCollections.bind(this.local);
+      const setCollection = this.local.setCollection.bind(this.local);
+      const removeCollection = this.local.removeCollection.bind(this.local);
+      this.getCollections = async () => {
+        const collections = await getCollections();
+        const scope = this.scope;
+        return scope ? collections.filter((collection) => sameScope(collection.scope, scope)) : collections;
+      };
+      this.setCollection = async (collection) => {
+        const scopedCollection = { ...collection, ...this.scope ? { scope: this.scope } : {} };
+        if (this.remote.pushCollection) {
+          const operation = this.createCollectionOperation("upsert", scopedCollection.id, scopedCollection);
+          await this.enqueueBeforeLocalWrite(operation);
+          try {
+            await setCollection(scopedCollection);
+          } catch (cause) {
+            await this.removeQueued(operation.operationId);
+            throw cause;
+          }
+          this.notifyDataListeners();
+          this.setPendingState();
+          return;
+        }
+        await setCollection(scopedCollection);
+        this.notifyDataListeners();
+      };
+      this.removeCollection = async (id) => {
+        if (this.remote.pushCollection) {
+          const operation = this.createCollectionOperation("remove", id);
+          await this.enqueueBeforeLocalWrite(operation);
+          try {
+            await removeCollection(id, this.scope);
+          } catch (cause) {
+            await this.removeQueued(operation.operationId);
+            throw cause;
+          }
+          this.notifyDataListeners();
+          this.setPendingState();
+          return;
+        }
+        await removeCollection(id, this.scope);
+        this.notifyDataListeners();
+      };
+    }
+    if (this.local.getCollectionMemberships && this.local.setCollectionMembership && this.local.removeCollectionMembership) {
+      const getMemberships = this.local.getCollectionMemberships.bind(this.local);
+      const setMembership = this.local.setCollectionMembership.bind(this.local);
+      const removeMembership = this.local.removeCollectionMembership.bind(this.local);
+      this.getCollectionMemberships = async () => {
+        const memberships = await getMemberships();
+        const scope = this.scope;
+        return scope ? memberships.filter((membership) => sameScope(membership.scope, scope)) : memberships;
+      };
+      this.setCollectionMembership = async (membership) => {
+        await setMembership({ ...membership, ...this.scope ? { scope: this.scope } : {} });
+        this.notifyDataListeners();
+      };
+      this.removeCollectionMembership = async (collectionId, itemId) => {
+        await removeMembership(collectionId, itemId, this.scope);
+        this.notifyDataListeners();
+      };
+    }
     if (typeof window !== "undefined") {
       this.onlineHandler = () => void this.flushSync();
       window.addEventListener("online", this.onlineHandler);
@@ -496,6 +587,16 @@ var SyncStorageAdapter = class {
     for (const operation of [...this.queueItems]) {
       if (this.disposed) return;
       try {
+        if (isCollectionSyncOperation(operation)) {
+          if (!this.remote.pushCollection) throw new Error("Remote sync driver does not support collection sync.");
+          await this.pushCollectionWithRetry(operation);
+          await this.removeQueued(operation.operationId);
+          this.updateState({
+            status: this.queueItems.length > 0 ? "syncing" : "synced",
+            lastSyncedAt: this.now()
+          });
+          continue;
+        }
         const result = await this.pushWithRetry(operation);
         if (result.type === "conflict") {
           const local = operation.item;
@@ -560,6 +661,17 @@ var SyncStorageAdapter = class {
       ...this.scope ? { scope: this.scope } : {}
     };
   }
+  createCollectionOperation(type, id, collection) {
+    return {
+      operationId: `${this.clientId}:${this.now()}:${createId()}`,
+      type,
+      entity: "collection",
+      id,
+      ...collection ? { collection } : {},
+      createdAt: this.now(),
+      ...this.scope ? { scope: this.scope } : {}
+    };
+  }
   applyScope(item) {
     return this.scope ? { ...item, scope: this.scope } : item;
   }
@@ -576,6 +688,20 @@ var SyncStorageAdapter = class {
       }
     }
   }
+  async pushCollectionWithRetry(operation) {
+    let attempt = 0;
+    while (true) {
+      try {
+        await this.remote.pushCollection?.({ ...operation, attempts: attempt });
+        return;
+      } catch (error) {
+        if (isKeepSyncAuthError(error) || attempt >= this.maxRetries) throw error;
+        attempt += 1;
+        const delay = this.retryDelayMs * this.retryBackoff ** (attempt - 1);
+        if (delay > 0) await wait(delay);
+      }
+    }
+  }
   async enqueueBeforeLocalWrite(operation) {
     await this.enqueueManyBeforeLocalWrite([operation]);
   }
@@ -584,7 +710,8 @@ var SyncStorageAdapter = class {
     const next = [...this.queueItems];
     for (const operation of operations) {
       for (let index = next.length - 1; index >= 0; index -= 1) {
-        if (next[index]?.id !== operation.id) continue;
+        const queued = next[index];
+        if (!queued || getQueueIdentity(queued) !== getQueueIdentity(operation)) continue;
         next.splice(index, 1);
       }
       next.push(operation);
@@ -644,30 +771,53 @@ var SyncStorageAdapter = class {
     });
   }
   async pullRemote() {
-    if (!this.remote.pull) return true;
+    if (!this.remote.pull && !this.remote.pullCollections) return true;
     try {
-      const remoteItems = await this.remote.pull();
-      const pendingIds = new Set(this.queueItems.map((operation) => operation.id));
-      const localItems = await this.getAll();
-      const localById = new Map(localItems.map((item) => [item.id, item]));
-      const remoteById = /* @__PURE__ */ new Map();
-      for (const item of remoteItems) {
-        if (this.scope && item.scope && !sameScope(item.scope, this.scope)) continue;
-        if (pendingIds.has(item.id)) continue;
-        const previous = remoteById.get(item.id);
-        remoteById.set(item.id, previous ? mergeKeepItemLists([item], [previous])[0] ?? item : item);
+      if (this.remote.pull) {
+        const remoteItems = await this.remote.pull();
+        const pendingIds = new Set(
+          this.queueItems.filter((operation) => operation.entity !== "collection").map((operation) => operation.id)
+        );
+        const localItems = await this.getAll();
+        const localById = new Map(localItems.map((item) => [item.id, item]));
+        const remoteById = /* @__PURE__ */ new Map();
+        for (const item of remoteItems) {
+          if (this.scope && item.scope && !sameScope(item.scope, this.scope)) continue;
+          if (pendingIds.has(item.id)) continue;
+          const previous = remoteById.get(item.id);
+          remoteById.set(item.id, previous ? mergeKeepItemLists([item], [previous])[0] ?? item : item);
+        }
+        const incoming = [...remoteById.values()].flatMap((item) => {
+          const current = localById.get(item.id);
+          if (current && item.updatedAt < current.updatedAt && (item.lastOpenedAt ?? 0) <= (current.lastOpenedAt ?? 0)) {
+            return [];
+          }
+          const merged = current ? mergeKeepItemLists([item], [current])[0] ?? item : item;
+          return [this.applyScope(merged)];
+        });
+        if (incoming.length > 0) {
+          await persistKeepItems(this.local, incoming);
+          this.notifyDataListeners();
+        }
       }
-      const incoming = [...remoteById.values()].flatMap((item) => {
-        const current = localById.get(item.id);
-        if (current && item.updatedAt < current.updatedAt && (item.lastOpenedAt ?? 0) <= (current.lastOpenedAt ?? 0)) {
-          return [];
+      if (this.remote.pullCollections && this.local.getCollections && this.local.setCollection && this.local.removeCollection) {
+        const remoteCollections = await this.remote.pullCollections();
+        const localCollections = await this.local.getCollections();
+        const pendingIds = new Set(this.queueItems.filter(isCollectionSyncOperation).map((operation) => operation.id));
+        const remoteById = new Map(
+          remoteCollections.filter((collection) => !this.scope || sameScope(collection.scope, this.scope)).map((collection) => [collection.id, collection])
+        );
+        for (const collection of remoteById.values()) {
+          if (pendingIds.has(collection.id)) continue;
+          await this.local.setCollection({ ...collection, ...this.scope ? { scope: this.scope } : {} });
         }
-        const merged = current ? mergeKeepItemLists([item], [current])[0] ?? item : item;
-        return [this.applyScope(merged)];
-      });
-      if (incoming.length === 0) return true;
-      await persistKeepItems(this.local, incoming);
-      this.notifyDataListeners();
+        for (const collection of localCollections) {
+          if (pendingIds.has(collection.id) || remoteById.has(collection.id)) continue;
+          if (this.scope && !sameScope(collection.scope, this.scope)) continue;
+          await this.local.removeCollection(collection.id, this.scope);
+        }
+        this.notifyDataListeners();
+      }
       return true;
     } catch (error) {
       this.updateState({ status: "error", error });
@@ -688,7 +838,17 @@ var SyncStorageAdapter = class {
 };
 function isSyncOperation(value) {
   if (!isRecord(value)) return false;
-  return typeof value.operationId === "string" && (value.type === "upsert" || value.type === "remove") && typeof value.id === "string" && typeof value.createdAt === "number";
+  return typeof value.operationId === "string" && (value.type === "upsert" || value.type === "remove") && typeof value.id === "string" && typeof value.createdAt === "number" && (value.entity === void 0 || value.entity === "item" || value.entity === "collection") && (value.collection === void 0 || isKeepCollectionDefinition(value.collection)) && (value.entity !== "collection" || value.type !== "upsert" || isKeepCollectionDefinition(value.collection));
+}
+function isCollectionSyncOperation(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.operationId === "string" && value.entity === "collection" && (value.type === "upsert" || value.type === "remove") && typeof value.id === "string" && typeof value.createdAt === "number" && (value.collection === void 0 || isKeepCollectionDefinition(value.collection));
+}
+function isSyncQueueOperation(value) {
+  return isSyncOperation(value) || isCollectionSyncOperation(value);
+}
+function getQueueIdentity(operation) {
+  return `${operation.entity === "collection" ? "collection" : "item"}:${operation.id}`;
 }
 function createId() {
   if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
@@ -771,6 +931,45 @@ var FallbackStorageAdapter = class {
     this.migrateFallbackOnEmpty = options.migrateFallbackOnEmpty ?? false;
     this.mirrorWrites = options.mirrorWrites ?? false;
     this.storageKey = options.fallback.storageKey ?? options.primary.storageKey;
+    if (this.primary.getCollections && this.primary.setCollection && this.primary.removeCollection && this.fallback.getCollections && this.fallback.setCollection && this.fallback.removeCollection) {
+      const fallbackGetCollections = this.fallback.getCollections.bind(this.fallback);
+      this.getCollections = async () => {
+        const collections = await this.execute((adapter) => {
+          if (!adapter.getCollections) throw new Error("Collection storage is unavailable.");
+          return adapter.getCollections();
+        });
+        if (this.active === "primary" && this.migrateFallbackOnEmpty && collections.length === 0) {
+          const fallbackCollections = await fallbackGetCollections();
+          for (const collection of fallbackCollections) await this.setCollection?.(collection);
+          return fallbackCollections;
+        }
+        return collections;
+      };
+      this.setCollection = (collection) => this.executeWrite((adapter) => {
+        if (!adapter.setCollection) throw new Error("Collection storage is unavailable.");
+        return adapter.setCollection(collection);
+      });
+      this.removeCollection = (id, scope) => this.executeWrite((adapter) => {
+        if (!adapter.removeCollection) throw new Error("Collection storage is unavailable.");
+        return adapter.removeCollection(id, scope);
+      });
+    }
+    if (this.primary.getCollectionMemberships && this.primary.setCollectionMembership && this.primary.removeCollectionMembership && this.fallback.getCollectionMemberships && this.fallback.setCollectionMembership && this.fallback.removeCollectionMembership) {
+      const fallbackGetMemberships = this.fallback.getCollectionMemberships.bind(this.fallback);
+      this.getCollectionMemberships = async () => {
+        const memberships = await this.execute(
+          (adapter) => adapter.getCollectionMemberships?.() ?? Promise.resolve([])
+        );
+        if (this.active !== "primary" || !this.migrateFallbackOnEmpty || memberships.length > 0) return memberships;
+        const fallbackMemberships = await fallbackGetMemberships();
+        for (const membership of fallbackMemberships) await this.setCollectionMembership?.(membership);
+        return fallbackMemberships;
+      };
+      this.setCollectionMembership = (membership) => this.executeWrite((adapter) => adapter.setCollectionMembership?.(membership) ?? Promise.resolve());
+      this.removeCollectionMembership = (collectionId, itemId, scope) => this.executeWrite(
+        (adapter) => adapter.removeCollectionMembership?.(collectionId, itemId, scope) ?? Promise.resolve()
+      );
+    }
   }
   get isUsingFallback() {
     return this.active === "fallback";
@@ -895,8 +1094,24 @@ function createStorageAdapter(options) {
   const subscribe = options.subscribe;
   const setMany = options.setMany;
   const removeMany = options.removeMany;
+  const getCollections = options.getCollections;
+  const setCollection = options.setCollection;
+  const removeCollection = options.removeCollection;
+  const getCollectionMemberships = options.getCollectionMemberships;
+  const setCollectionMembership = options.setCollectionMembership;
+  const removeCollectionMembership = options.removeCollectionMembership;
   return {
     getAll: async () => options.getAll(),
+    ...getCollections && setCollection && removeCollection ? {
+      getCollections: async () => getCollections(),
+      setCollection: async (collection) => setCollection(collection),
+      removeCollection: async (id, scope) => removeCollection(id, scope)
+    } : {},
+    ...getCollectionMemberships && setCollectionMembership && removeCollectionMembership ? {
+      getCollectionMemberships: async () => getCollectionMemberships(),
+      setCollectionMembership: async (membership) => setCollectionMembership(membership),
+      removeCollectionMembership: async (collectionId, itemId, scope) => removeCollectionMembership(collectionId, itemId, scope)
+    } : {},
     set: async (item) => options.set(item),
     ...setMany ? { setMany: async (items) => setMany(items) } : {},
     remove: async (id) => options.remove(id),
@@ -945,6 +1160,86 @@ var LocalStorageAdapter = class {
       });
     }
   }
+  async getCollections() {
+    if (!this.storage) return [];
+    const storageKey = `${this.storageKey}:collections`;
+    let raw;
+    try {
+      raw = this.storage.getItem(storageKey);
+    } catch (cause) {
+      throw new KeepStorageAccessError({ operation: "getAll", storageKey, cause });
+    }
+    if (!raw) return [];
+    try {
+      const value = JSON.parse(raw);
+      if (!Array.isArray(value) || !value.every(isKeepCollectionDefinition)) {
+        throw new KeepStorageParseError({ operation: "getAll", storageKey });
+      }
+      return value;
+    } catch (cause) {
+      if (cause instanceof KeepStorageParseError) throw cause;
+      throw new KeepStorageParseError({ operation: "getAll", storageKey, cause });
+    }
+  }
+  async setCollection(collection) {
+    if (!isKeepCollectionDefinition(collection)) throw new Error("Collection id and name are required.");
+    const current = await this.getCollections();
+    await this.writeCollections(
+      [
+        ...current.filter((entry) => entry.id !== collection.id || !isSameKeepScope(entry.scope, collection.scope)),
+        collection
+      ],
+      "set"
+    );
+  }
+  async removeCollection(id, scope) {
+    const current = await this.getCollections();
+    await this.writeCollections(
+      current.filter((entry) => entry.id !== id || !isSameKeepScope(entry.scope, scope)),
+      "remove"
+    );
+    const memberships = await this.getCollectionMemberships();
+    await this.writeMemberships(
+      memberships.filter((membership) => membership.collectionId !== id || !isSameKeepScope(membership.scope, scope)),
+      "remove"
+    );
+  }
+  async getCollectionMemberships() {
+    if (!this.storage) return [];
+    const storageKey = `${this.storageKey}:memberships`;
+    let raw;
+    try {
+      raw = this.storage.getItem(storageKey);
+    } catch (cause) {
+      throw new KeepStorageAccessError({ operation: "getAll", storageKey, cause });
+    }
+    if (!raw) return [];
+    try {
+      const value = JSON.parse(raw);
+      if (!Array.isArray(value) || !value.every(isKeepCollectionMembership)) {
+        throw new KeepStorageParseError({ operation: "getAll", storageKey });
+      }
+      return value;
+    } catch (cause) {
+      if (cause instanceof KeepStorageParseError) throw cause;
+      throw new KeepStorageParseError({ operation: "getAll", storageKey, cause });
+    }
+  }
+  async setCollectionMembership(membership) {
+    if (!isKeepCollectionMembership(membership)) throw new Error("Collection membership is invalid.");
+    const current = await this.getCollectionMemberships();
+    const sameMembership = (entry) => entry.collectionId === membership.collectionId && entry.itemId === membership.itemId && isSameKeepScope(entry.scope, membership.scope);
+    await this.writeMemberships([...current.filter((entry) => !sameMembership(entry)), membership], "set");
+  }
+  async removeCollectionMembership(collectionId, itemId, scope) {
+    const current = await this.getCollectionMemberships();
+    await this.writeMemberships(
+      current.filter(
+        (entry) => entry.collectionId !== collectionId || entry.itemId !== itemId || !isSameKeepScope(entry.scope, scope)
+      ),
+      "remove"
+    );
+  }
   async set(item) {
     await this.setMany([item]);
   }
@@ -985,7 +1280,8 @@ var LocalStorageAdapter = class {
   subscribe(listener) {
     if (typeof window === "undefined") return () => void 0;
     const handleStorage = (event) => {
-      if (event.key !== null && event.key !== this.storageKey) return;
+      if (event.key !== null && event.key !== this.storageKey && event.key !== `${this.storageKey}:collections` && event.key !== `${this.storageKey}:memberships`)
+        return;
       listener();
     };
     window.addEventListener("storage", handleStorage);
@@ -1010,6 +1306,26 @@ var LocalStorageAdapter = class {
       });
     }
   }
+  async writeCollections(collections, operation) {
+    if (!this.storage) return;
+    const storageKey = `${this.storageKey}:collections`;
+    try {
+      this.storage.setItem(storageKey, JSON.stringify(collections));
+    } catch (cause) {
+      if (isQuotaExceededError(cause)) throw new KeepStorageQuotaError({ operation, storageKey, cause });
+      throw new KeepStorageAccessError({ operation, storageKey, cause });
+    }
+  }
+  async writeMemberships(memberships, operation) {
+    if (!this.storage) return;
+    const storageKey = `${this.storageKey}:memberships`;
+    try {
+      this.storage.setItem(storageKey, JSON.stringify(memberships));
+    } catch (cause) {
+      if (isQuotaExceededError(cause)) throw new KeepStorageQuotaError({ operation, storageKey, cause });
+      throw new KeepStorageAccessError({ operation, storageKey, cause });
+    }
+  }
 };
 var IndexedDBAdapter = class {
   constructor(options = {}) {
@@ -1034,6 +1350,64 @@ var IndexedDBAdapter = class {
       throw new KeepStorageAccessError({ operation: "getAll", storageKey: this.storageKey, cause });
     }
   }
+  async getCollections() {
+    const database = await this.openCollections("getAll");
+    if (!database) return [];
+    const storageKey = `${this.storageKey}:collections`;
+    try {
+      const transaction = database.transaction("collections", "readonly");
+      const value = await requestToPromise2(transaction.objectStore("collections").getAll());
+      if (!Array.isArray(value) || !value.every((entry) => isRecord(entry) && typeof entry.key === "string" && isKeepCollectionDefinition(entry))) {
+        throw new KeepStorageParseError({ operation: "getAll", storageKey });
+      }
+      return value.map(({ key: _key, ...collection }) => collection);
+    } catch (cause) {
+      if (cause instanceof KeepStorageParseError) throw cause;
+      throw new KeepStorageAccessError({ operation: "getAll", storageKey, cause });
+    }
+  }
+  async setCollection(collection) {
+    if (!isKeepCollectionDefinition(collection)) throw new Error("Collection id and name are required.");
+    await this.writeCollection(
+      "set",
+      (store) => store.put({ ...collection, key: collectionKey(collection.id, collection.scope) })
+    );
+  }
+  async removeCollection(id, scope) {
+    await this.writeCollection("remove", (store) => store.delete(collectionKey(id, scope)));
+    const memberships = await this.getCollectionMemberships();
+    for (const membership of memberships) {
+      if (membership.collectionId === id && isSameKeepScope(membership.scope, scope)) {
+        await this.removeCollectionMembership(id, membership.itemId, scope);
+      }
+    }
+  }
+  async getCollectionMemberships() {
+    const database = await this.openCollections("getAll");
+    if (!database) return [];
+    const storageKey = `${this.storageKey}:memberships`;
+    try {
+      const transaction = database.transaction("memberships", "readonly");
+      const value = await requestToPromise2(transaction.objectStore("memberships").getAll());
+      if (!Array.isArray(value) || !value.every((entry) => isRecord(entry) && typeof entry.key === "string" && isKeepCollectionMembership(entry))) {
+        throw new KeepStorageParseError({ operation: "getAll", storageKey });
+      }
+      return value.map(({ key: _key, ...membership }) => membership);
+    } catch (cause) {
+      if (cause instanceof KeepStorageParseError) throw cause;
+      throw new KeepStorageAccessError({ operation: "getAll", storageKey, cause });
+    }
+  }
+  async setCollectionMembership(membership) {
+    if (!isKeepCollectionMembership(membership)) throw new Error("Collection membership is invalid.");
+    await this.writeCollectionMembership(
+      "set",
+      (store) => store.put({ ...membership, key: membershipKey(membership.collectionId, membership.itemId, membership.scope) })
+    );
+  }
+  async removeCollectionMembership(collectionId, itemId, scope) {
+    await this.writeCollectionMembership("remove", (store) => store.delete(membershipKey(collectionId, itemId, scope)));
+  }
   async set(item) {
     return this.setMany([item]);
   }
@@ -1103,6 +1477,64 @@ var IndexedDBAdapter = class {
     channel.postMessage({ type: "keepkit:changed" });
     channel.close();
   }
+  async writeCollection(operation, write) {
+    const database = await this.openCollections(operation);
+    if (!database) return;
+    const storageKey = `${this.storageKey}:collections`;
+    try {
+      const transaction = database.transaction("collections", "readwrite");
+      write(transaction.objectStore("collections"));
+      await transactionToPromise2(transaction);
+      this.notifySubscribers();
+    } catch (cause) {
+      if (isQuotaExceededError(cause)) throw new KeepStorageQuotaError({ operation, storageKey, cause });
+      throw new KeepStorageAccessError({ operation, storageKey, cause });
+    }
+  }
+  async writeCollectionMembership(operation, write) {
+    const database = await this.openCollections(operation);
+    if (!database) return;
+    const storageKey = `${this.storageKey}:memberships`;
+    try {
+      const transaction = database.transaction("memberships", "readwrite");
+      write(transaction.objectStore("memberships"));
+      await transactionToPromise2(transaction);
+      this.notifySubscribers();
+    } catch (cause) {
+      if (isQuotaExceededError(cause)) throw new KeepStorageQuotaError({ operation, storageKey, cause });
+      throw new KeepStorageAccessError({ operation, storageKey, cause });
+    }
+  }
+  openCollections(operation) {
+    if (!this.indexedDB) return Promise.resolve(void 0);
+    const storageKey = `${this.storageKey}:collections`;
+    if (!this.collectionDatabasePromise) {
+      this.collectionDatabasePromise = new Promise((resolve, reject) => {
+        let request;
+        try {
+          request = this.indexedDB?.open(storageKey, 2);
+        } catch (cause) {
+          reject(cause);
+          return;
+        }
+        request.onupgradeneeded = () => {
+          if (!request.result.objectStoreNames.contains("collections")) {
+            request.result.createObjectStore("collections", { keyPath: "key" });
+          }
+          if (!request.result.objectStoreNames.contains("memberships")) {
+            request.result.createObjectStore("memberships", { keyPath: "key" });
+          }
+        };
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+        request.onblocked = () => reject(request.error ?? new Error("IndexedDB collection storage open was blocked."));
+      });
+    }
+    return this.collectionDatabasePromise.catch((cause) => {
+      this.collectionDatabasePromise = void 0;
+      throw new KeepStorageAccessError({ operation, storageKey, cause });
+    });
+  }
   open(operation) {
     if (!this.indexedDB) return Promise.resolve(void 0);
     if (!this.databasePromise) {
@@ -1131,6 +1563,12 @@ var IndexedDBAdapter = class {
     });
   }
 };
+function collectionKey(id, scope) {
+  return JSON.stringify([scope?.tenantId ?? null, scope?.userId ?? null, id]);
+}
+function membershipKey(collectionId, itemId, scope) {
+  return JSON.stringify([scope?.tenantId ?? null, scope?.userId ?? null, collectionId, itemId]);
+}
 function getBrowserStorage2() {
   if (typeof window === "undefined") return void 0;
   try {
@@ -1176,6 +1614,8 @@ export {
   removeKeepItems,
   mergeKeepItemLists,
   isKeepItem,
+  isKeepCollectionDefinition,
+  isKeepCollectionMembership,
   isRecord,
   getKeepScopeKey,
   isSameKeepScope,
@@ -1198,4 +1638,4 @@ export {
   LocalStorageAdapter,
   IndexedDBAdapter
 };
-//# sourceMappingURL=chunk-MZFZQIM5.js.map
+//# sourceMappingURL=chunk-NZLAW4LY.js.map