@keepkit/core 0.28.5 → 0.28.7

package/dist/core.js

@@ -13,13 +13,14 @@ import {
   isKeepItemMetadataStale,
   mergeKeepItems,
   migrateKeepItems,
+  migrateLegacyCollectionMemberships,
   moveKeepItem,
   orderKeepItems,
   queryKeepItems,
   reconcileKeepItems,
   reorderKeepItems,
   revalidateKeepItems
-} from "./chunk-AUNFZU3A.js";
+} from "./chunk-EMOPFB5D.js";
 import {
   KeepSchemaValidationError,
   parseKeepMeta,
@@ -53,7 +54,23 @@ import {
   isKeepSyncAuthError,
   isSameKeepScope,
   normalizeKeepTags
-} from "./chunk-NZLAW4LY.js";
+} from "./chunk-SLH4DFYQ.js";
+
+// src/features/persistence/write-lock.ts
+var writeQueues = /* @__PURE__ */ new Map();
+function withLocalStorageWriteLock(key, operation, lockUnavailableError) {
+  const lockName = `keepkit:local-storage:${key}`;
+  if (typeof navigator !== "undefined" && navigator.locks) {
+    return navigator.locks.request(lockName, operation);
+  }
+  if (typeof window !== "undefined") return Promise.reject(lockUnavailableError);
+  const previous = writeQueues.get(lockName) ?? Promise.resolve();
+  const next = previous.catch(() => void 0).then(operation);
+  writeQueues.set(lockName, next);
+  return next.finally(() => {
+    if (writeQueues.get(lockName) === next) writeQueues.delete(lockName);
+  });
+}
 
 // src/features/items/activity.ts
 var DEFAULT_KEEP_HISTORY_KEY = "keepkit:view-history";
@@ -84,32 +101,52 @@ var LocalStorageKeepHistoryStorage = class {
   }
   async setLimit(limit) {
     const normalized = normalizeLimit(limit);
-    this.writeRaw(this.limitKey, JSON.stringify(normalized), "history-limit");
-    const entries = await this.getAll();
-    await this.writeEntries(entries.slice(0, normalized));
+    await this.withWriteLock(async () => {
+      this.writeRaw(this.limitKey, JSON.stringify(normalized), "history-limit");
+      const entries = await this.getAll();
+      await this.writeEntries(entries.slice(0, normalized));
+    });
   }
-  async record(itemId, viewedAt = this.now()) {
+  async record(itemId, viewedAt = this.now(), context) {
     const normalizedId = normalizeId(itemId);
     assertTimestamp(viewedAt);
-    const entries = await this.getAll();
-    const previous = entries.find((entry) => entry.itemId === normalizedId);
-    const next = [
-      { itemId: normalizedId, lastViewedAt: Math.max(previous?.lastViewedAt ?? 0, viewedAt) },
-      ...entries.filter((entry) => entry.itemId !== normalizedId)
-    ].sort((left, right) => right.lastViewedAt - left.lastViewedAt).slice(0, await this.getLimit());
-    await this.writeEntries(next);
-    return cloneHistoryEntries(next);
+    return this.withWriteLock(async () => {
+      const entries = await this.getAll();
+      const previous = entries.find((entry) => entry.itemId === normalizedId);
+      const isNewer = viewedAt >= (previous?.lastViewedAt ?? -1);
+      const nextContext = isNewer ? normalizeHistoryContext(context) : previous?.context;
+      const next = [
+        {
+          itemId: normalizedId,
+          lastViewedAt: Math.max(previous?.lastViewedAt ?? 0, viewedAt),
+          ...nextContext ? { context: nextContext } : {}
+        },
+        ...entries.filter((entry) => entry.itemId !== normalizedId)
+      ].sort((left, right) => right.lastViewedAt - left.lastViewedAt).slice(0, await this.getLimit());
+      await this.writeEntries(next);
+      return cloneHistoryEntries(next);
+    });
   }
   async remove(itemId) {
     const normalizedId = normalizeId(itemId);
-    await this.writeEntries((await this.getAll()).filter((entry) => entry.itemId !== normalizedId));
+    await this.withWriteLock(
+      async () => this.writeEntries((await this.getAll()).filter((entry) => entry.itemId !== normalizedId))
+    );
   }
   async clear() {
-    this.writeRaw(this.key, "[]", "history");
+    await this.withWriteLock(async () => this.writeRaw(this.key, "[]", "history"));
   }
   async writeEntries(entries) {
     this.writeRaw(this.key, JSON.stringify(entries), "history");
   }
+  withWriteLock(operation) {
+    if (!this.storage) return operation();
+    return withLocalStorageWriteLock(
+      this.key,
+      operation,
+      new KeepActivityStorageError("KeepKit needs the Web Locks API to safely update history across tabs.", this.key)
+    );
+  }
   async read(key, validate, label) {
     const raw = this.readRaw(key, label);
     if (raw === null) return [];
@@ -125,8 +162,10 @@ var LocalStorageKeepHistoryStorage = class {
     }
   }
   writeRaw(key, value, label) {
+    if (!this.storage)
+      throw new KeepActivityStorageError(`KeepKit cannot persist ${label} data without browser storage.`, key);
     try {
-      this.storage?.setItem(key, value);
+      this.storage.setItem(key, value);
     } catch (cause) {
       throw new KeepActivityStorageError(`KeepKit could not write ${label} data.`, key, cause);
     }
@@ -145,29 +184,51 @@ var LocalStorageKeepViewingRecordStorage = class {
     return filtered.sort((left, right) => right.viewedAt - left.viewedAt).map((record) => ({ ...record }));
   }
   async set(record) {
-    const normalized = normalizeViewingRecord(record);
-    const records = await this.readRecords();
-    this.writeRecords([...records.filter((entry) => entry.id !== normalized.id), normalized]);
+    await this.saveRecord(record);
   }
   async add(itemId, options = {}) {
+    const timestamp = this.now();
     const record = {
       id: this.createId(),
       itemId: normalizeId(itemId),
-      viewedAt: options.viewedAt ?? this.now(),
+      viewedAt: options.viewedAt ?? timestamp,
+      createdAt: timestamp,
+      updatedAt: timestamp,
       ...options.note?.trim() ? { note: options.note.trim() } : {}
     };
-    await this.set(record);
-    return { ...record };
+    return this.saveRecord(record);
+  }
+  async saveRecord(record) {
+    const normalized = normalizeViewingRecord(record);
+    return this.withWriteLock(async () => {
+      const records = await this.readRecords();
+      const previous = records.find((entry) => entry.id === normalized.id);
+      if (previous?.updatedAt !== void 0 && normalized.updatedAt !== void 0 && previous.updatedAt > normalized.updatedAt) {
+        return { ...previous };
+      }
+      const now = this.now();
+      const next = {
+        ...normalized,
+        createdAt: previous?.createdAt ?? normalized.createdAt ?? now,
+        updatedAt: Math.max(now, (previous?.updatedAt ?? -1) + 1, normalized.updatedAt ?? -1)
+      };
+      this.writeRecords([...records.filter((entry) => entry.id !== normalized.id), next]);
+      return { ...next };
+    });
   }
   async remove(id) {
-    this.writeRecords((await this.readRecords()).filter((record) => record.id !== id));
+    await this.withWriteLock(
+      async () => this.writeRecords((await this.readRecords()).filter((record) => record.id !== id))
+    );
   }
   async removeForItem(itemId) {
     const normalizedId = normalizeId(itemId);
-    this.writeRecords((await this.readRecords()).filter((record) => record.itemId !== normalizedId));
+    await this.withWriteLock(
+      async () => this.writeRecords((await this.readRecords()).filter((record) => record.itemId !== normalizedId))
+    );
   }
   async clear() {
-    this.writeRecords([]);
+    await this.withWriteLock(async () => this.writeRecords([]));
   }
   async readRecords() {
     const raw = this.readRaw();
@@ -186,12 +247,26 @@ var LocalStorageKeepViewingRecordStorage = class {
     }
   }
   writeRecords(records) {
+    if (!this.storage) {
+      throw new KeepActivityStorageError("KeepKit cannot persist viewing records without browser storage.", this.key);
+    }
     try {
-      this.storage?.setItem(this.key, JSON.stringify(records));
+      this.storage.setItem(this.key, JSON.stringify(records));
     } catch (cause) {
       throw new KeepActivityStorageError("KeepKit could not write viewing records.", this.key, cause);
     }
   }
+  withWriteLock(operation) {
+    if (!this.storage) return operation();
+    return withLocalStorageWriteLock(
+      this.key,
+      operation,
+      new KeepActivityStorageError(
+        "KeepKit needs the Web Locks API to safely update viewing records across tabs.",
+        this.key
+      )
+    );
+  }
 };
 var KeepActivityStorageError = class extends Error {
   constructor(message, storageKey, cause) {
@@ -203,20 +278,22 @@ var KeepActivityStorageError = class extends Error {
 };
 function isHistoryEntryArray(value) {
   return Array.isArray(value) && value.every(
-    (entry) => isRecord(entry) && typeof entry.itemId === "string" && entry.itemId.length > 0 && typeof entry.lastViewedAt === "number" && Number.isFinite(entry.lastViewedAt)
+    (entry) => isRecord(entry) && typeof entry.itemId === "string" && entry.itemId.length > 0 && typeof entry.lastViewedAt === "number" && Number.isFinite(entry.lastViewedAt) && (entry.context === void 0 || isHistoryContext(entry.context))
   );
 }
 function isViewingRecordArray(value) {
   return Array.isArray(value) && value.every(isViewingRecord);
 }
 function isViewingRecord(value) {
-  return isRecord(value) && typeof value.id === "string" && value.id.length > 0 && typeof value.itemId === "string" && value.itemId.length > 0 && typeof value.viewedAt === "number" && Number.isFinite(value.viewedAt) && value.viewedAt >= 0 && (value.note === void 0 || typeof value.note === "string");
+  return isRecord(value) && typeof value.id === "string" && value.id.length > 0 && typeof value.itemId === "string" && value.itemId.length > 0 && typeof value.viewedAt === "number" && Number.isFinite(value.viewedAt) && value.viewedAt >= 0 && (value.createdAt === void 0 || typeof value.createdAt === "number" && Number.isFinite(value.createdAt)) && (value.updatedAt === void 0 || typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt)) && (value.note === void 0 || typeof value.note === "string");
 }
 function normalizeViewingRecord(record) {
   const normalized = {
     id: normalizeId(record.id),
     itemId: normalizeId(record.itemId),
     viewedAt: record.viewedAt,
+    ...record.createdAt !== void 0 ? { createdAt: record.createdAt } : {},
+    ...record.updatedAt !== void 0 ? { updatedAt: record.updatedAt } : {},
     ...record.note?.trim() ? { note: record.note.trim() } : {}
   };
   assertTimestamp(normalized.viewedAt);
@@ -235,7 +312,15 @@ function assertTimestamp(value) {
   if (!Number.isFinite(value) || value < 0) throw new TypeError("KeepKit timestamps must be non-negative numbers.");
 }
 function cloneHistoryEntries(entries) {
-  return entries.map((entry) => ({ ...entry }));
+  return entries.map((entry) => ({ ...entry, ...entry.context ? { context: { ...entry.context } } : {} }));
+}
+function normalizeHistoryContext(context) {
+  if (!context) return void 0;
+  const entries = Object.entries(context).filter(([key, value]) => key.trim() && typeof value === "string");
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function isHistoryContext(value) {
+  return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
 function parseJson(raw, key, label) {
   try {
@@ -261,6 +346,7 @@ function createRecordId() {
 }
 
 // src/features/items/collections.ts
+var collectionMutationQueues = /* @__PURE__ */ new WeakMap();
 async function getKeepCollectionItems(storage, collectionId) {
   const memberships = await requireMemberships(storage);
   const items = await storage.getAll();
@@ -271,48 +357,62 @@ async function getKeepCollectionItems(storage, collectionId) {
   });
 }
 async function addKeepItemToCollection(storage, collectionId, itemId, order) {
-  if (!(await storage.getAll()).some((item) => item.id === itemId)) {
-    throw new Error(`KeepKit cannot add missing item "${itemId}" to a collection.`);
-  }
-  const collectionMemberships = (await requireMemberships(storage)).filter((membership) => membership.collectionId === collectionId).filter((membership) => membership.itemId !== itemId).sort((left, right) => left.order - right.order);
-  const insertionIndex = order ?? collectionMemberships.length;
-  if (!Number.isInteger(insertionIndex) || insertionIndex < 0) {
-    throw new RangeError("Collection order must be a non-negative integer.");
-  }
-  collectionMemberships.splice(Math.min(insertionIndex, collectionMemberships.length), 0, {
-    collectionId,
-    itemId,
-    order: insertionIndex
+  return withCollectionMutationLock(storage, async () => {
+    if (!(await storage.getAll()).some((item) => item.id === itemId)) {
+      throw new Error(`KeepKit cannot add missing item "${itemId}" to a collection.`);
+    }
+    const collectionMemberships = (await requireMemberships(storage)).filter((membership) => membership.collectionId === collectionId).filter((membership) => membership.itemId !== itemId).sort((left, right) => left.order - right.order);
+    const insertionIndex = order ?? collectionMemberships.length;
+    if (!Number.isInteger(insertionIndex) || insertionIndex < 0) {
+      throw new RangeError("Collection order must be a non-negative integer.");
+    }
+    collectionMemberships.splice(Math.min(insertionIndex, collectionMemberships.length), 0, {
+      collectionId,
+      itemId,
+      order: insertionIndex
+    });
+    const reordered = collectionMemberships.map((membership, index) => ({ ...membership, order: index }));
+    for (const membership of reordered) await storage.setCollectionMembership?.(membership);
+    const added = reordered.find((membership) => membership.itemId === itemId);
+    if (!added) throw new Error("KeepKit failed to add the collection membership.");
+    return added;
   });
-  const reordered = collectionMemberships.map((membership, index) => ({ ...membership, order: index }));
-  for (const membership of reordered) await storage.setCollectionMembership?.(membership);
-  const added = reordered.find((membership) => membership.itemId === itemId);
-  if (!added) throw new Error("KeepKit failed to add the collection membership.");
-  return added;
 }
 async function removeKeepItemFromCollection(storage, collectionId, itemId) {
-  const memberships = await requireMemberships(storage);
-  await storage.removeCollectionMembership?.(collectionId, itemId);
-  const remaining = memberships.filter((membership) => membership.collectionId === collectionId && membership.itemId !== itemId).sort((left, right) => left.order - right.order).map((membership, order) => ({ ...membership, order }));
-  for (const membership of remaining) await storage.setCollectionMembership?.(membership);
+  await withCollectionMutationLock(storage, async () => {
+    const memberships = await requireMemberships(storage);
+    await storage.removeCollectionMembership?.(collectionId, itemId);
+    const remaining = memberships.filter((membership) => membership.collectionId === collectionId && membership.itemId !== itemId).sort((left, right) => left.order - right.order).map((membership, order) => ({ ...membership, order }));
+    for (const membership of remaining) await storage.setCollectionMembership?.(membership);
+  });
 }
 async function reorderKeepCollectionItems(storage, collectionId, itemIds) {
-  const allMemberships = await requireMemberships(storage);
-  const current = allMemberships.filter((membership) => membership.collectionId === collectionId).sort((left, right) => left.order - right.order);
-  const currentIds = new Set(current.map((membership) => membership.itemId));
-  const orderedIds = [...itemIds.filter((id, index) => currentIds.has(id) && itemIds.indexOf(id) === index)];
-  for (const membership of current) {
-    if (!orderedIds.includes(membership.itemId)) orderedIds.push(membership.itemId);
-  }
-  const currentByItemId = new Map(current.map((membership) => [membership.itemId, membership]));
-  const reordered = orderedIds.map((itemId, order) => ({
-    ...currentByItemId.get(itemId) ?? {},
-    collectionId,
-    itemId,
-    order
-  }));
-  for (const membership of reordered) await storage.setCollectionMembership?.(membership);
-  return reordered;
+  return withCollectionMutationLock(storage, async () => {
+    const allMemberships = await requireMemberships(storage);
+    const current = allMemberships.filter((membership) => membership.collectionId === collectionId).sort((left, right) => left.order - right.order);
+    const currentIds = new Set(current.map((membership) => membership.itemId));
+    const orderedIds = [...itemIds.filter((id, index) => currentIds.has(id) && itemIds.indexOf(id) === index)];
+    for (const membership of current) {
+      if (!orderedIds.includes(membership.itemId)) orderedIds.push(membership.itemId);
+    }
+    const currentByItemId = new Map(current.map((membership) => [membership.itemId, membership]));
+    const reordered = orderedIds.map((itemId, order) => ({
+      ...currentByItemId.get(itemId) ?? {},
+      collectionId,
+      itemId,
+      order
+    }));
+    for (const membership of reordered) await storage.setCollectionMembership?.(membership);
+    return reordered;
+  });
+}
+function withCollectionMutationLock(storage, operation) {
+  const previous = collectionMutationQueues.get(storage) ?? Promise.resolve();
+  const next = previous.catch(() => void 0).then(operation);
+  collectionMutationQueues.set(storage, next);
+  return next.finally(() => {
+    if (collectionMutationQueues.get(storage) === next) collectionMutationQueues.delete(storage);
+  });
 }
 async function requireMemberships(storage) {
   if (!storage.getCollectionMemberships || !storage.setCollectionMembership || !storage.removeCollectionMembership) {
@@ -383,41 +483,69 @@ var LocalStorageKeepProgressStorage = class {
     return record;
   }
   async saveCourse(courseId, currentItemId) {
-    const record = {
-      kind: "course",
-      courseId: normalizeId2(courseId, "course"),
-      ...currentItemId?.trim() ? { currentItemId: currentItemId.trim() } : {},
-      updatedAt: this.now()
-    };
-    await this.set(record);
-    return record;
+    const id = normalizeId2(courseId, "course");
+    return this.withWriteLock(async () => {
+      const records = await this.getAll();
+      const previous = records.find((entry) => entry.kind === "course" && entry.courseId === id);
+      const record = {
+        kind: "course",
+        courseId: id,
+        ...currentItemId?.trim() ? { currentItemId: currentItemId.trim() } : {},
+        updatedAt: Math.max(this.now(), (previous?.updatedAt ?? -1) + 1)
+      };
+      this.writeRecords([
+        ...records.filter((entry) => getProgressIdentity(entry) !== getProgressIdentity(record)),
+        record
+      ]);
+      return record;
+    });
   }
   async saveItem(itemId, progress) {
-    const record = {
-      kind: "item",
-      itemId: normalizeId2(itemId, "item"),
-      ...progress,
-      updatedAt: this.now()
-    };
-    await this.set(record);
-    return record;
+    const id = normalizeId2(itemId, "item");
+    return this.withWriteLock(async () => {
+      const records = await this.getAll();
+      const previous = records.find((entry) => entry.kind === "item" && entry.itemId === id);
+      const record = {
+        ...previous,
+        ...progress,
+        kind: "item",
+        itemId: id,
+        ...progress.audioId !== void 0 ? progress.audioId.trim() ? { audioId: progress.audioId.trim() } : { audioId: void 0 } : {},
+        updatedAt: Math.max(this.now(), (previous?.updatedAt ?? -1) + 1)
+      };
+      const normalized = normalizeProgressRecord(record);
+      if (normalized.kind !== "item") throw new TypeError("KeepKit progress record is invalid.");
+      this.writeRecords([
+        ...records.filter((entry) => getProgressIdentity(entry) !== getProgressIdentity(normalized)),
+        normalized
+      ]);
+      return normalized;
+    });
   }
   async set(record) {
-    const normalized = normalizeProgressRecord(record);
-    const records = await this.getAll();
-    const identity = getProgressIdentity(normalized);
-    this.writeRecords([...records.filter((entry) => getProgressIdentity(entry) !== identity), normalized]);
+    await this.withWriteLock(async () => {
+      const normalized = normalizeProgressRecord(record);
+      const records = await this.getAll();
+      const identity = getProgressIdentity(normalized);
+      const previous = records.find((entry) => getProgressIdentity(entry) === identity);
+      const resolved = previous && previous.updatedAt > normalized.updatedAt ? previous : normalized;
+      this.writeRecords([...records.filter((entry) => getProgressIdentity(entry) !== identity), resolved]);
+    });
   }
   async resetCourse(courseId) {
     const id = normalizeId2(courseId, "course");
-    this.writeRecords((await this.getAll()).filter((entry) => entry.kind !== "course" || entry.courseId !== id));
+    await this.withWriteLock(
+      async () => this.writeRecords((await this.getAll()).filter((entry) => entry.kind !== "course" || entry.courseId !== id))
+    );
   }
   async resetItem(itemId) {
     const id = normalizeId2(itemId, "item");
-    this.writeRecords((await this.getAll()).filter((entry) => entry.kind !== "item" || entry.itemId !== id));
+    await this.withWriteLock(
+      async () => this.writeRecords((await this.getAll()).filter((entry) => entry.kind !== "item" || entry.itemId !== id))
+    );
   }
   async clear() {
-    this.writeRecords([]);
+    await this.withWriteLock(async () => this.writeRecords([]));
   }
   readRaw() {
     try {
@@ -427,12 +555,23 @@ var LocalStorageKeepProgressStorage = class {
     }
   }
   writeRecords(records) {
+    if (!this.storage) {
+      throw new KeepProgressStorageError("KeepKit cannot persist progress without browser storage.", this.key);
+    }
     try {
-      this.storage?.setItem(this.key, JSON.stringify(records));
+      this.storage.setItem(this.key, JSON.stringify(records));
     } catch (cause) {
       throw new KeepProgressStorageError("KeepKit could not write progress data.", this.key, cause);
     }
   }
+  withWriteLock(operation) {
+    if (!this.storage) return operation();
+    return withLocalStorageWriteLock(
+      this.key,
+      operation,
+      new KeepProgressStorageError("KeepKit needs the Web Locks API to safely update progress across tabs.", this.key)
+    );
+  }
 };
 function isProgressCompatible(record, compatibility) {
   if (record.language !== void 0 && record.language !== compatibility?.language) return false;
@@ -440,6 +579,8 @@ function isProgressCompatible(record, compatibility) {
   if (compatibility?.language !== void 0 && record.language !== compatibility.language) return false;
   if (compatibility?.contentVersion !== void 0 && record.contentVersion !== compatibility.contentVersion)
     return false;
+  if (record.audioId !== void 0 && record.audioId !== compatibility?.audioId) return false;
+  if (compatibility?.audioId !== void 0 && record.audioId !== compatibility.audioId) return false;
   return true;
 }
 var KeepProgressStorageError = class extends Error {
@@ -457,7 +598,7 @@ function isProgressRecord(value) {
     return typeof value.courseId === "string" && value.courseId.length > 0 && (value.currentItemId === void 0 || typeof value.currentItemId === "string");
   }
   if (value.kind !== "item") return false;
-  return typeof value.itemId === "string" && value.itemId.length > 0 && (value.audioPositionMs === void 0 || typeof value.audioPositionMs === "number" && Number.isFinite(value.audioPositionMs) && value.audioPositionMs >= 0) && (value.readingPosition === void 0 || typeof value.readingPosition === "number" && Number.isFinite(value.readingPosition) && value.readingPosition >= 0) && (value.language === void 0 || typeof value.language === "string") && (value.contentVersion === void 0 || typeof value.contentVersion === "string");
+  return typeof value.itemId === "string" && value.itemId.length > 0 && (value.audioPositionMs === void 0 || typeof value.audioPositionMs === "number" && Number.isFinite(value.audioPositionMs) && value.audioPositionMs >= 0) && (value.readingPosition === void 0 || typeof value.readingPosition === "number" && Number.isFinite(value.readingPosition) && value.readingPosition >= 0 || typeof value.readingPosition === "string" && value.readingPosition.trim().length > 0) && (value.audioId === void 0 || typeof value.audioId === "string" && value.audioId.length > 0) && (value.language === void 0 || typeof value.language === "string") && (value.contentVersion === void 0 || typeof value.contentVersion === "string");
 }
 function normalizeProgressRecord(record) {
   if (!isProgressRecord(record)) throw new TypeError("KeepKit progress record is invalid.");
@@ -474,6 +615,7 @@ function normalizeProgressRecord(record) {
     itemId: normalizeId2(record.itemId, "item"),
     ...record.audioPositionMs !== void 0 ? { audioPositionMs: record.audioPositionMs } : {},
     ...record.readingPosition !== void 0 ? { readingPosition: record.readingPosition } : {},
+    ...record.audioId !== void 0 ? { audioId: record.audioId } : {},
     ...record.language !== void 0 ? { language: record.language } : {},
     ...record.contentVersion !== void 0 ? { contentVersion: record.contentVersion } : {},
     updatedAt: record.updatedAt
@@ -969,6 +1111,7 @@ var AuthenticatedSyncStorageController = class {
 function createAuthenticatedRemote(options, scope) {
   const pull = options.transport.pull;
   const pullCollections = options.transport.pullCollections;
+  const pullMemberships = options.transport.pullMemberships;
   return {
     push: async (operation) => {
       try {
@@ -1001,6 +1144,22 @@ function createAuthenticatedRemote(options, scope) {
       } catch (cause) {
         return handleAuthFailure(cause, options, { scope });
       }
+    } : void 0,
+    pushMembership: options.transport.pushMembership ? async (membershipOperation) => {
+      try {
+        const token = await options.getAuthToken();
+        await options.transport.pushMembership?.(membershipOperation, { token, scope, membershipOperation });
+      } catch (cause) {
+        return handleAuthFailure(cause, options, { membershipOperation, scope });
+      }
+    } : void 0,
+    pullMemberships: pullMemberships ? async () => {
+      try {
+        const token = await options.getAuthToken();
+        return await pullMemberships({ token, scope });
+      } catch (cause) {
+        return handleAuthFailure(cause, options, { scope });
+      }
     } : void 0
   };
 }
@@ -1084,6 +1243,7 @@ export {
   mergeKeepItems,
   mergeKeepListQueryFromUrl,
   migrateKeepItems,
+  migrateLegacyCollectionMemberships,
   moveKeepItem,
   normalizeKeepTags,
   orderKeepItems,