@keepkit/core 0.28.4 → 0.28.6

package/dist/core.js

@@ -13,13 +13,14 @@ import {
   isKeepItemMetadataStale,
   mergeKeepItems,
   migrateKeepItems,
+  migrateLegacyCollectionMemberships,
   moveKeepItem,
   orderKeepItems,
   queryKeepItems,
   reconcileKeepItems,
   reorderKeepItems,
   revalidateKeepItems
-} from "./chunk-Y4U5DEGG.js";
+} from "./chunk-5XSSH3TO.js";
 import {
   KeepSchemaValidationError,
   parseKeepMeta,
@@ -53,7 +54,331 @@ import {
   isKeepSyncAuthError,
   isSameKeepScope,
   normalizeKeepTags
-} from "./chunk-2TENUU7B.js";
+} from "./chunk-QRPQYE7K.js";
+
+// src/features/items/activity.ts
+var DEFAULT_KEEP_HISTORY_KEY = "keepkit:view-history";
+var DEFAULT_KEEP_VIEWING_RECORDS_KEY = "keepkit:viewing-records";
+var DEFAULT_KEEP_HISTORY_LIMIT = 100;
+var LocalStorageKeepHistoryStorage = class {
+  constructor(options = {}) {
+    this.writes = Promise.resolve();
+    this.key = options.key ?? DEFAULT_KEEP_HISTORY_KEY;
+    this.limitKey = `${this.key}:limit`;
+    this.storage = options.storage ?? getBrowserStorage();
+    this.initialLimit = normalizeLimit(options.maxEntries ?? DEFAULT_KEEP_HISTORY_LIMIT);
+    this.now = options.now ?? Date.now;
+  }
+  async getAll() {
+    return (await this.read(this.key, isHistoryEntryArray, "history")).sort(
+      (left, right) => right.lastViewedAt - left.lastViewedAt
+    );
+  }
+  async getLimit() {
+    if (!this.storage) return this.initialLimit;
+    const raw = this.readRaw(this.limitKey, "history-limit");
+    if (raw === null) return this.initialLimit;
+    const parsed = parseJson(raw, this.limitKey, "history-limit");
+    if (typeof parsed !== "number" || !Number.isInteger(parsed) || parsed < 1) {
+      throw new KeepActivityStorageError("KeepKit history limit is invalid.", this.limitKey);
+    }
+    return parsed;
+  }
+  async setLimit(limit) {
+    const normalized = normalizeLimit(limit);
+    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(), context) {
+    const normalizedId = normalizeId(itemId);
+    assertTimestamp(viewedAt);
+    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.withWriteLock(
+      async () => this.writeEntries((await this.getAll()).filter((entry) => entry.itemId !== normalizedId))
+    );
+  }
+  async clear() {
+    await this.withWriteLock(async () => this.writeRaw(this.key, "[]", "history"));
+  }
+  async writeEntries(entries) {
+    this.writeRaw(this.key, JSON.stringify(entries), "history");
+  }
+  withWriteLock(operation) {
+    const next = this.writes.then(operation);
+    this.writes = next.catch(() => void 0);
+    return next;
+  }
+  async read(key, validate, label) {
+    const raw = this.readRaw(key, label);
+    if (raw === null) return [];
+    const value = parseJson(raw, key, label);
+    if (!validate(value)) throw new KeepActivityStorageError(`KeepKit ${label} data is invalid.`, key);
+    return value;
+  }
+  readRaw(key, label) {
+    try {
+      return this.storage?.getItem(key) ?? null;
+    } catch (cause) {
+      throw new KeepActivityStorageError(`KeepKit could not read ${label} data.`, key, cause);
+    }
+  }
+  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);
+    } catch (cause) {
+      throw new KeepActivityStorageError(`KeepKit could not write ${label} data.`, key, cause);
+    }
+  }
+};
+var LocalStorageKeepViewingRecordStorage = class {
+  constructor(options = {}) {
+    this.writes = Promise.resolve();
+    this.key = options.key ?? DEFAULT_KEEP_VIEWING_RECORDS_KEY;
+    this.storage = options.storage ?? getBrowserStorage();
+    this.now = options.now ?? Date.now;
+    this.createId = options.createId ?? createRecordId;
+  }
+  async getAll(itemId) {
+    const records = await this.readRecords();
+    const filtered = itemId === void 0 ? records : records.filter((record) => record.itemId === itemId);
+    return filtered.sort((left, right) => right.viewedAt - left.viewedAt).map((record) => ({ ...record }));
+  }
+  async set(record) {
+    await this.saveRecord(record);
+  }
+  async add(itemId, options = {}) {
+    const timestamp = this.now();
+    const record = {
+      id: this.createId(),
+      itemId: normalizeId(itemId),
+      viewedAt: options.viewedAt ?? timestamp,
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      ...options.note?.trim() ? { note: options.note.trim() } : {}
+    };
+    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);
+      const now = this.now();
+      const next = {
+        ...normalized,
+        createdAt: previous?.createdAt ?? normalized.createdAt ?? now,
+        updatedAt: now
+      };
+      this.writeRecords([...records.filter((entry) => entry.id !== normalized.id), next]);
+      return { ...next };
+    });
+  }
+  async remove(id) {
+    await this.withWriteLock(
+      async () => this.writeRecords((await this.readRecords()).filter((record) => record.id !== id))
+    );
+  }
+  async removeForItem(itemId) {
+    const normalizedId = normalizeId(itemId);
+    await this.withWriteLock(
+      async () => this.writeRecords((await this.readRecords()).filter((record) => record.itemId !== normalizedId))
+    );
+  }
+  async clear() {
+    await this.withWriteLock(async () => this.writeRecords([]));
+  }
+  async readRecords() {
+    const raw = this.readRaw();
+    if (raw === null) return [];
+    const value = parseJson(raw, this.key, "viewing records");
+    if (!isViewingRecordArray(value)) {
+      throw new KeepActivityStorageError("KeepKit viewing record data is invalid.", this.key);
+    }
+    return value;
+  }
+  readRaw() {
+    try {
+      return this.storage?.getItem(this.key) ?? null;
+    } catch (cause) {
+      throw new KeepActivityStorageError("KeepKit could not read viewing records.", this.key, cause);
+    }
+  }
+  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));
+    } catch (cause) {
+      throw new KeepActivityStorageError("KeepKit could not write viewing records.", this.key, cause);
+    }
+  }
+  withWriteLock(operation) {
+    const next = this.writes.then(operation);
+    this.writes = next.catch(() => void 0);
+    return next;
+  }
+};
+var KeepActivityStorageError = class extends Error {
+  constructor(message, storageKey, cause) {
+    super(message);
+    this.name = "KeepActivityStorageError";
+    this.storageKey = storageKey;
+    this.cause = cause;
+  }
+};
+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.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.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);
+  return normalized;
+}
+function normalizeId(value) {
+  const normalized = value.trim();
+  if (!normalized) throw new TypeError("KeepKit item ids must not be empty.");
+  return normalized;
+}
+function normalizeLimit(value) {
+  if (!Number.isInteger(value) || value < 1) throw new RangeError("KeepKit history limit must be a positive integer.");
+  return value;
+}
+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, ...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 {
+    return JSON.parse(raw);
+  } catch (cause) {
+    throw new KeepActivityStorageError(`KeepKit ${label} data is not valid JSON.`, key, cause);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getBrowserStorage() {
+  if (typeof window === "undefined") return void 0;
+  try {
+    return window.localStorage;
+  } catch {
+    return void 0;
+  }
+}
+function createRecordId() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
+  return `keepkit-view-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+
+// src/features/items/collections.ts
+async function getKeepCollectionItems(storage, collectionId) {
+  const memberships = await requireMemberships(storage);
+  const items = await storage.getAll();
+  const itemsById = new Map(items.map((item) => [item.id, item]));
+  return memberships.filter((membership) => membership.collectionId === collectionId).sort((left, right) => left.order - right.order).flatMap((membership) => {
+    const item = itemsById.get(membership.itemId);
+    return item ? [item] : [];
+  });
+}
+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
+  });
+  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);
+}
+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;
+}
+async function requireMemberships(storage) {
+  if (!storage.getCollectionMemberships || !storage.setCollectionMembership || !storage.removeCollectionMembership) {
+    throw new Error("KeepKit storage adapter does not support collection memberships.");
+  }
+  return storage.getCollectionMemberships();
+}
 
 // src/features/items/presets.ts
 function createKeepKitPreset(options = {}) {
@@ -82,6 +407,176 @@ function createKeepKitPreset(options = {}) {
 }
 var createKeepKitSetup = createKeepKitPreset;
 
+// src/features/items/progress.ts
+var DEFAULT_KEEP_PROGRESS_KEY = "keepkit:progress";
+var LocalStorageKeepProgressStorage = class {
+  constructor(options = {}) {
+    this.writes = Promise.resolve();
+    this.key = options.key ?? DEFAULT_KEEP_PROGRESS_KEY;
+    this.storage = options.storage ?? getBrowserStorage2();
+    this.now = options.now ?? Date.now;
+  }
+  async getAll() {
+    const raw = this.readRaw();
+    if (raw === null) return [];
+    let value;
+    try {
+      value = JSON.parse(raw);
+    } catch (cause) {
+      throw new KeepProgressStorageError("KeepKit progress data is not valid JSON.", this.key, cause);
+    }
+    if (!Array.isArray(value) || !value.every(isProgressRecord)) {
+      throw new KeepProgressStorageError("KeepKit progress data is invalid.", this.key);
+    }
+    return value.map((record) => ({ ...record }));
+  }
+  async getCourse(courseId) {
+    const id = normalizeId2(courseId, "course");
+    const record = (await this.getAll()).find((entry) => entry.kind === "course" && entry.courseId === id);
+    return record?.kind === "course" ? record : void 0;
+  }
+  async getItem(itemId, compatibility) {
+    const id = normalizeId2(itemId, "item");
+    const record = (await this.getAll()).find((entry) => entry.kind === "item" && entry.itemId === id);
+    if (record?.kind !== "item") return void 0;
+    if (!isProgressCompatible(record, compatibility)) return void 0;
+    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;
+  }
+  async saveItem(itemId, progress) {
+    const record = {
+      kind: "item",
+      itemId: normalizeId2(itemId, "item"),
+      ...progress,
+      ...progress.audioId?.trim() ? { audioId: progress.audioId.trim() } : {},
+      updatedAt: this.now()
+    };
+    await this.set(record);
+    return record;
+  }
+  async set(record) {
+    await this.withWriteLock(async () => {
+      const normalized = normalizeProgressRecord(record);
+      const records = await this.getAll();
+      const identity = getProgressIdentity(normalized);
+      this.writeRecords([...records.filter((entry) => getProgressIdentity(entry) !== identity), normalized]);
+    });
+  }
+  async resetCourse(courseId) {
+    const id = normalizeId2(courseId, "course");
+    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");
+    await this.withWriteLock(
+      async () => this.writeRecords((await this.getAll()).filter((entry) => entry.kind !== "item" || entry.itemId !== id))
+    );
+  }
+  async clear() {
+    await this.withWriteLock(async () => this.writeRecords([]));
+  }
+  readRaw() {
+    try {
+      return this.storage?.getItem(this.key) ?? null;
+    } catch (cause) {
+      throw new KeepProgressStorageError("KeepKit could not read progress data.", this.key, cause);
+    }
+  }
+  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));
+    } catch (cause) {
+      throw new KeepProgressStorageError("KeepKit could not write progress data.", this.key, cause);
+    }
+  }
+  withWriteLock(operation) {
+    const next = this.writes.then(operation);
+    this.writes = next.catch(() => void 0);
+    return next;
+  }
+};
+function isProgressCompatible(record, compatibility) {
+  if (record.language !== void 0 && record.language !== compatibility?.language) return false;
+  if (record.contentVersion !== void 0 && record.contentVersion !== compatibility?.contentVersion) return false;
+  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 {
+  constructor(message, storageKey, cause) {
+    super(message);
+    this.name = "KeepProgressStorageError";
+    this.storageKey = storageKey;
+    this.cause = cause;
+  }
+};
+function isProgressRecord(value) {
+  if (!isRecord2(value) || typeof value.updatedAt !== "number" || !Number.isFinite(value.updatedAt) || value.updatedAt < 0)
+    return false;
+  if (value.kind === "course") {
+    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 || 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.");
+  if (record.kind === "course") {
+    return {
+      kind: "course",
+      courseId: normalizeId2(record.courseId, "course"),
+      ...record.currentItemId?.trim() ? { currentItemId: record.currentItemId.trim() } : {},
+      updatedAt: record.updatedAt
+    };
+  }
+  return {
+    kind: "item",
+    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
+  };
+}
+function getProgressIdentity(record) {
+  return record.kind === "course" ? `course:${record.courseId}` : `item:${record.itemId}`;
+}
+function normalizeId2(value, kind) {
+  const normalized = value.trim();
+  if (!normalized) throw new TypeError(`KeepKit ${kind} ids must not be empty.`);
+  return normalized;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getBrowserStorage2() {
+  if (typeof window === "undefined") return void 0;
+  try {
+    return window.localStorage;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/features/items/saved-views.ts
 var DEFAULT_SAVED_VIEWS_STORAGE_KEY = "keepkit:saved-views";
 var LocalStorageKeepSavedViewStorage = class {
@@ -149,13 +644,13 @@ function isKeepListQuery(value) {
   }
   if (query.pinnedFirst !== void 0 && typeof query.pinnedFirst !== "boolean") return false;
   if (query.sort !== void 0) {
-    if (!isRecord(query.sort) || !["savedAt", "updatedAt", "lastOpenedAt"].includes(String(query.sort.by)))
+    if (!isRecord3(query.sort) || !["savedAt", "updatedAt", "lastOpenedAt"].includes(String(query.sort.by)))
       return false;
     if (query.sort.direction !== void 0 && query.sort.direction !== "asc" && query.sort.direction !== "desc")
       return false;
   }
   if (query.search !== void 0) {
-    if (!isRecord(query.search)) return false;
+    if (!isRecord3(query.search)) return false;
     if (query.search.query !== void 0 && typeof query.search.query !== "string") return false;
     if (query.search.mode !== void 0 && query.search.mode !== "and" && query.search.mode !== "or") return false;
     if (query.search.tokenize !== void 0 && typeof query.search.tokenize !== "boolean") return false;
@@ -164,7 +659,7 @@ function isKeepListQuery(value) {
     }
   }
   if (query.activity !== void 0) {
-    if (!isRecord(query.activity)) return false;
+    if (!isRecord3(query.activity)) return false;
     if (query.activity.opened !== void 0 && query.activity.opened !== "ever" && query.activity.opened !== "never") {
       return false;
     }
@@ -178,7 +673,7 @@ function isKeepListQuery(value) {
     return false;
   }
   if (query.pagination !== void 0) {
-    if (!isRecord(query.pagination) || [query.pagination.page, query.pagination.pageSize].some(isInvalidNumber))
+    if (!isRecord3(query.pagination) || [query.pagination.page, query.pagination.pageSize].some(isInvalidNumber))
       return false;
   }
   const organization = query.organization;
@@ -193,7 +688,7 @@ function isKeepListQuery(value) {
   }
   return true;
 }
-function isRecord(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isInvalidNumber(value) {
@@ -411,6 +906,20 @@ var AuthenticatedSyncStorageController = class {
         await this.current.removeCollection?.(id);
       };
     }
+    if (this.current.getCollectionMemberships && this.current.setCollectionMembership && this.current.removeCollectionMembership) {
+      this.getCollectionMemberships = async () => {
+        await this.ensureScope();
+        return this.current.getCollectionMemberships?.() ?? [];
+      };
+      this.setCollectionMembership = async (membership) => {
+        await this.ensureScope();
+        await this.current.setCollectionMembership?.(membership);
+      };
+      this.removeCollectionMembership = async (collectionId, itemId) => {
+        await this.ensureScope();
+        await this.current.removeCollectionMembership?.(collectionId, itemId);
+      };
+    }
   }
   get storageKey() {
     return this.current.storageKey;
@@ -537,6 +1046,8 @@ 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 {
@@ -553,6 +1064,38 @@ function createAuthenticatedRemote(options, scope) {
       } catch (cause) {
         return handleAuthFailure(cause, options, { scope });
       }
+    } : void 0,
+    pushCollection: options.transport.pushCollection ? async (collectionOperation) => {
+      try {
+        const token = await options.getAuthToken();
+        await options.transport.pushCollection?.(collectionOperation, { token, scope, collectionOperation });
+      } catch (cause) {
+        return handleAuthFailure(cause, options, { collectionOperation, scope });
+      }
+    } : void 0,
+    pullCollections: pullCollections ? async () => {
+      try {
+        const token = await options.getAuthToken();
+        return await pullCollections({ token, 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
   };
 }
@@ -575,7 +1118,11 @@ function getAuthStatus(error) {
 export {
   DEFAULT_INDEXEDDB_DATABASE,
   DEFAULT_INDEXEDDB_STORE,
+  DEFAULT_KEEP_HISTORY_KEY,
+  DEFAULT_KEEP_HISTORY_LIMIT,
+  DEFAULT_KEEP_PROGRESS_KEY,
   DEFAULT_KEEP_URL_PARAMS,
+  DEFAULT_KEEP_VIEWING_RECORDS_KEY,
   DEFAULT_SAVED_VIEWS_STORAGE_KEY,
   DEFAULT_STORAGE_KEY,
   DEFAULT_SYNC_QUEUE_DATABASE,
@@ -587,8 +1134,10 @@ export {
   IndexedDBSyncQueueAdapter,
   KEEP_BACKUP_FORMAT,
   KEEP_BACKUP_VERSION,
+  KeepActivityStorageError,
   KeepBackupImportError,
   KeepBackupParseError,
+  KeepProgressStorageError,
   KeepSchemaValidationError,
   KeepStorageAccessError,
   KeepStorageError,
@@ -597,11 +1146,15 @@ export {
   KeepStore,
   KeepSyncAuthError,
   LocalStorageAdapter,
+  LocalStorageKeepHistoryStorage,
+  LocalStorageKeepProgressStorage,
   LocalStorageKeepSavedViewStorage,
+  LocalStorageKeepViewingRecordStorage,
   LocalStorageSyncQueueAdapter,
   ScopedStorageAdapter,
   ScopedSyncQueueAdapter,
   SyncStorageAdapter,
+  addKeepItemToCollection,
   createAuthenticatedSyncKit,
   createBrowserStorageAdapter,
   createInboxQuery,
@@ -614,22 +1167,27 @@ export {
   decodeKeepListQuery,
   encodeKeepListQuery,
   exportItems,
+  getKeepCollectionItems,
   getKeepNavigationState,
   getKeepScopeKey,
   getTagCounts,
   importItems,
   isKeepItemMetadataStale,
   isKeepSyncAuthError,
+  isProgressCompatible,
   isSameKeepScope,
   mergeKeepItems,
   mergeKeepListQueryFromUrl,
   migrateKeepItems,
+  migrateLegacyCollectionMemberships,
   moveKeepItem,
   normalizeKeepTags,
   orderKeepItems,
   parseKeepMeta,
   queryKeepItems,
   reconcileKeepItems,
+  removeKeepItemFromCollection,
+  reorderKeepCollectionItems,
   reorderKeepItems,
   revalidateKeepItems,
   serializeKeepListQuery,