jazz-tools 0.20.14 → 0.20.16

package/dist/{chunk-KGV2CJMG.js → chunk-WAYFZQXB.js}

@@ -34,6 +34,7 @@ __export(zodReExport_exports, {
   number: () => number,
   object: () => object,
   optional: () => optional,
+  partialRecord: () => partialRecord,
   record: () => record,
   strictObject: () => strictObject,
   string: () => string,
@@ -96,6 +97,7 @@ import {
   union,
   discriminatedUnion,
   record,
+  partialRecord,
   intersection,
   int,
   codec,
@@ -182,7 +184,7 @@ function getJazzErrorType(error) {
 
 // src/tools/coValues/interfaces.ts
 import {
-  cojsonInternals as cojsonInternals6
+  cojsonInternals as cojsonInternals7
 } from "cojson";
 
 // src/tools/coValues/CoValueBase.ts
@@ -302,6 +304,14 @@ var CoValueJazzApi = class {
     const subscriptionScope = this._subscriptionScope;
     return Boolean(subscriptionScope?.unstable_branch);
   }
+  get cursor() {
+    const subscriptionScope = this._subscriptionScope;
+    return subscriptionScope?.cursor;
+  }
+  createCursor() {
+    const subscriptionScope = getSubscriptionScope(this.coValue);
+    return subscriptionScope.cursor ?? subscriptionScope.createCursor();
+  }
   /**
    * Deeply merge the current branch into the main CoValues.
    *
@@ -5436,7 +5446,7 @@ var CoValueLoadingState = {
 
 // src/tools/subscribe/CoValueCoreSubscription.ts
 var CoValueCoreSubscription = class {
-  constructor(localNode, id, listener, skipRetry, branch) {
+  constructor(localNode, id, listener, skipRetry, branch, decodedCursor) {
     this._unsubscribe = () => {
     };
     this.unsubscribed = false;
@@ -5446,6 +5456,9 @@ var CoValueCoreSubscription = class {
     this.branchName = branch?.name;
     this.branchOwnerId = branch?.owner?.$jazz.raw.id;
     this.source = localNode.getCoValue(id);
+    if (decodedCursor) {
+      this.frontier = decodedCursor.frontiers[id] ?? CoValueLoadingState.UNAVAILABLE;
+    }
     this.initializeSubscription();
   }
   /**
@@ -5542,7 +5555,14 @@ var CoValueCoreSubscription = class {
     if (value === CoValueLoadingState.UNAVAILABLE) {
       this.listener(CoValueLoadingState.UNAVAILABLE);
     } else if (isCompletelyDownloaded(value)) {
-      this.listener(value.getCurrentContent());
+      const currentContent = value.getCurrentContent();
+      if (this.frontier) {
+        this.listener(
+          this.frontier === CoValueLoadingState.UNAVAILABLE ? CoValueLoadingState.UNAVAILABLE : currentContent.atFrontier(this.frontier)
+        );
+      } else {
+        this.listener(currentContent);
+      }
     }
   }
   /**
@@ -5639,7 +5659,7 @@ function rejectedPromise(reason) {
   promise.reason = reason;
   return promise;
 }
-function isEqualRefsToResolve(a, b) {
+function compareRefsToResolve(a, b, mode) {
   if (a === b) {
     return true;
   }
@@ -5654,7 +5674,7 @@ function isEqualRefsToResolve(a, b) {
   }
   const keysA = Object.keys(a);
   const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length) {
+  if (mode === "equality" && keysA.length !== keysB.length) {
     return false;
   }
   for (const key of keysA) {
@@ -5663,16 +5683,101 @@ function isEqualRefsToResolve(a, b) {
     }
     const valueA = a[key];
     const valueB = b[key];
-    if (!isEqualRefsToResolve(valueA, valueB)) {
+    if (!compareRefsToResolve(valueA, valueB, mode)) {
       return false;
     }
   }
   return true;
 }
+function isEqualRefsToResolve(a, b) {
+  return compareRefsToResolve(a, b, "equality");
+}
+function isSubsetOfRefsToResolve(a, b) {
+  return compareRefsToResolve(a, b, "subset");
+}
+
+// src/tools/subscribe/cursor.ts
+import { base58 } from "@scure/base";
+import { cojsonInternals as cojsonInternals5 } from "cojson";
+import { z as z2 } from "zod/v4";
+var cursorSchema = z2.object({
+  version: z2.literal(1),
+  rootId: z2.string(),
+  resolveFingerprint: z2.record(z2.string(), z2.any()),
+  frontiers: z2.record(z2.string(), z2.record(z2.string(), z2.number()))
+});
+var CursorError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CursorError";
+  }
+};
+var normalizeResolveForFingerprint = (resolve) => {
+  if (resolve === true) {
+    return {};
+  }
+  if (typeof resolve === "object") {
+    return Object.fromEntries(
+      Object.entries(resolve).filter(([k]) => k !== "$onError").map(([k, v]) => [
+        k,
+        normalizeResolveForFingerprint(v)
+      ])
+    );
+  }
+  return resolve;
+};
+var encodeCursor = (decodedCursor) => {
+  const textEncoder = new TextEncoder();
+  return `cursor_z${base58.encode(
+    textEncoder.encode(
+      cojsonInternals5.stableStringify({
+        ...decodedCursor,
+        resolveFingerprint: normalizeResolveForFingerprint(
+          decodedCursor.resolveFingerprint
+        )
+      })
+    )
+  )}`;
+};
+var decodeAndValidateCursor = ({
+  rootId,
+  resolve,
+  cursor
+}) => {
+  const textDecoder = new TextDecoder();
+  let maybeDecodedCursor;
+  try {
+    maybeDecodedCursor = cojsonInternals5.parseJSON(
+      textDecoder.decode(
+        base58.decode(cursor.replace(/^cursor_z/, ""))
+      )
+    );
+  } catch {
+    throw new CursorError("Invalid cursor string");
+  }
+  const parseResult = cursorSchema.safeParse(maybeDecodedCursor);
+  if (!parseResult.success) {
+    throw new CursorError("Invalid cursor string");
+  }
+  const decodedCursor = parseResult.data;
+  if (decodedCursor.rootId !== rootId) {
+    throw new CursorError("Invalid cursor: root CoValue ID mismatch");
+  }
+  const normalizedResolve = normalizeResolveForFingerprint(resolve);
+  if (!isSubsetOfRefsToResolve(
+    normalizedResolve,
+    decodedCursor.resolveFingerprint
+  )) {
+    throw new CursorError(
+      `Invalid cursor: resolve query mismatch. Expected ${JSON.stringify(normalizedResolve)} to be a subset of ${JSON.stringify(decodedCursor.resolveFingerprint)}`
+    );
+  }
+  return decodedCursor;
+};
 
 // src/tools/subscribe/SubscriptionScope.ts
 var _SubscriptionScope = class _SubscriptionScope {
-  constructor(node, resolve, id, schema, skipRetry = false, bestEffortResolution = false, unstable_branch, callerStack) {
+  constructor(node, resolve, id, schema, skipRetry = false, bestEffortResolution = false, unstable_branch, cursor) {
     this.node = node;
     this.id = id;
     this.schema = schema;
@@ -5705,9 +5810,23 @@ var _SubscriptionScope = class _SubscriptionScope {
     this.silenceUpdates = false;
     this.subscribers = /* @__PURE__ */ new Set();
     this.subscriberChangeCallbacks = /* @__PURE__ */ new Set();
-    this.callerStack = callerStack;
     this.resolve = resolve;
+    this.initialResolve = resolve;
     this.value = { type: CoValueLoadingState.LOADING, id };
+    if (cursor) {
+      if (typeof cursor === "object") {
+        this._cursor = cursor;
+      } else {
+        this._cursor = {
+          encoded: cursor,
+          decoded: decodeAndValidateCursor({
+            rootId: id,
+            cursor,
+            resolve
+          })
+        };
+      }
+    }
     let lastUpdate;
     this.subscription = new CoValueCoreSubscription(
       node,
@@ -5745,7 +5864,8 @@ var _SubscriptionScope = class _SubscriptionScope {
         this.handleUpdate(value);
       },
       skipRetry,
-      this.unstable_branch
+      this.unstable_branch,
+      this._cursor?.decoded
     );
   }
   static setProfilingEnabled(enabled) {
@@ -6167,6 +6287,9 @@ var _SubscriptionScope = class _SubscriptionScope {
     }
     const resolve = this.resolve;
     if (!resolve.$each && !(key in resolve)) {
+      if (this.cursor) {
+        return;
+      }
       resolve[key] = true;
       this.autoloadedKeys.add(key);
     }
@@ -6416,7 +6539,8 @@ var _SubscriptionScope = class _SubscriptionScope {
       descriptor,
       this.skipRetry,
       this.bestEffortResolution,
-      this.unstable_branch
+      this.unstable_branch,
+      isAutoloaded ? void 0 : this._cursor
     );
     this.childNodes.set(id, child);
     child.setListener((value) => this.handleChildUpdate(id, value, key));
@@ -6424,6 +6548,30 @@ var _SubscriptionScope = class _SubscriptionScope {
       child.destroy();
     }
   }
+  *selfAndChildrenFrontiers() {
+    if (this.value.type !== CoValueLoadingState.LOADED) {
+      return;
+    }
+    yield [this.id, this.value.value.$jazz.raw.core.frontier()];
+    for (const child of this.childNodes.values()) {
+      if (this.autoloaded.has(child.id)) {
+        continue;
+      }
+      yield* child.selfAndChildrenFrontiers();
+    }
+  }
+  get cursor() {
+    return this._cursor?.encoded;
+  }
+  createCursor() {
+    return encodeCursor({
+      version: 1,
+      rootId: this.id,
+      // we pass the initial resolve, and not the actual resolve as it may have changed due to autoloading
+      resolveFingerprint: this.initialResolve,
+      frontiers: Object.fromEntries(this.selfAndChildrenFrontiers())
+    });
+  }
   destroy() {
     this.closed = true;
     this.subscription.unsubscribe();
@@ -6926,6 +7074,7 @@ var CoMapSchema = class {
   }
   /**
    * Creates a new CoMap schema by picking the specified keys from the original schema.
+   * The new CoMap will **not** inherit any configurations (migration, catchall, permissions, default resolve query)
    *
    * @param keys - The keys to pick from the original schema.
    * @returns A new CoMap schema with the picked keys.
@@ -6938,10 +7087,45 @@ var CoMapSchema = class {
         pickedShape[key] = value;
       }
     }
-    return coMapDefiner(pickedShape);
+    return this.copy(
+      {
+        shape: pickedShape,
+        permissions: DEFAULT_SCHEMA_PERMISSIONS,
+        resolveQuery: true
+      },
+      {
+        shouldCopyCatchAll: false,
+        shouldCopyMigration: false
+      }
+    );
+  }
+  /**
+   * Creates a new CoMap schema by omitting the specified keys from the original schema.
+   * The new CoMap will **not** inherit any configurations (migration, catchall, permissions, default resolve query)
+   *
+   * @param keys - The keys to omit from the original schema.
+   * @returns A new CoMap schema with the omitted keys.
+   */
+  omit(keys) {
+    const newShape = { ...this.shape };
+    for (const key in keys) {
+      delete newShape[key];
+    }
+    return this.copy(
+      {
+        shape: newShape,
+        permissions: DEFAULT_SCHEMA_PERMISSIONS,
+        resolveQuery: true
+      },
+      {
+        shouldCopyCatchAll: false,
+        shouldCopyMigration: false
+      }
+    );
   }
   /**
    * Creates a new CoMap schema by making all fields optional.
+   * The new CoMap will **not** inherit any configurations (migration, permissions, default resolve query) except catchall
    *
    * @returns A new CoMap schema with all fields optional.
    */
@@ -6958,13 +7142,47 @@ var CoMapSchema = class {
         partialShape[key] = z.optional(this.shape[key]);
       }
     }
-    const partialCoMapSchema = coMapDefiner(partialShape);
-    if (this.catchAll) {
-      return partialCoMapSchema.catchall(
-        this.catchAll
-      );
-    }
-    return partialCoMapSchema;
+    return this.copy(
+      {
+        shape: partialShape,
+        permissions: DEFAULT_SCHEMA_PERMISSIONS,
+        resolveQuery: true
+      },
+      {
+        shouldCopyMigration: false
+      }
+    );
+  }
+  /**
+   * Creates a new CoMap schema by extending the current schema with additional fields.
+   * The new CoMap **will** inherit all configurations (migration, catchall, permissions, default resolve query)
+   *
+   * @param shape - The shape object with additional fields to add to the schema.
+   * @returns A new CoMap schema with the additional fields.
+   */
+  extend(shape) {
+    return this.copy({
+      shape: {
+        ...this.shape,
+        ...shape
+      }
+    });
+  }
+  /**
+   * Creates a new CoMap schema by extending the current schema with additional fields,
+   * while also making sure that no existing fields are accidentally overridden.
+   * The new CoMap **will** inherit all configurations (migration, catchall, permissions, default resolve query)
+   *
+   * @param shape - The shape object with additional fields to add to the schema.
+   * @returns A new CoMap schema with the additional fields.
+   */
+  safeExtend(shape) {
+    return this.copy({
+      shape: {
+        ...this.shape,
+        ...shape
+      }
+    });
   }
   /**
    * Adds a default resolve query to be used when loading instances of this schema.
@@ -6983,14 +7201,21 @@ var CoMapSchema = class {
    * Creates a copy of this schema, preserving all previous configuration
    */
   copy({
+    shape,
     permissions,
     resolveQuery
-  }) {
-    const coreSchema = createCoreCoMapSchema(this.shape, this.catchAll);
+  }, options = {}) {
+    const { shouldCopyCatchAll = true, shouldCopyMigration = true } = options;
+    const coreSchema = createCoreCoMapSchema(
+      shape ?? this.shape,
+      shouldCopyCatchAll ? this.catchAll : void 0
+    );
     const copy = hydrateCoreCoValueSchema(coreSchema);
-    copy.coValueClass.prototype.migrate = this.coValueClass.prototype.migrate;
-    copy.resolveQuery = resolveQuery ?? this.resolveQuery;
+    if (shouldCopyMigration) {
+      copy.coValueClass.prototype.migrate = this.coValueClass.prototype.migrate;
+    }
     __privateSet(copy, _permissions3, permissions ?? __privateGet(this, _permissions3));
+    copy.resolveQuery = resolveQuery ?? this.resolveQuery;
     return copy;
   }
 };
@@ -7605,7 +7830,7 @@ var ImageDefinitionBase = coMapDefiner({
 var ImageDefinition = ImageDefinitionBase;
 
 // src/tools/implementation/ContextManager.ts
-import { cojsonInternals as cojsonInternals5 } from "cojson";
+import { cojsonInternals as cojsonInternals6 } from "cojson";
 
 // src/tools/auth/KvStoreContext.ts
 var KvStoreContext = class _KvStoreContext {
@@ -7636,12 +7861,12 @@ var KvStoreContext = class _KvStoreContext {
 var KvStoreContext_default = KvStoreContext;
 
 // src/tools/auth/AuthSecretStorage.ts
-import { z as z2 } from "zod/v4";
+import { z as z3 } from "zod/v4";
 var STORAGE_KEY = "jazz-logged-in-secret";
 var AuthSecretStorage = class {
   constructor(storageKey = STORAGE_KEY) {
     this.storageKey = storageKey;
-    z2.string().nonempty().parse(storageKey);
+    z3.string().nonempty().parse(storageKey);
     this.listeners = /* @__PURE__ */ new Set();
     this.isAuthenticated = false;
   }
@@ -7722,7 +7947,7 @@ var AuthSecretStorage = class {
     );
   }
   async set(payload) {
-    this.setWithoutNotify(payload);
+    await this.setWithoutNotify(payload);
     this.emitUpdate(payload);
   }
   getIsAuthenticated(data) {
@@ -7806,7 +8031,7 @@ var SubscriptionCache = class {
   /**
    * Check if an entry matches the provided parameters
    */
-  matchesEntry(entry, schema, resolve, branch) {
+  matchesEntry(entry, schema, resolve, branch, cursor) {
     if (entry.schema !== schema) {
       return false;
     }
@@ -7821,19 +8046,22 @@ var SubscriptionCache = class {
     if (entry.branch?.owner?.$jazz.id !== branchOwnerId) {
       return false;
     }
+    if (entry.cursor !== cursor) {
+      return false;
+    }
     return true;
   }
   /**
    * Find a matching cache entry by comparing against entry properties
    * Uses id-based nesting to quickly filter candidates
    */
-  findMatchingEntry(schema, id, resolve, branch) {
+  findMatchingEntry(schema, id, resolve, branch, cursor) {
     const idSet = this.getIdSet(id);
     if (!idSet) {
       return void 0;
     }
     for (const entry of idSet) {
-      if (this.matchesEntry(entry, schema, resolve, branch)) {
+      if (this.matchesEntry(entry, schema, resolve, branch, cursor)) {
         return entry;
       }
     }
@@ -7891,11 +8119,17 @@ var SubscriptionCache = class {
   /**
    * Get or create a SubscriptionScope from the cache
    */
-  getOrCreate(node, schema, id, resolve, skipRetry, bestEffortResolution, branch) {
+  getOrCreate(node, schema, id, resolve, skipRetry, bestEffortResolution, branch, cursor) {
     if (!id) {
       throw new Error("Cannot create subscription with undefined or null id");
     }
-    const matchingEntry = this.findMatchingEntry(schema, id, resolve, branch);
+    const matchingEntry = this.findMatchingEntry(
+      schema,
+      id,
+      resolve,
+      branch,
+      cursor
+    );
     if (matchingEntry) {
       this.cancelCleanup(matchingEntry);
       return matchingEntry.subscriptionScope;
@@ -7911,7 +8145,8 @@ var SubscriptionCache = class {
       refEncoded,
       skipRetry ?? false,
       bestEffortResolution ?? false,
-      branch
+      branch,
+      cursor
     );
     const handleSubscriberChange = (count) => {
       const idSet2 = this.getIdSet(id);
@@ -7924,6 +8159,7 @@ var SubscriptionCache = class {
       schema,
       resolve: copyResolve(resolve),
       branch,
+      cursor,
       subscriberCount: subscriptionScope.subscribers.size,
       unsubscribeFromScope: subscriptionScope.onSubscriberChange(
         handleSubscriberChange
@@ -8183,7 +8419,7 @@ var JazzContextManager = class {
     }
     const currentContext = this.context;
     if (prevContext && currentContext && "me" in prevContext && "me" in currentContext) {
-      const [prevAccountAsPeer, currentAccountAsPeer] = cojsonInternals5.connectedPeers(
+      const [prevAccountAsPeer, currentAccountAsPeer] = cojsonInternals6.connectedPeers(
         prevContext.me.$jazz.id,
         currentContext.me.$jazz.id,
         {
@@ -8340,10 +8576,42 @@ function loadCoValueWithoutMe(cls, id, options) {
   return loadCoValue(cls, id, {
     ...options,
     loadAs: options?.loadAs ?? activeAccountContext.get(),
-    unstable_branch: options?.unstable_branch
+    unstable_branch: options?.unstable_branch,
+    cursor: options?.cursor
   });
 }
-function loadCoValue(cls, id, options) {
+async function loadCoValue(cls, id, options) {
+  let cursor;
+  if (options.cursor) {
+    if (typeof options.cursor === "string") {
+      cursor = options.cursor;
+    } else if (options.cursor.useCurrentCursor) {
+      const loadAs = options.loadAs ?? activeAccountContext.get();
+      const node = "node" in loadAs ? loadAs.node : loadAs.$jazz.localNode;
+      const resolve = options.resolve ?? true;
+      const rootNode = new SubscriptionScope(
+        node,
+        resolve,
+        id,
+        {
+          ref: coValueClassFromCoValueClassOrSchema(cls),
+          optional: false
+        },
+        options.skipRetry,
+        false,
+        options.unstable_branch,
+        void 0
+      );
+      try {
+        await rootNode.getPromise();
+        rootNode.destroy();
+      } catch (error) {
+        rootNode.destroy();
+        throw error;
+      }
+      cursor = rootNode.createCursor();
+    }
+  }
   return new Promise((resolve) => {
     subscribeToCoValue(
       cls,
@@ -8354,7 +8622,8 @@ function loadCoValue(cls, id, options) {
         syncResolution: true,
         skipRetry: options.skipRetry,
         onError: resolve,
-        unstable_branch: options.unstable_branch
+        unstable_branch: options.unstable_branch,
+        cursor
       },
       (value, unsubscribe) => {
         resolve(value);
@@ -8370,7 +8639,8 @@ async function ensureCoValueLoaded(existing, options) {
     {
       loadAs: existing.$jazz.loadedAs,
       resolve: options?.resolve,
-      unstable_branch: options?.unstable_branch
+      unstable_branch: options?.unstable_branch,
+      cursor: options?.cursor
     }
   );
   if (!response.$isLoaded) {
@@ -8388,7 +8658,8 @@ function parseSubscribeRestArgs(args) {
           onError: args[0].onError,
           onUnauthorized: args[0].onUnauthorized,
           onUnavailable: args[0].onUnavailable,
-          unstable_branch: args[0].unstable_branch
+          unstable_branch: args[0].unstable_branch,
+          cursor: args[0].cursor
         },
         listener: args[1]
       };
@@ -8429,7 +8700,8 @@ function subscribeToCoValue(cls, id, options, listener) {
     },
     options.skipRetry,
     false,
-    options.unstable_branch
+    options.unstable_branch,
+    options.cursor
   );
   rootNode.trackLoadingPerformance("subscribe");
   const handleUpdate = () => {
@@ -8476,7 +8748,8 @@ function subscribeToExistingCoValue(existing, options, listener) {
       onError: options?.onError,
       onUnavailable: options?.onUnavailable,
       onUnauthorized: options?.onUnauthorized,
-      unstable_branch: options?.unstable_branch
+      unstable_branch: options?.unstable_branch,
+      cursor: options?.cursor
     },
     listener
   );
@@ -8551,7 +8824,7 @@ function parseGroupCreateOptions(options) {
 function getIdFromHeader(header, loadAs) {
   loadAs ||= activeAccountContext.get();
   const node = loadAs[TypeSym] === "Anonymous" ? loadAs.node : loadAs.$jazz.localNode;
-  return cojsonInternals6.idforHeader(header, node.crypto);
+  return cojsonInternals7.idforHeader(header, node.crypto);
 }
 var coValueTypeSymToHeaderType = {
   CoMap: "comap",
@@ -8607,7 +8880,7 @@ async function internalLoadUnique(cls, options) {
     options.unique,
     options.owner.$jazz.id
   );
-  const id = cojsonInternals6.idforHeader(header, node.crypto);
+  const id = cojsonInternals7.idforHeader(header, node.crypto);
   const maybeLoadedCoValue = await loadCoValueWithoutMe(cls, id, {
     skipRetry: true,
     loadAs
@@ -8898,4 +9171,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-KGV2CJMG.js.map
+//# sourceMappingURL=chunk-WAYFZQXB.js.map