@keepkit/core 0.28.4 → 0.28.6

package/dist/{chunk-2TENUU7B.js → chunk-QRPQYE7K.js}

@@ -82,7 +82,10 @@ 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));
+  return isRecord(value) && typeof value.id === "string" && value.id.trim().length > 0 && typeof value.name === "string" && value.name.trim().length > 0 && (value.revision === void 0 || typeof value.revision === "string") && (value.updatedAt === void 0 || typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt)) && (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;
@@ -116,6 +119,17 @@ var ScopedStorageAdapter = class {
       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();
@@ -129,29 +143,37 @@ var ScopedStorageAdapter = class {
     const scoped = items.map((item) => ({ ...item, ...this.scope ? { scope: this.scope } : {} }));
     const ids = new Set(scoped.map((item) => item.id));
     const next = current.filter((item) => !ids.has(item.id) || !isSameKeepScope(item.scope, this.scope));
-    await writeAll(this.base, [...next, ...scoped]);
+    await writeAll(this.base, [...next, ...scoped], this.scope);
   }
   async remove(id) {
     const current = await this.base.getAll();
     await writeAll(
       this.base,
-      current.filter((item) => item.id !== id || !isSameKeepScope(item.scope, this.scope))
+      current.filter((item) => item.id !== id || !isSameKeepScope(item.scope, this.scope)),
+      this.scope
     );
+    await this.removeMembershipsForItems([id]);
   }
   async removeMany(ids) {
     const idSet = new Set(ids);
     const current = await this.base.getAll();
     await writeAll(
       this.base,
-      current.filter((item) => !idSet.has(item.id) || !isSameKeepScope(item.scope, this.scope))
+      current.filter((item) => !idSet.has(item.id) || !isSameKeepScope(item.scope, this.scope)),
+      this.scope
     );
+    await this.removeMembershipsForItems([...idSet]);
   }
   async clear() {
     const current = await this.base.getAll();
+    const removedIds = current.filter((item) => isSameKeepScope(item.scope, this.scope)).map((item) => item.id);
     await writeAll(
       this.base,
-      current.filter((item) => !isSameKeepScope(item.scope, this.scope))
+      current.filter((item) => !isSameKeepScope(item.scope, this.scope)),
+      this.scope
     );
+    if (removedIds.length > 0) await this.removeMembershipsForItems(removedIds);
+    await this.clearMembershipsForScope();
   }
   async merge(items) {
     await this.setMany(items);
@@ -160,6 +182,25 @@ var ScopedStorageAdapter = class {
   subscribe(listener) {
     return this.base.subscribe?.(listener) ?? (() => void 0);
   }
+  async removeMembershipsForItems(ids) {
+    if (!this.base.getCollectionMemberships || !this.base.removeCollectionMembership || ids.length === 0) return;
+    const removedIds = new Set(ids);
+    const memberships = await this.base.getCollectionMemberships();
+    for (const membership of memberships) {
+      if (removedIds.has(membership.itemId) && isSameKeepScope(membership.scope, this.scope)) {
+        await this.base.removeCollectionMembership(membership.collectionId, membership.itemId, this.scope);
+      }
+    }
+  }
+  async clearMembershipsForScope() {
+    if (!this.base.getCollectionMemberships || !this.base.removeCollectionMembership) return;
+    const memberships = await this.base.getCollectionMemberships();
+    for (const membership of memberships) {
+      if (isSameKeepScope(membership.scope, this.scope)) {
+        await this.base.removeCollectionMembership(membership.collectionId, membership.itemId, this.scope);
+      }
+    }
+  }
 };
 function createScopedStorageAdapter(base, scope) {
   return new ScopedStorageAdapter(base, scope);
@@ -179,32 +220,38 @@ var ScopedSyncQueueAdapter = class {
     const ids = new Set(scoped.map((operation) => operation.operationId));
     await this.base.setMany([
       ...current.filter(
-        (operation) => !ids.has(operation.operationId) && !isSameKeepScope(operation.scope, this.scope)
+        (operation) => !ids.has(operation.operationId) || !isSameKeepScope(operation.scope, this.scope)
       ),
       ...scoped
     ]);
   }
-  remove(operationIds) {
-    return this.base.remove(operationIds);
+  async remove(operationIds) {
+    const ids = new Set(operationIds);
+    const scopedIds = (await this.base.getAll()).filter((operation) => ids.has(operation.operationId) && isSameKeepScope(operation.scope, this.scope)).map((operation) => operation.operationId);
+    await this.base.remove(scopedIds);
   }
-  clear() {
-    return this.base.getAll().then(
-      (operations) => this.base.setMany(operations.filter((operation) => !isSameKeepScope(operation.scope, this.scope)))
-    );
+  async clear() {
+    const operationIds = (await this.base.getAll()).filter((operation) => isSameKeepScope(operation.scope, this.scope)).map((operation) => operation.operationId);
+    await this.base.remove(operationIds);
   }
 };
-async function writeAll(base, items) {
+async function writeAll(base, items, scope) {
+  const existing = await base.getAll();
+  const desiredItems = new Set(items.filter((item) => isSameKeepScope(item.scope, scope)).map(itemStorageKey));
+  const removedIds = existing.filter((item) => isSameKeepScope(item.scope, scope) && !desiredItems.has(itemStorageKey(item))).map((item) => item.id);
+  if (removedIds.length > 0) {
+    if (base.removeMany) await base.removeMany(removedIds, scope);
+    else await Promise.all(removedIds.map((id) => base.remove(id, scope)));
+  }
   if (base.setMany) {
     await base.setMany(items);
     return;
   }
-  const existing = await base.getAll();
-  const ids = new Set(items.map((item) => item.id));
-  for (const item of existing) {
-    if (!ids.has(item.id)) await base.remove(item.id);
-  }
   for (const item of items) await base.set(item);
 }
+function itemStorageKey(item) {
+  return JSON.stringify([item.scope?.tenantId ?? null, item.scope?.userId ?? null, item.id]);
+}
 
 // src/storage/sync.ts
 var DEFAULT_SYNC_QUEUE_KEY = "keepkit:sync-queue";
@@ -225,7 +272,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;
@@ -255,7 +302,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;
@@ -367,11 +414,12 @@ var SyncStorageAdapter = class {
     };
     this.local = options.local;
     this.remote = options.remote;
-    this.queue = options.queue ?? createDefaultQueue(options);
+    this.scope = getSyncScope(options);
+    const queue = options.queue ?? createDefaultQueue(options);
+    this.queue = this.scope ? new ScopedSyncQueueAdapter(queue, this.scope) : queue;
     this.clientId = options.clientId ?? createId();
     this.now = options.now ?? Date.now;
     this.resolveConflict = options.resolveConflict;
-    this.scope = getSyncScope(options);
     this.maxRetries = Math.max(0, options.maxRetries ?? 3);
     this.retryDelayMs = Math.max(0, options.retryDelayMs ?? 0);
     this.retryBackoff = Math.max(1, options.retryBackoff ?? 2);
@@ -385,8 +433,93 @@ var SyncStorageAdapter = class {
         const scope = this.scope;
         return scope ? collections.filter((collection) => sameScope(collection.scope, scope)) : collections;
       };
-      this.setCollection = (collection) => setCollection({ ...collection, ...this.scope ? { scope: this.scope } : {} });
-      this.removeCollection = (id) => removeCollection(id, this.scope);
+      this.setCollection = async (collection) => {
+        const scopedCollection = { ...collection, ...this.scope ? { scope: this.scope } : {} };
+        if (this.remote.pushCollection) {
+          const current = (await this.getCollections?.())?.find((entry) => entry.id === scopedCollection.id);
+          const operation = this.createCollectionOperation(
+            "upsert",
+            scopedCollection.id,
+            scopedCollection,
+            current?.revision
+          );
+          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) => {
+        const memberships = await this.getCollectionMemberships?.() ?? [];
+        const membershipOperations = this.remote.pushMembership ? memberships.filter((membership) => membership.collectionId === id).map((membership) => this.createMembershipOperation("remove", membership.collectionId, membership.itemId)) : [];
+        if (this.remote.pushCollection) {
+          const current = (await this.getCollections?.())?.find((collection) => collection.id === id);
+          const operation = this.createCollectionOperation("remove", id, void 0, current?.revision);
+          await this.enqueueManyBeforeLocalWrite([...membershipOperations, operation]);
+          try {
+            await removeCollection(id, this.scope);
+          } catch (cause) {
+            await this.removeQueued([operation.operationId, ...membershipOperations.map((entry) => entry.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) => {
+        const scoped = { ...membership, ...this.scope ? { scope: this.scope } : {} };
+        if (this.remote.pushMembership) {
+          const operation = this.createMembershipOperation("upsert", scoped.collectionId, scoped.itemId, scoped);
+          await this.enqueueBeforeLocalWrite(operation);
+          try {
+            await setMembership(scoped);
+          } catch (cause) {
+            await this.removeQueued(operation.operationId);
+            throw cause;
+          }
+          this.setPendingState();
+        } else {
+          await setMembership(scoped);
+        }
+        this.notifyDataListeners();
+      };
+      this.removeCollectionMembership = async (collectionId, itemId) => {
+        if (this.remote.pushMembership) {
+          const operation = this.createMembershipOperation("remove", collectionId, itemId);
+          await this.enqueueBeforeLocalWrite(operation);
+          try {
+            await removeMembership(collectionId, itemId, this.scope);
+          } catch (cause) {
+            await this.removeQueued(operation.operationId);
+            throw cause;
+          }
+          this.setPendingState();
+        } else {
+          await removeMembership(collectionId, itemId, this.scope);
+        }
+        this.notifyDataListeners();
+      };
     }
     if (typeof window !== "undefined") {
       this.onlineHandler = () => void this.flushSync();
@@ -428,11 +561,13 @@ var SyncStorageAdapter = class {
   }
   async remove(id) {
     const operation = this.createOperation("remove", id);
-    await this.enqueueBeforeLocalWrite(operation);
+    const memberships = await this.getCollectionMemberships?.() ?? [];
+    const membershipOperations = this.remote.pushMembership ? memberships.filter((membership) => membership.itemId === id).map((membership) => this.createMembershipOperation("remove", membership.collectionId, membership.itemId)) : [];
+    await this.enqueueManyBeforeLocalWrite([...membershipOperations, operation]);
     try {
-      await this.local.remove(id);
+      await this.local.remove(id, this.scope);
     } catch (cause) {
-      await this.removeQueued(operation.operationId);
+      await this.removeQueued([operation.operationId, ...membershipOperations.map((entry) => entry.operationId)]);
       throw cause;
     }
     this.notifyDataListeners();
@@ -440,11 +575,15 @@ var SyncStorageAdapter = class {
   }
   async removeMany(ids) {
     const operations = [...new Set(ids)].map((id) => this.createOperation("remove", id));
-    await this.enqueueManyBeforeLocalWrite(operations);
+    const idSet = new Set(ids);
+    const memberships = await this.getCollectionMemberships?.() ?? [];
+    const membershipOperations = this.remote.pushMembership ? memberships.filter((membership) => idSet.has(membership.itemId)).map((membership) => this.createMembershipOperation("remove", membership.collectionId, membership.itemId)) : [];
+    await this.enqueueManyBeforeLocalWrite([...membershipOperations, ...operations]);
     try {
-      await removeKeepItems(this.local, ids);
+      if (this.local.removeMany) await this.local.removeMany(ids, this.scope);
+      else await Promise.all(ids.map((id) => this.local.remove(id, this.scope)));
     } catch (cause) {
-      await this.removeQueued(operations.map((operation) => operation.operationId));
+      await this.removeQueued([...operations, ...membershipOperations].map((operation) => operation.operationId));
       throw cause;
     }
     this.notifyDataListeners();
@@ -453,9 +592,17 @@ var SyncStorageAdapter = class {
   async clear() {
     const items = await this.getAll();
     await this.removeMany(items.map((item) => item.id));
-    await this.local.clear();
+    if (!this.scope) await this.local.clear();
   }
   async merge(localItems) {
+    if (this.scope) {
+      const merged2 = mergeKeepItemLists(
+        await this.getAll(),
+        localItems.map((item) => this.applyScope(item))
+      );
+      await this.setMany(localItems);
+      return merged2;
+    }
     const merged = this.local.merge ? await this.local.merge(localItems) : mergeKeepItemLists(await this.local.getAll(), localItems);
     if (!this.local.merge) await persistKeepItems(this.local, merged);
     await this.setMany(localItems);
@@ -504,6 +651,47 @@ var SyncStorageAdapter = class {
     });
     if (resolution !== "remote" && this.queueItems.length > 0) await this.flushSync();
   }
+  async resolveCollectionSyncConflict(id, resolution, collection) {
+    await this.loadQueue();
+    const conflict = (this.state.collectionConflicts ?? []).find((entry) => entry.operation.id === id);
+    if (!conflict) return;
+    if (!this.local.getCollections || !this.local.setCollection || !this.local.removeCollection) {
+      throw new Error("KeepKit collection storage is unavailable.");
+    }
+    if (resolution === "remote") {
+      if (conflict.deleted) await this.local.removeCollection(id, this.scope);
+      else {
+        if (!conflict.collection) throw new Error("Remote collection conflict is missing its selected definition.");
+        await this.local.setCollection({
+          ...conflict.collection,
+          ...conflict.revision ? { revision: conflict.revision } : {},
+          ...this.scope ? { scope: this.scope } : {}
+        });
+      }
+      await this.removeQueued(conflict.operation.operationId);
+      this.updateState({
+        collectionConflicts: (this.state.collectionConflicts ?? []).filter((entry) => entry.operation.id !== id)
+      });
+      return;
+    }
+    if (collection && collection.id !== id) {
+      throw new TypeError("KeepKit collection conflict resolution must use the requested collection ID.");
+    }
+    const chosen = collection ?? (await this.getCollections?.())?.find((entry) => entry.id === id);
+    const retry = {
+      ...conflict.operation,
+      operationId: `${this.clientId}:${this.now()}:${createId()}`,
+      ...conflict.operation.type === "upsert" && chosen ? { collection: { ...chosen, ...this.scope ? { scope: this.scope } : {} } } : {},
+      createdAt: this.now(),
+      baseRevision: conflict.revision,
+      attempts: 0
+    };
+    await this.replaceQueued(conflict.operation, retry);
+    this.updateState({
+      collectionConflicts: (this.state.collectionConflicts ?? []).filter((entry) => entry.operation.id !== id)
+    });
+    await this.flushSync();
+  }
   dispose() {
     this.disposed = true;
     if (this.onlineHandler) window.removeEventListener("online", this.onlineHandler);
@@ -522,6 +710,38 @@ 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.");
+          const result2 = await this.pushCollectionWithRetry(operation);
+          if (result2?.type === "conflict" && result2.resolution === "manual") {
+            const conflict = createCollectionSyncConflict(operation, result2);
+            this.updateState({
+              status: "conflict",
+              collectionConflicts: [
+                ...(this.state.collectionConflicts ?? []).filter((entry) => entry.operation.id !== operation.id),
+                conflict
+              ]
+            });
+            continue;
+          }
+          await this.applyCollectionPushResult(operation, result2);
+          await this.removeQueued(operation.operationId);
+          this.updateState({
+            status: this.queueItems.length > 0 ? "syncing" : "synced",
+            lastSyncedAt: this.now()
+          });
+          continue;
+        }
+        if (isMembershipSyncOperation(operation)) {
+          if (!this.remote.pushMembership) throw new Error("Remote sync driver does not support membership sync.");
+          await this.pushMembershipWithRetry(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;
@@ -586,6 +806,31 @@ var SyncStorageAdapter = class {
       ...this.scope ? { scope: this.scope } : {}
     };
   }
+  createCollectionOperation(type, id, collection, baseRevision) {
+    return {
+      operationId: `${this.clientId}:${this.now()}:${createId()}`,
+      type,
+      entity: "collection",
+      id,
+      ...collection ? { collection } : {},
+      createdAt: this.now(),
+      ...baseRevision ? { baseRevision } : {},
+      ...this.scope ? { scope: this.scope } : {}
+    };
+  }
+  createMembershipOperation(type, collectionId, itemId, membership) {
+    return {
+      operationId: `${this.clientId}:${this.now()}:${createId()}`,
+      type,
+      entity: "membership",
+      id: getMembershipId(collectionId, itemId),
+      collectionId,
+      itemId,
+      ...membership ? { membership } : {},
+      createdAt: this.now(),
+      ...this.scope ? { scope: this.scope } : {}
+    };
+  }
   applyScope(item) {
     return this.scope ? { ...item, scope: this.scope } : item;
   }
@@ -602,6 +847,61 @@ var SyncStorageAdapter = class {
       }
     }
   }
+  async pushCollectionWithRetry(operation) {
+    let attempt = 0;
+    while (true) {
+      try {
+        return await this.remote.pushCollection?.({ ...operation, attempts: attempt });
+      } 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 applyCollectionPushResult(operation, result) {
+    if (!this.local.getCollections || !this.local.setCollection || !this.local.removeCollection) return;
+    if (!result) return;
+    const outcome = result.type === "conflict" ? result.resolution : "remote";
+    if (outcome === "manual") return;
+    const deleted = outcome === "local" ? operation.type === "remove" : result.deleted ?? (operation.type === "remove" && outcome === "remote");
+    if (deleted) {
+      await this.local.removeCollection(operation.id, this.scope);
+    } else if (result.type === "synced" || outcome === "remote" || outcome === "local") {
+      const current = (outcome === "local" ? operation.collection : result.collection) ?? (await this.getCollections?.())?.find((entry) => entry.id === operation.id);
+      if (!current) return;
+      await this.local.setCollection({
+        ...current,
+        ...result.revision ? { revision: result.revision } : current.revision ? { revision: current.revision } : {},
+        ...this.scope ? { scope: this.scope } : {}
+      });
+    }
+    if (result.type === "conflict") {
+      const conflict = createCollectionSyncConflict(operation, result);
+      this.updateState({
+        status: "conflict",
+        collectionConflicts: [
+          ...(this.state.collectionConflicts ?? []).filter((entry) => entry.operation.id !== operation.id),
+          conflict
+        ]
+      });
+    }
+  }
+  async pushMembershipWithRetry(operation) {
+    let attempt = 0;
+    while (true) {
+      try {
+        await this.remote.pushMembership?.({ ...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]);
   }
@@ -610,7 +910,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);
@@ -670,30 +971,79 @@ var SyncStorageAdapter = class {
     });
   }
   async pullRemote() {
-    if (!this.remote.pull) return true;
+    if (!this.remote.pull && !this.remote.pullCollections && !this.remote.pullMemberships) 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 || !collection.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();
+      }
+      if (this.remote.pullMemberships && this.getCollections && this.local.getCollectionMemberships && this.local.setCollectionMembership && this.local.removeCollectionMembership) {
+        const remoteMemberships = await this.remote.pullMemberships();
+        const localMemberships = await this.local.getCollectionMemberships();
+        const pendingIds = new Set(this.queueItems.filter(isMembershipSyncOperation).map((operation) => operation.id));
+        const itemIds = new Set((await this.getAll()).map((item) => item.id));
+        const collectionIds = new Set((await this.getCollections()).map((collection) => collection.id));
+        const remoteById = new Map(
+          remoteMemberships.filter((membership) => {
+            if (this.scope && membership.scope && !sameScope(membership.scope, this.scope)) return false;
+            if (!itemIds.has(membership.itemId)) return false;
+            return collectionIds.has(membership.collectionId);
+          }).map((membership) => [getMembershipId(membership.collectionId, membership.itemId), membership])
+        );
+        for (const membership of remoteById.values()) {
+          const id = getMembershipId(membership.collectionId, membership.itemId);
+          if (pendingIds.has(id)) continue;
+          await this.local.setCollectionMembership({ ...membership, ...this.scope ? { scope: this.scope } : {} });
+        }
+        for (const membership of localMemberships) {
+          const id = getMembershipId(membership.collectionId, membership.itemId);
+          if (pendingIds.has(id) || remoteById.has(id)) continue;
+          if (this.scope && !sameScope(membership.scope, this.scope)) continue;
+          await this.local.removeCollectionMembership(membership.collectionId, membership.itemId, this.scope);
+        }
+        this.notifyDataListeners();
+      }
       return true;
     } catch (error) {
       this.updateState({ status: "error", error });
@@ -714,7 +1064,33 @@ 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 isMembershipSyncOperation(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.operationId === "string" && value.entity === "membership" && (value.type === "upsert" || value.type === "remove") && typeof value.id === "string" && typeof value.collectionId === "string" && typeof value.itemId === "string" && typeof value.createdAt === "number" && (value.membership === void 0 || isKeepCollectionMembership(value.membership)) && (value.type !== "upsert" || isKeepCollectionMembership(value.membership));
+}
+function isSyncQueueOperation(value) {
+  return isSyncOperation(value) || isCollectionSyncOperation(value) || isMembershipSyncOperation(value);
+}
+function getQueueIdentity(operation) {
+  return `${operation.entity ?? "item"}:${operation.id}`;
+}
+function getMembershipId(collectionId, itemId) {
+  return `${collectionId}\0${itemId}`;
+}
+function createCollectionSyncConflict(operation, result) {
+  const details = {
+    operation,
+    resolution: result.resolution,
+    ...result.revision ? { revision: result.revision } : {}
+  };
+  if (result.deleted) return { ...details, deleted: true };
+  return { ...details, deleted: false, collection: result.collection };
 }
 function createId() {
   if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
@@ -797,6 +1173,7 @@ var FallbackStorageAdapter = class {
     this.migrateFallbackOnEmpty = options.migrateFallbackOnEmpty ?? false;
     this.mirrorWrites = options.mirrorWrites ?? false;
     this.storageKey = options.fallback.storageKey ?? options.primary.storageKey;
+    this.scope = options.primary.scope ?? options.fallback.scope;
     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 () => {
@@ -820,6 +1197,22 @@ var FallbackStorageAdapter = class {
         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";
@@ -835,12 +1228,12 @@ var FallbackStorageAdapter = class {
       (adapter) => adapter.setMany ? adapter.setMany(items) : Promise.all(items.map((item) => adapter.set(item))).then(() => void 0)
     );
   }
-  remove(id) {
-    return this.executeWrite((adapter) => adapter.remove(id));
+  remove(id, scope) {
+    return this.executeWrite((adapter) => adapter.remove(id, scope));
   }
-  removeMany(ids) {
+  removeMany(ids, scope) {
     return this.executeWrite(
-      (adapter) => adapter.removeMany ? adapter.removeMany(ids) : Promise.all(ids.map((id) => adapter.remove(id))).then(() => void 0)
+      (adapter) => adapter.removeMany ? adapter.removeMany(ids, scope) : Promise.all(ids.map((id) => adapter.remove(id, scope))).then(() => void 0)
     );
   }
   clear() {
@@ -947,6 +1340,9 @@ function createStorageAdapter(options) {
   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 ? {
@@ -954,10 +1350,15 @@ function createStorageAdapter(options) {
       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),
-    ...removeMany ? { removeMany: async (ids) => removeMany(ids) } : {},
+    remove: async (id, scope) => options.remove(id, scope),
+    ...removeMany ? { removeMany: async (ids, scope) => removeMany(ids, scope) } : {},
     clear: async () => options.clear(),
     ...merge ? { merge: async (items) => merge(items) } : {},
     ...subscribe ? {
@@ -1040,30 +1441,84 @@ var LocalStorageAdapter = class {
       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]);
   }
   async setMany(items) {
     const current = await this.getAll();
-    const byId = new Map(current.map((item) => [item.id, item]));
-    for (const item of items) byId.set(item.id, item);
-    this.write([...byId.values()], "set");
+    const byScopeAndId = new Map(current.map((item) => [getItemStorageKey(item), item]));
+    for (const item of items) byScopeAndId.set(getItemStorageKey(item), item);
+    this.write([...byScopeAndId.values()], "set");
   }
-  async remove(id) {
-    await this.removeMany([id]);
+  async remove(id, scope) {
+    await this.removeMany([id], scope);
   }
-  async removeMany(ids) {
+  async removeMany(ids, scope) {
     const idSet = new Set(ids);
     const items = await this.getAll();
     this.write(
-      items.filter((item) => !idSet.has(item.id)),
+      items.filter((item) => !idSet.has(item.id) || scope !== void 0 && !isSameKeepScope(item.scope, scope)),
       "remove"
     );
+    const memberships = await this.getCollectionMemberships();
+    const membershipIds = memberships.filter(
+      (membership) => idSet.has(membership.itemId) && (scope === void 0 || isSameKeepScope(membership.scope, scope))
+    );
+    for (const membership of membershipIds) {
+      await this.removeCollectionMembership(membership.collectionId, membership.itemId, membership.scope);
+    }
   }
   async clear() {
     if (!this.storage) return;
     try {
+      const items = await this.getAll();
+      if (items.length > 0) await this.removeMany(items.map((item) => item.id));
+      const memberships = await this.getCollectionMemberships();
+      for (const membership of memberships) {
+        await this.removeCollectionMembership(membership.collectionId, membership.itemId, membership.scope);
+      }
       this.storage.removeItem(this.storageKey);
     } catch (cause) {
       throw new KeepStorageAccessError({
@@ -1081,7 +1536,8 @@ var LocalStorageAdapter = class {
   subscribe(listener) {
     if (typeof window === "undefined") return () => void 0;
     const handleStorage = (event) => {
-      if (event.key !== null && event.key !== this.storageKey && event.key !== `${this.storageKey}:collections`) 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);
@@ -1116,6 +1572,16 @@ var LocalStorageAdapter = class {
       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 = {}) {
@@ -1134,7 +1600,7 @@ var IndexedDBAdapter = class {
       if (!isKeepItemArray(value)) {
         throw new KeepStorageParseError({ operation: "getAll", storageKey: this.storageKey });
       }
-      return value;
+      return value.map(decodeIndexedDBItem);
     } catch (cause) {
       if (cause instanceof KeepStorageParseError) throw cause;
       throw new KeepStorageAccessError({ operation: "getAll", storageKey: this.storageKey, cause });
@@ -1165,6 +1631,38 @@ var IndexedDBAdapter = class {
   }
   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]);
@@ -1173,9 +1671,12 @@ var IndexedDBAdapter = class {
     const database = await this.open("set");
     if (!database) return;
     try {
+      const identities = new Set(items.map(getItemIdentity));
+      const previous = (await this.getAll()).filter((item) => identities.has(getItemIdentity(item)));
       const transaction = database.transaction(this.storeName, "readwrite");
       const objectStore = transaction.objectStore(this.storeName);
-      for (const item of items) objectStore.put(item);
+      for (const item of previous) objectStore.delete(getStoredIndexedDBItemId(item));
+      for (const item of items) objectStore.put(encodeIndexedDBItem(item));
       await transactionToPromise2(transaction);
       this.notifySubscribers();
     } catch (cause) {
@@ -1185,17 +1686,25 @@ var IndexedDBAdapter = class {
       throw new KeepStorageAccessError({ operation: "set", storageKey: this.storageKey, cause });
     }
   }
-  async remove(id) {
-    return this.removeMany([id]);
+  async remove(id, scope) {
+    return this.removeMany([id], scope);
   }
-  async removeMany(ids) {
+  async removeMany(ids, scope) {
     const database = await this.open("remove");
     if (!database) return;
     try {
+      const idSet = new Set(ids);
+      const removableIds = (await this.getAll()).filter((item) => idSet.has(item.id) && (scope === void 0 || isSameKeepScope(item.scope, scope))).map(getStoredIndexedDBItemId);
       const transaction = database.transaction(this.storeName, "readwrite");
       const objectStore = transaction.objectStore(this.storeName);
-      for (const id of new Set(ids)) objectStore.delete(id);
+      for (const id of removableIds) objectStore.delete(id);
       await transactionToPromise2(transaction);
+      const memberships = await this.getCollectionMemberships();
+      for (const membership of memberships) {
+        if (idSet.has(membership.itemId) && (scope === void 0 || isSameKeepScope(membership.scope, scope))) {
+          await this.removeCollectionMembership(membership.collectionId, membership.itemId, membership.scope);
+        }
+      }
       this.notifySubscribers();
     } catch (cause) {
       throw new KeepStorageAccessError({ operation: "remove", storageKey: this.storageKey, cause });
@@ -1205,6 +1714,12 @@ var IndexedDBAdapter = class {
     const database = await this.open("clear");
     if (!database) return;
     try {
+      const items = await this.getAll();
+      if (items.length > 0) await this.removeMany(items.map((item) => item.id));
+      const memberships = await this.getCollectionMemberships();
+      for (const membership of memberships) {
+        await this.removeCollectionMembership(membership.collectionId, membership.itemId, membership.scope);
+      }
       const transaction = database.transaction(this.storeName, "readwrite");
       transaction.objectStore(this.storeName).clear();
       await transactionToPromise2(transaction);
@@ -1249,6 +1764,20 @@ var IndexedDBAdapter = class {
       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`;
@@ -1256,7 +1785,7 @@ var IndexedDBAdapter = class {
       this.collectionDatabasePromise = new Promise((resolve, reject) => {
         let request;
         try {
-          request = this.indexedDB?.open(storageKey, 1);
+          request = this.indexedDB?.open(storageKey, 2);
         } catch (cause) {
           reject(cause);
           return;
@@ -1265,6 +1794,9 @@ var IndexedDBAdapter = class {
           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);
@@ -1304,9 +1836,42 @@ var IndexedDBAdapter = class {
     });
   }
 };
+var indexedDBStoredItemId = /* @__PURE__ */ Symbol("keepkit.indexeddb-stored-item-id");
+function encodeIndexedDBItem(item) {
+  if (!item.scope) return item;
+  return {
+    ...item,
+    id: createScopedIndexedDBItemId(item),
+    __keepkitOriginalId: item.id
+  };
+}
+function decodeIndexedDBItem(item) {
+  const originalId = item.__keepkitOriginalId;
+  const isEncoded = typeof originalId === "string" && item.scope !== void 0 && item.id === createScopedIndexedDBItemId({ ...item, id: originalId });
+  const { __keepkitOriginalId: _encodedOriginalId, ...record } = item;
+  const decoded = isEncoded ? { ...record, id: originalId } : item;
+  Object.defineProperty(decoded, indexedDBStoredItemId, { value: item.id });
+  return decoded;
+}
+function getStoredIndexedDBItemId(item) {
+  return item[indexedDBStoredItemId] ?? createScopedIndexedDBItemId(item);
+}
+function createScopedIndexedDBItemId(item) {
+  if (!item.scope) return item.id;
+  return `\0keepkit-scope:${JSON.stringify([item.scope.tenantId ?? null, item.scope.userId ?? null, item.id])}`;
+}
+function getItemIdentity(item) {
+  return JSON.stringify([item.scope?.tenantId ?? null, item.scope?.userId ?? null, item.id]);
+}
 function collectionKey(id, scope) {
   return JSON.stringify([scope?.tenantId ?? null, scope?.userId ?? null, id]);
 }
+function getItemStorageKey(item) {
+  return JSON.stringify([item.scope?.tenantId ?? null, item.scope?.userId ?? null, item.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 {
@@ -1352,6 +1917,8 @@ export {
   removeKeepItems,
   mergeKeepItemLists,
   isKeepItem,
+  isKeepCollectionDefinition,
+  isKeepCollectionMembership,
   isRecord,
   getKeepScopeKey,
   isSameKeepScope,
@@ -1374,4 +1941,4 @@ export {
   LocalStorageAdapter,
   IndexedDBAdapter
 };
-//# sourceMappingURL=chunk-2TENUU7B.js.map
+//# sourceMappingURL=chunk-QRPQYE7K.js.map