jazz-tools 0.19.7 → 0.19.10

package/dist/{chunk-CUS6O5NE.js → chunk-FFEEPZEG.js}

@@ -3930,7 +3930,8 @@ function applyCoValueMigrations(instance) {
 
 // src/tools/subscribe/CoValueCoreSubscription.ts
 import {
-  cojsonInternals as cojsonInternals4
+  cojsonInternals as cojsonInternals4,
+  isRawCoID
 } from "cojson";
 
 // src/tools/subscribe/types.ts
@@ -3984,101 +3985,62 @@ var CoValueCoreSubscription = class {
    */
   initializeSubscription() {
     const source = this.source;
-    if (source.isAvailable()) {
-      this.handleAvailableSource();
+    if (!isRawCoID(source.id)) {
+      this.emit(CoValueLoadingState.UNAVAILABLE);
       return;
     }
     if (this.branchName) {
-      this.handleBranchCheckout();
+      this.handleBranching(this.branchName, this.branchOwnerId);
       return;
     }
-    this.loadCoValue();
+    this.subscribe(this.source);
   }
-  /**
-   * Handles the case where the CoValue source is immediately available.
-   * Either subscribes directly or attempts to get the requested branch.
-   */
-  handleAvailableSource() {
-    if (!this.branchName || !cojsonInternals4.canBeBranched(this.source)) {
-      this.subscribe(this.source.getCurrentContent());
+  handleBranching(branchName, branchOwnerId) {
+    const source = this.source;
+    if (!source.isAvailable()) {
+      this.waitForSourceToBecomeAvailable(branchName, branchOwnerId);
       return;
     }
-    const branch = this.source.getBranch(this.branchName, this.branchOwnerId);
-    if (branch.isAvailable()) {
-      this.subscribe(branch.getCurrentContent());
+    if (!cojsonInternals4.canBeBranched(source)) {
+      this.subscribe(source);
       return;
-    } else if (!this.source.hasBranch(this.branchName, this.branchOwnerId)) {
-      this.source.createBranch(this.branchName, this.branchOwnerId);
-      this.subscribe(branch.getCurrentContent());
-    } else {
-      this.handleBranchCheckout();
     }
-  }
-  /**
-   * Attempts to checkout a specific branch of the CoValue.
-   * This is called when the source isn't available but a branch is requested.
-   */
-  handleBranchCheckout() {
-    this.localNode.checkoutBranch(this.source.id, this.branchName, this.branchOwnerId).then((value) => {
-      if (this.unsubscribed) return;
-      if (value !== CoValueLoadingState.UNAVAILABLE) {
-        this.subscribe(value);
-      } else {
-        this.handleUnavailableBranch();
+    const branch = source.getBranch(branchName, branchOwnerId);
+    if (!branch.isAvailable() && !source.hasBranch(branchName, branchOwnerId)) {
+      try {
+        source.createBranch(branchName, branchOwnerId);
+      } catch (error) {
+        console.error("error creating branch", error);
+        this.emit(CoValueLoadingState.UNAVAILABLE);
+        return;
       }
-    }).catch((error) => {
-      console.error(error);
-      this.emit(CoValueLoadingState.UNAVAILABLE);
-    });
-  }
-  /**
-   * Handles the case where a branch checkout fails.
-   * Determines whether to retry or report unavailability.
-   */
-  handleUnavailableBranch() {
-    const source = this.source;
-    if (source.isAvailable()) {
-      throw new Error("Branch is unavailable");
     }
-    this.subscribeToUnavailableSource();
-    this.emit(CoValueLoadingState.UNAVAILABLE);
+    this.subscribe(branch);
   }
   /**
-   * Loads the CoValue core from the network/storage.
-   * This is the fallback strategy when immediate availability fails.
+   * Loads a CoValue core and emits an unavailable event if it is still unavailable after the retries.
    */
-  loadCoValue() {
-    this.localNode.loadCoValueCore(this.source.id, void 0, this.skipRetry).then((value) => {
-      if (this.unsubscribed) return;
-      if (value.isAvailable()) {
-        this.subscribe(value.getCurrentContent());
-      } else {
-        this.subscribeToUnavailableSource();
+  load(value) {
+    this.localNode.loadCoValueCore(value.id, void 0, this.skipRetry).then(() => {
+      if (!value.isAvailable()) {
         this.emit(CoValueLoadingState.UNAVAILABLE);
       }
-    }).catch((error) => {
-      console.error(error);
-      this.emit(CoValueLoadingState.UNAVAILABLE);
     });
   }
   /**
-   * Subscribes to state changes of an unavailable CoValue source.
-   * This allows the subscription to become active when the source becomes available after a first loading attempt.
+   * Waits for the source to become available and then tries to branch.
    */
-  subscribeToUnavailableSource() {
+  waitForSourceToBecomeAvailable(branchName, branchOwnerId) {
     const source = this.source;
     const handleStateChange = (_, unsubFromStateChange) => {
       if (!source.isAvailable()) {
         return;
       }
       unsubFromStateChange();
-      if (this.branchName) {
-        this.handleBranchCheckout();
-      } else {
-        this.subscribe(source.getCurrentContent());
-      }
+      this.handleBranching(branchName, branchOwnerId);
     };
     this._unsubscribe = source.subscribe(handleStateChange);
+    this.load(source);
   }
   /**
    * Subscribes to a specific CoValue and notifies the listener.
@@ -4087,16 +4049,30 @@ var CoValueCoreSubscription = class {
   subscribe(value) {
     if (this.unsubscribed) return;
     this._unsubscribe = value.subscribe((value2) => {
-      this.emit(value2);
+      if (value2.isAvailable()) {
+        this.emit(value2.getCurrentContent());
+      }
     });
+    if (!value.isAvailable()) {
+      this.load(value);
+    }
   }
   emit(value) {
     if (this.unsubscribed) return;
-    if (!isReadyForEmit(value)) {
+    if (!this.isReadyForEmit(value)) {
       return;
     }
     this.listener(value);
   }
+  isReadyForEmit(value) {
+    if (value === CoValueLoadingState.UNAVAILABLE) {
+      return true;
+    }
+    if (!isCompletelyDownloaded(value)) {
+      return false;
+    }
+    return true;
+  }
   /**
    * Unsubscribes from all active subscriptions and marks the instance as unsubscribed.
    * This prevents any further operations and ensures proper cleanup.
@@ -4107,10 +4083,7 @@ var CoValueCoreSubscription = class {
     this._unsubscribe();
   }
 };
-function isReadyForEmit(value) {
-  if (value === "unavailable") {
-    return true;
-  }
+function isCompletelyDownloaded(value) {
   return value.core.verified?.header.meta?.type === "binary" || value.core.isCompletelyDownloaded();
 }
 
@@ -4122,16 +4095,17 @@ var JazzError = class _JazzError {
     this.issues = issues;
   }
   toString() {
-    return this.issues.map((issue) => {
+    let result = this.issues.map((issue) => {
       let message = `${issue.message}`;
-      if (this.id) {
-        message += ` from ${this.id}`;
-      }
       if (issue.path.length > 0) {
-        message += ` on path ${issue.path.join(".")}`;
+        if (this.id) {
+          message += `. Subscription starts from ${this.id}`;
+        }
+        message += ` and the value is on path ${issue.path.join(".")}`;
       }
       return message;
     }).join("\n");
+    return result;
   }
   prependPath(item) {
     if (this.issues.length === 0) {
@@ -4147,6 +4121,34 @@ var JazzError = class _JazzError {
   }
 };
 
+// src/tools/subscribe/errorReporting.ts
+var isDev = function() {
+  try {
+    return process.env.NODE_ENV === "development";
+  } catch {
+    return false;
+  }
+}();
+var customErrorReporter;
+var captureErrorCause = isDev;
+function enableCaptureErrorCause(capture) {
+  captureErrorCause = capture;
+}
+function setCustomErrorReporter(reporter) {
+  customErrorReporter = reporter;
+}
+function isCustomErrorReportingEnabled() {
+  return customErrorReporter !== void 0;
+}
+function captureStack() {
+  return captureErrorCause ? new Error() : void 0;
+}
+function captureError(error, props) {
+  if (customErrorReporter) {
+    customErrorReporter(error, props);
+  }
+}
+
 // src/tools/subscribe/utils.ts
 import { RawAccount as RawAccount4 } from "cojson";
 
@@ -4187,10 +4189,52 @@ function createCoValue(ref2, raw, subscriptionScope) {
     id: subscriptionScope.id
   };
 }
+function resolvedPromise(value) {
+  const promise = Promise.resolve(value);
+  promise.status = "fulfilled";
+  promise.value = value;
+  return promise;
+}
+function rejectedPromise(reason) {
+  const promise = Promise.reject(reason);
+  promise.status = "rejected";
+  promise.reason = reason;
+  return promise;
+}
+function isEqualRefsToResolve(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a === "boolean" && typeof b === "boolean") {
+    return a === b;
+  }
+  if (typeof a === "boolean" || typeof b === "boolean") {
+    return false;
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (const key of keysA) {
+    if (!(key in b)) {
+      return false;
+    }
+    const valueA = a[key];
+    const valueB = b[key];
+    if (!isEqualRefsToResolve(valueA, valueB)) {
+      return false;
+    }
+  }
+  return true;
+}
 
 // src/tools/subscribe/SubscriptionScope.ts
 var SubscriptionScope = class _SubscriptionScope {
-  constructor(node, resolve, id, schema, skipRetry = false, bestEffortResolution = false, unstable_branch) {
+  constructor(node, resolve, id, schema, skipRetry = false, bestEffortResolution = false, unstable_branch, callerStack) {
     this.node = node;
     this.id = id;
     this.schema = schema;
@@ -4244,6 +4288,8 @@ var SubscriptionScope = class _SubscriptionScope {
       this.triggerUpdate();
     };
     this.subscribers = /* @__PURE__ */ new Set();
+    this.subscriberChangeCallbacks = /* @__PURE__ */ new Set();
+    this.callerStack = callerStack;
     this.resolve = resolve;
     this.value = { type: CoValueLoadingState.LOADING, id };
     let lastUpdate;
@@ -4281,36 +4327,35 @@ var SubscriptionScope = class _SubscriptionScope {
   handleUpdate(update) {
     if (update === CoValueLoadingState.UNAVAILABLE) {
       if (this.value.type === CoValueLoadingState.LOADING) {
-        this.updateValue(
-          new JazzError(this.id, CoValueLoadingState.UNAVAILABLE, [
-            {
-              code: CoValueLoadingState.UNAVAILABLE,
-              message: "The value is unavailable",
-              params: {
-                id: this.id
-              },
-              path: []
-            }
-          ])
-        );
+        const error = new JazzError(this.id, CoValueLoadingState.UNAVAILABLE, [
+          {
+            code: CoValueLoadingState.UNAVAILABLE,
+            message: `Jazz Unavailable Error: unable to load ${this.id}`,
+            params: {
+              id: this.id
+            },
+            path: []
+          }
+        ]);
+        this.updateValue(error);
       }
       this.triggerUpdate();
       return;
     }
     if (!hasAccessToCoValue(update)) {
       if (this.value.type !== CoValueLoadingState.UNAUTHORIZED) {
-        this.updateValue(
-          new JazzError(this.id, CoValueLoadingState.UNAUTHORIZED, [
-            {
-              code: CoValueLoadingState.UNAUTHORIZED,
-              message: `The current user (${this.node.getCurrentAgent().id}) is not authorized to access this value`,
-              params: {
-                id: this.id
-              },
-              path: []
-            }
-          ])
-        );
+        const message = `Jazz Authorization Error: The current user (${this.node.getCurrentAgent().id}) is not authorized to access ${this.id}`;
+        const error = new JazzError(this.id, CoValueLoadingState.UNAUTHORIZED, [
+          {
+            code: CoValueLoadingState.UNAUTHORIZED,
+            message,
+            params: {
+              id: this.id
+            },
+            path: []
+          }
+        ]);
+        this.updateValue(error);
         this.triggerUpdate();
       }
       return;
@@ -4372,6 +4417,48 @@ var SubscriptionScope = class _SubscriptionScope {
     if (this.value.type !== CoValueLoadingState.LOADED) return true;
     return this.pendingLoadedChildren.size === 0;
   }
+  cachePromise(value, callback) {
+    if (this.lastPromise?.value === value) {
+      return this.lastPromise.promise;
+    }
+    const promise = callback();
+    this.lastPromise = { value, promise };
+    return promise;
+  }
+  getPromise() {
+    const currentValue = this.getCurrentValue();
+    if (currentValue.$isLoaded) {
+      return resolvedPromise(currentValue);
+    }
+    if (currentValue.$jazz.loadingState !== CoValueLoadingState.LOADING) {
+      const error = this.getError();
+      return rejectedPromise(
+        new Error(error?.toString() ?? "Unknown error", {
+          cause: this.callerStack
+        })
+      );
+    }
+    return this.cachePromise(currentValue, () => {
+      return new Promise((resolve, reject) => {
+        const unsubscribe = this.subscribe(() => {
+          const currentValue2 = this.getCurrentValue();
+          if (currentValue2.$jazz.loadingState === CoValueLoadingState.LOADING) {
+            return;
+          }
+          if (currentValue2.$isLoaded) {
+            resolve(currentValue2);
+          } else {
+            reject(
+              new Error(this.getError()?.toString() ?? "Unknown error", {
+                cause: this.callerStack
+              })
+            );
+          }
+          unsubscribe();
+        });
+      });
+    });
+  }
   getUnloadedValue(reason) {
     if (this.unloadedValue?.$jazz.loadingState === reason) {
       return this.unloadedValue;
@@ -4383,20 +4470,19 @@ var SubscriptionScope = class _SubscriptionScope {
   getCurrentValue() {
     const rawValue = this.getCurrentRawValue();
     if (rawValue === CoValueLoadingState.UNAUTHORIZED || rawValue === CoValueLoadingState.UNAVAILABLE || rawValue === CoValueLoadingState.LOADING) {
+      this.logError();
       return this.getUnloadedValue(rawValue);
     }
     return rawValue;
   }
   getCurrentRawValue() {
     if (this.value.type === CoValueLoadingState.UNAUTHORIZED || this.value.type === CoValueLoadingState.UNAVAILABLE) {
-      console.error(this.value.toString());
       return this.value.type;
     }
     if (!this.shouldSendUpdates()) {
       return CoValueLoadingState.LOADING;
     }
     if (this.errorFromChildren) {
-      console.error(this.errorFromChildren.toString());
       return this.errorFromChildren.type;
     }
     if (this.value.type === CoValueLoadingState.LOADED) {
@@ -4404,6 +4490,51 @@ var SubscriptionScope = class _SubscriptionScope {
     }
     return CoValueLoadingState.LOADING;
   }
+  getCreationStackLines() {
+    const stack = this.callerStack?.stack;
+    if (!stack) {
+      return "";
+    }
+    const creationStackLines = stack.split("\n").slice(2, 15);
+    const creationAppFrame = creationStackLines.find(
+      (line) => !line.includes("node_modules") && !line.includes("useCoValueSubscription") && !line.includes("useCoState") && !line.includes("useAccount") && !line.includes("jazz-tools")
+    );
+    let result = "\n\n";
+    if (creationAppFrame) {
+      result += "Subscription created ", result += creationAppFrame.trim();
+    }
+    result += "\nFull subscription creation stack:";
+    for (const line of creationStackLines.slice(0, 8)) {
+      result += "\n    " + line.trim();
+    }
+    return result;
+  }
+  getError() {
+    if (this.value.type === CoValueLoadingState.UNAUTHORIZED || this.value.type === CoValueLoadingState.UNAVAILABLE) {
+      return this.value;
+    }
+    if (this.errorFromChildren) {
+      return this.errorFromChildren;
+    }
+  }
+  logError() {
+    const error = this.getError();
+    if (!error || this.lastErrorLogged === error) {
+      return;
+    }
+    if (error.type === CoValueLoadingState.UNAVAILABLE && this.skipRetry) {
+      return;
+    }
+    this.lastErrorLogged = error;
+    if (isCustomErrorReportingEnabled()) {
+      captureError(new Error(error.toString(), { cause: this.callerStack }), {
+        getPrettyStackTrace: () => this.getCreationStackLines(),
+        jazzError: error
+      });
+    } else {
+      console.error(`${error.toString()}${this.getCreationStackLines()}`);
+    }
+  }
   triggerUpdate() {
     if (!this.shouldSendUpdates()) return;
     if (!this.dirty) return;
@@ -4418,14 +4549,37 @@ var SubscriptionScope = class _SubscriptionScope {
     }
     this.dirty = false;
   }
+  /**
+   * Subscribe to subscriber count changes
+   * Callback receives the total number of subscribers
+   * Returns an unsubscribe function
+   */
+  onSubscriberChange(callback) {
+    this.subscriberChangeCallbacks.add(callback);
+    return () => {
+      this.subscriberChangeCallbacks.delete(callback);
+    };
+  }
+  notifySubscriberChange() {
+    const count = this.subscribers.size;
+    this.subscriberChangeCallbacks.forEach((callback) => {
+      callback(count);
+    });
+  }
   subscribe(listener) {
     this.subscribers.add(listener);
+    this.notifySubscriberChange();
     return () => {
       this.subscribers.delete(listener);
+      this.notifySubscriberChange();
     };
   }
   setListener(listener) {
+    const hadListener = this.subscribers.has(listener);
     this.subscribers.add(listener);
+    if (!hadListener) {
+      this.notifySubscriberChange();
+    }
     this.triggerUpdate();
   }
   subscribeToKey(key) {
@@ -4563,7 +4717,7 @@ var SubscriptionScope = class _SubscriptionScope {
                   new JazzError(void 0, CoValueLoadingState.UNAVAILABLE, [
                     {
                       code: "validationError",
-                      message: `The ref on position ${key} requested on ${stream.constructor.name} is missing`,
+                      message: `Jazz Validation Error: The ref on position ${key} is missing`,
                       params: {},
                       path: [key]
                     }
@@ -4615,7 +4769,7 @@ var SubscriptionScope = class _SubscriptionScope {
           new JazzError(void 0, CoValueLoadingState.UNAVAILABLE, [
             {
               code: "validationError",
-              message: `The ref ${key} requested on ${map.constructor.name} is missing`,
+              message: `Jazz Validation Error: The ref ${key} is required but missing`,
               params: {},
               path: [key]
             }
@@ -4646,7 +4800,7 @@ var SubscriptionScope = class _SubscriptionScope {
         new JazzError(void 0, CoValueLoadingState.UNAVAILABLE, [
           {
             code: "validationError",
-            message: `The ref on position ${key} requested on ${list.constructor.name} is missing`,
+            message: `Jazz Validation Error: The ref on position ${key} is required but missing`,
             params: {},
             path: [key]
           }
@@ -4694,7 +4848,12 @@ var SubscriptionScope = class _SubscriptionScope {
   destroy() {
     this.closed = true;
     this.subscription.unsubscribe();
+    const hadSubscribers = this.subscribers.size > 0;
     this.subscribers.clear();
+    if (hadSubscribers) {
+      this.notifySubscriberChange();
+    }
+    this.subscriberChangeCallbacks.clear();
     this.childNodes.forEach((child) => child.destroy());
   }
 };
@@ -6310,6 +6469,177 @@ var InMemoryKVStore = class {
   }
 };
 
+// src/tools/subscribe/SubscriptionCache.ts
+var SubscriptionCache = class {
+  constructor(cleanupTimeout = 5e3) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.cleanupTimeout = cleanupTimeout;
+  }
+  /**
+   * Get the inner set for a given id (read-only access)
+   */
+  getIdSet(id) {
+    return this.cache.get(id);
+  }
+  /**
+   * Get the inner set for a given id, creating it if it doesn't exist
+   */
+  getIdSetOrCreate(id) {
+    let idSet = this.cache.get(id);
+    if (!idSet) {
+      idSet = /* @__PURE__ */ new Set();
+      this.cache.set(id, idSet);
+    }
+    return idSet;
+  }
+  /**
+   * Check if an entry matches the provided parameters
+   */
+  matchesEntry(entry, schema, resolve, branch) {
+    if (entry.schema !== schema) {
+      return false;
+    }
+    if (!isEqualRefsToResolve(entry.resolve, resolve)) {
+      return false;
+    }
+    const branchName = branch?.name;
+    if (entry.branch?.name !== branchName) {
+      return false;
+    }
+    const branchOwnerId = branch?.owner?.$jazz.id;
+    if (entry.branch?.owner?.$jazz.id !== branchOwnerId) {
+      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) {
+    const idSet = this.getIdSet(id);
+    if (!idSet) {
+      return void 0;
+    }
+    for (const entry of idSet) {
+      if (this.matchesEntry(entry, schema, resolve, branch)) {
+        return entry;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Handle subscriber count changes from SubscriptionScope
+   */
+  handleSubscriberChange(entry, count) {
+    entry.subscriberCount = count;
+    if (count === 0) {
+      this.scheduleCleanup(entry);
+    } else {
+      this.cancelCleanup(entry);
+    }
+  }
+  /**
+   * Schedule cleanup timeout for an entry
+   */
+  scheduleCleanup(entry) {
+    this.cancelCleanup(entry);
+    entry.cleanupTimeoutId = setTimeout(() => {
+      this.destroyEntry(entry);
+    }, this.cleanupTimeout);
+  }
+  /**
+   * Cancel pending cleanup timeout for an entry
+   */
+  cancelCleanup(entry) {
+    if (entry.cleanupTimeoutId !== void 0) {
+      clearTimeout(entry.cleanupTimeoutId);
+      entry.cleanupTimeoutId = void 0;
+    }
+  }
+  /**
+   * Destroy a cache entry and its SubscriptionScope
+   */
+  destroyEntry(entry) {
+    this.cancelCleanup(entry);
+    entry.unsubscribeFromScope();
+    try {
+      entry.subscriptionScope.destroy();
+    } catch (error) {
+      console.error("Error destroying SubscriptionScope:", error);
+    }
+    const id = entry.subscriptionScope.id;
+    const idSet = this.getIdSet(id);
+    if (idSet) {
+      idSet.delete(entry);
+      if (idSet.size === 0) {
+        this.cache.delete(id);
+      }
+    }
+  }
+  /**
+   * Get or create a SubscriptionScope from the cache
+   */
+  getOrCreate(node, schema, id, resolve, skipRetry, bestEffortResolution, branch) {
+    if (!id) {
+      throw new Error("Cannot create subscription with undefined or null id");
+    }
+    const matchingEntry = this.findMatchingEntry(schema, id, resolve, branch);
+    if (matchingEntry) {
+      this.cancelCleanup(matchingEntry);
+      return matchingEntry.subscriptionScope;
+    }
+    const refEncoded = {
+      ref: coValueClassFromCoValueClassOrSchema(schema),
+      optional: true
+    };
+    const subscriptionScope = new SubscriptionScope(
+      node,
+      // @ts-expect-error the SubscriptionScope is too generic for TS to infer its instances are CoValues
+      resolve,
+      id,
+      refEncoded,
+      skipRetry ?? false,
+      bestEffortResolution ?? false,
+      branch
+    );
+    const handleSubscriberChange = (count) => {
+      const idSet2 = this.getIdSet(id);
+      if (idSet2 && idSet2.has(entry)) {
+        this.handleSubscriberChange(entry, count);
+      }
+    };
+    const entry = {
+      subscriptionScope,
+      schema,
+      resolve,
+      branch,
+      subscriberCount: subscriptionScope.subscribers.size,
+      unsubscribeFromScope: subscriptionScope.onSubscriberChange(
+        handleSubscriberChange
+      )
+    };
+    const idSet = this.getIdSetOrCreate(id);
+    idSet.add(entry);
+    return subscriptionScope;
+  }
+  /**
+   * Clear all cache entries and destroy all SubscriptionScope instances
+   */
+  clear() {
+    const entriesToDestroy = [];
+    for (const idSet of this.cache.values()) {
+      for (const entry of idSet) {
+        entriesToDestroy.push(entry);
+      }
+    }
+    for (const entry of entriesToDestroy) {
+      this.destroyEntry(entry);
+    }
+    this.cache.clear();
+  }
+};
+
 // src/tools/implementation/ContextManager.ts
 function getAnonymousFallback() {
   const context = createAnonymousJazzContext({
@@ -6343,6 +6673,7 @@ var JazzContextManager = class {
         return;
       }
       this.authenticatingAccountID = null;
+      this.subscriptionCache.clear();
       await this.props.onLogOut?.();
       if (this.props.logOutReplacement) {
         await this.props.logOutReplacement();
@@ -6440,6 +6771,7 @@ var JazzContextManager = class {
     };
     KvStoreContext.getInstance().initialize(this.getKvStore());
     this.authSecretStorage = new AuthSecretStorage(opts?.authSecretStorageKey);
+    this.subscriptionCache = new SubscriptionCache();
     if (opts?.useAnonymousFallback) {
       this.value = getAnonymousFallback();
     }
@@ -6468,6 +6800,7 @@ var JazzContextManager = class {
     throw new Error("Not implemented");
   }
   async updateContext(props, context, authProps) {
+    this.subscriptionCache.clear();
     if (!this.keepContextOpen) {
       this.context?.done();
     }
@@ -6505,6 +6838,9 @@ var JazzContextManager = class {
   getAuthenticatingAccountID() {
     return this.authenticatingAccountID;
   }
+  getSubscriptionScopeCache() {
+    return this.subscriptionCache;
+  }
   async handleAnonymousAccountMigration(prevContext) {
     if (!this.props) {
       throw new Error("Props required");
@@ -6749,13 +7085,9 @@ function subscribeToCoValue(cls, id, options, listener) {
     switch (value.$jazz.loadingState) {
       case CoValueLoadingState.UNAVAILABLE:
         options.onUnavailable?.(value);
-        if (!options.skipRetry) {
-          console.error(value.toString());
-        }
         break;
       case CoValueLoadingState.UNAUTHORIZED:
         options.onUnauthorized?.(value);
-        console.error(value.toString());
         break;
     }
   };
@@ -6898,17 +7230,14 @@ async function exportCoValue(cls, id, options) {
     options.unstable_branch
   );
   const value = await new Promise((resolve2) => {
-    rootNode.setListener((value2) => {
-      if (value2.type === CoValueLoadingState.UNAVAILABLE) {
-        resolve2(null);
-        console.error(value2.toString());
-      } else if (value2.type === CoValueLoadingState.UNAUTHORIZED) {
+    rootNode.setListener(() => {
+      const value2 = rootNode.getCurrentValue();
+      if (value2.$isLoaded) {
+        resolve2(value2);
+      } else if (value2.$jazz.loadingState === CoValueLoadingState.UNAVAILABLE || value2.$jazz.loadingState === CoValueLoadingState.UNAUTHORIZED) {
         resolve2(null);
-        console.error(value2.toString());
-      } else if (value2.type === CoValueLoadingState.LOADED) {
-        resolve2(value2.value);
+        rootNode.destroy();
       }
-      rootNode.destroy();
     });
   });
   if (!value) {
@@ -7046,6 +7375,9 @@ export {
   Encoders,
   coField,
   CoValueLoadingState,
+  enableCaptureErrorCause,
+  setCustomErrorReporter,
+  captureStack,
   SubscriptionScope,
   randomSessionProvider,
   createJazzContextFromExistingCredentials,
@@ -7062,4 +7394,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-CUS6O5NE.js.map
+//# sourceMappingURL=chunk-FFEEPZEG.js.map