jazz-tools 0.18.38 → 0.19.0

package/dist/{chunk-OSQ7S47Q.js → chunk-P3YLNFN4.js}

@@ -58,6 +58,11 @@ function removeGetters(obj) {
   }
   return result;
 }
+function withSchemaResolveQuery(loadOptions, schemaResolveQuery) {
+  const newOptions = loadOptions ? { ...loadOptions } : {};
+  newOptions.resolve ||= schemaResolveQuery;
+  return newOptions;
+}
 
 // src/tools/implementation/zodSchema/zodReExport.ts
 import {
@@ -130,6 +135,11 @@ import {
 // src/tools/coValues/CoValueBase.ts
 import { ControlledAccount } from "cojson";
 var CoValueBase = class {
+  constructor() {
+    Object.defineProperties(this, {
+      $isLoaded: { value: true, enumerable: false }
+    });
+  }
   /** @category Internals */
   static fromRaw(raw) {
     return new this({ fromRaw: raw });
@@ -161,6 +171,9 @@ var CoValueJazzApi = class {
     }
     return this.raw.id;
   }
+  get loadingState() {
+    return CoValueLoadingState.LOADED;
+  }
   /** @internal */
   get localNode() {
     return this.raw.core.node;
@@ -453,7 +466,7 @@ var _CoMap = class _CoMap extends CoValueBase {
   /**
    * Given some data, updates an existing CoMap or initialises a new one if none exists.
    *
-   * Note: This method respects resolve options, and thus can return `null` if the references cannot be resolved.
+   * Note: This method respects resolve options, and thus can return a not-loaded value if the references cannot be resolved.
    *
    * @example
    * ```ts
@@ -500,7 +513,7 @@ var _CoMap = class _CoMap extends CoValueBase {
    * @param unique The unique identifier of the CoMap to load.
    * @param ownerID The ID of the owner of the CoMap.
    * @param options Additional options for loading the CoMap.
-   * @returns The loaded CoMap, or null if unavailable.
+   * @returns The loaded CoMap, or an not-loaded value if unavailable.
    *
    * @deprecated Use `co.map(...).loadUnique` instead.
    */
@@ -509,7 +522,7 @@ var _CoMap = class _CoMap extends CoValueBase {
     const owner = await Group2.load(ownerID, {
       loadAs: options?.loadAs
     });
-    if (!owner) return owner;
+    if (!owner.$isLoaded) return owner;
     return internalLoadUnique(this, {
       header,
       owner,
@@ -888,7 +901,8 @@ var _CoList = class _CoList extends Array {
         $jazz: {
           value: new CoListJazzApi(proxy, () => options.fromRaw),
           enumerable: false
-        }
+        },
+        $isLoaded: { value: true, enumerable: false }
       });
     }
     return proxy;
@@ -922,7 +936,8 @@ var _CoList = class _CoList extends Array {
       $jazz: {
         value: new CoListJazzApi(instance, () => raw),
         enumerable: false
-      }
+      },
+      $isLoaded: { value: true, enumerable: false }
     });
     const raw = owner.$jazz.raw.createList(
       toRawItems(items, instance.$jazz.schema[ItemsSym], owner),
@@ -1012,7 +1027,7 @@ var _CoList = class _CoList extends Array {
   /**
    * Given some data, updates an existing CoList or initialises a new one if none exists.
    *
-   * Note: This method respects resolve options, and thus can return `null` if the references cannot be resolved.
+   * Note: This method respects resolve options, and thus can return a not-loaded value if the references cannot be resolved.
    *
    * @example
    * ```ts
@@ -1054,14 +1069,14 @@ var _CoList = class _CoList extends Array {
    * @param unique The unique identifier of the CoList to load.
    * @param ownerID The ID of the owner of the CoList.
    * @param options Additional options for loading the CoList.
-   * @returns The loaded CoList, or null if unavailable.
+   * @returns The loaded CoList, or an not-loaded value if unavailable.
    */
   static async loadUnique(unique, ownerID, options) {
     const header = _CoList._getUniqueHeader(unique, ownerID);
     const owner = await Group2.load(ownerID, {
       loadAs: options?.loadAs
     });
-    if (!owner) return owner;
+    if (!owner.$isLoaded) return owner;
     return internalLoadUnique(this, {
       header,
       owner,
@@ -1970,13 +1985,19 @@ var FileStream = class extends CoValueBase {
    */
   static async loadAsBlob(id, options) {
     let stream = await this.load(id, options);
-    return stream?.toBlob({
+    if (!stream.$isLoaded) {
+      return void 0;
+    }
+    return stream.toBlob({
       allowUnfinished: options?.allowUnfinished
     });
   }
   static async loadAsBase64(id, options) {
     const stream = await this.load(id, options);
-    return stream?.asBase64(options);
+    if (!stream.$isLoaded) {
+      return void 0;
+    }
+    return stream.asBase64(options);
   }
   asBase64(options) {
     const chunks = this.getChunks(options);
@@ -2078,7 +2099,7 @@ var FileStream = class extends CoValueBase {
    */
   static async load(id, options) {
     const stream = await loadCoValueWithoutMe(this, id, options);
-    if (!options?.allowUnfinished && !stream?.isBinaryStreamEnded()) {
+    if (!options?.allowUnfinished && stream.$isLoaded && !stream.isBinaryStreamEnded()) {
       return new Promise((resolve) => {
         subscribeToCoValueWithoutMe(
           this,
@@ -2676,7 +2697,7 @@ var _Group = class _Group extends CoValueBase {
     const group = await loadCoValueWithoutMe(this, id, {
       loadAs: options?.loadAs
     });
-    if (!group) {
+    if (!group.$isLoaded) {
       throw new Error(`Group with id ${id} not found`);
     }
     return group.$jazz.createInvite(options?.role ?? "reader");
@@ -2776,10 +2797,21 @@ import {
   RawAccount as RawAccount3
 } from "cojson";
 
-// src/tools/lib/id.ts
+// src/tools/lib/utils.ts
 function isCoValueId(id) {
   return typeof id === "string" && id.startsWith("co_z");
 }
+function assertLoaded(coValue) {
+  if (!coValue.$isLoaded) {
+    throw new Error("CoValue is not loaded");
+  }
+}
+function getLoadedOrUndefined(coValue) {
+  if (!coValue?.$isLoaded) {
+    return void 0;
+  }
+  return coValue;
+}
 
 // src/tools/coValues/inbox.ts
 function createInboxRoot(account) {
@@ -2888,7 +2920,7 @@ var Inbox = class _Inbox {
     const messagesFeed = new IncrementalFeed(this.messages.core);
     const processMessage = async (txKey, messageId) => {
       const message = await node.load(messageId);
-      if (message === "unavailable") {
+      if (message === CoValueLoadingState.UNAVAILABLE) {
         throw new Error(`Inbox: message ${messageId} is unavailable`);
       }
       const value = await loadCoValue(
@@ -2962,7 +2994,7 @@ var Inbox = class _Inbox {
   }
   static async load(account) {
     const profile = account.profile;
-    if (!profile) {
+    if (!profile.$isLoaded) {
       throw new Error("Account profile should already be loaded");
     }
     if (!profile.inbox) {
@@ -2970,7 +3002,7 @@ var Inbox = class _Inbox {
     }
     const node = account.$jazz.localNode;
     const root = await node.load(profile.inbox);
-    if (root === "unavailable") {
+    if (root === CoValueLoadingState.UNAVAILABLE) {
       throw new Error("Inbox not found");
     }
     const [messages, processed, failed] = await Promise.all([
@@ -2978,7 +3010,7 @@ var Inbox = class _Inbox {
       node.load(root.get("processed")),
       node.load(root.get("failed"))
     ]);
-    if (messages === "unavailable" || processed === "unavailable" || failed === "unavailable") {
+    if (messages === CoValueLoadingState.UNAVAILABLE || processed === CoValueLoadingState.UNAVAILABLE || failed === CoValueLoadingState.UNAVAILABLE) {
       throw new Error("Inbox not found");
     }
     await processed.core.waitForFullStreaming();
@@ -3018,11 +3050,11 @@ var InboxSender = class _InboxSender {
     const inboxOwnerRaw = await node.load(
       inboxOwnerID
     );
-    if (inboxOwnerRaw === "unavailable") {
+    if (inboxOwnerRaw === CoValueLoadingState.UNAVAILABLE) {
       throw new Error("Failed to load the inbox owner");
     }
     const inboxOwnerProfileRaw = await node.load(inboxOwnerRaw.get("profile"));
-    if (inboxOwnerProfileRaw === "unavailable") {
+    if (inboxOwnerProfileRaw === CoValueLoadingState.UNAVAILABLE) {
       throw new Error("Failed to load the inbox owner profile");
     }
     const inboxOwnerRole = inboxOwnerProfileRaw.group.roleOf(
@@ -3039,7 +3071,7 @@ var InboxSender = class _InboxSender {
     }
     const id = await acceptInvite(inboxInvite, currentAccount);
     const messages = await node.load(id);
-    if (messages === "unavailable") {
+    if (messages === CoValueLoadingState.UNAVAILABLE) {
       throw new Error("Inbox not found");
     }
     return new _InboxSender(currentAccount, inboxOwnerRaw, messages);
@@ -3085,7 +3117,8 @@ var CoPlainText = class extends String {
         $jazz: {
           value: new CoTextJazzApi(this, raw),
           enumerable: false
-        }
+        },
+        $isLoaded: { value: true, enumerable: false }
       });
       return;
     }
@@ -3097,7 +3130,8 @@ var CoPlainText = class extends String {
         $jazz: {
           value: new CoTextJazzApi(this, raw),
           enumerable: false
-        }
+        },
+        $isLoaded: { value: true, enumerable: false }
       });
       return;
     }
@@ -3341,6 +3375,7 @@ var _CoVector = class _CoVector extends Float32Array {
         value: new CoVectorJazzApi(this, raw),
         enumerable: false
       },
+      $isLoaded: { value: true, enumerable: false },
       _isVectorLoaded: { value: false, enumerable: false, writable: true },
       _requiredDimensionsCount: {
         value: dimensionsCount,
@@ -3441,7 +3476,7 @@ var _CoVector = class _CoVector extends Float32Array {
    */
   static async load(id, options) {
     const coVector = await loadCoValueWithoutMe(this, id, options);
-    if (!coVector?.$jazz.raw.isBinaryStreamEnded()) {
+    if (!coVector.$isLoaded || !coVector.$jazz.raw.isBinaryStreamEnded()) {
       return new Promise((resolve) => {
         subscribeToCoValueWithoutMe(
           this,
@@ -3662,23 +3697,27 @@ var Ref = class {
       node = subscriptionScope.childNodes.get(this.id);
     }
     if (!node) {
-      return null;
+      return createUnloadedCoValue(this.id, CoValueLoadingState.LOADING);
     }
     const value = node.value;
-    if (value?.type === "loaded") {
+    if (value?.type === CoValueLoadingState.LOADED) {
       return value.value;
     } else {
       return new Promise((resolve) => {
         const unsubscribe = node.subscribe((value2) => {
-          if (value2?.type === "loaded") {
+          if (value2?.type === CoValueLoadingState.LOADED) {
             unsubscribe();
             resolve(value2.value);
-          } else if (value2?.type === "unavailable") {
+          } else if (value2?.type === CoValueLoadingState.UNAVAILABLE) {
             unsubscribe();
-            resolve(null);
-          } else if (value2?.type === "unauthorized") {
+            resolve(
+              createUnloadedCoValue(this.id, CoValueLoadingState.UNAVAILABLE)
+            );
+          } else if (value2?.type === CoValueLoadingState.UNAUTHORIZED) {
             unsubscribe();
-            resolve(null);
+            resolve(
+              createUnloadedCoValue(this.id, CoValueLoadingState.UNAUTHORIZED)
+            );
           }
           if (subscriptionScope.closed) {
             node.destroy();
@@ -3855,6 +3894,28 @@ function applyCoValueMigrations(instance) {
 import {
   cojsonInternals as cojsonInternals4
 } from "cojson";
+
+// src/tools/subscribe/types.ts
+var CoValueLoadingState = {
+  /**
+   * The coValue is loaded.
+   */
+  LOADED: "loaded",
+  /**
+   * The coValue is being loaded.
+   */
+  LOADING: "loading",
+  /**
+   * The coValue was loaded but the account is not authorized to access it.
+   */
+  UNAUTHORIZED: "unauthorized",
+  /**
+   * Tried to load the coValue but failed.
+   */
+  UNAVAILABLE: "unavailable"
+};
+
+// src/tools/subscribe/CoValueCoreSubscription.ts
 var CoValueCoreSubscription = class {
   constructor(localNode, id, listener, skipRetry, branch) {
     this._unsubscribe = () => {
@@ -3922,14 +3983,14 @@ var CoValueCoreSubscription = class {
   handleBranchCheckout() {
     this.localNode.checkoutBranch(this.source.id, this.branchName, this.branchOwnerId).then((value) => {
       if (this.unsubscribed) return;
-      if (value !== "unavailable") {
+      if (value !== CoValueLoadingState.UNAVAILABLE) {
         this.subscribe(value);
       } else {
         this.handleUnavailableBranch();
       }
     }).catch((error) => {
       console.error(error);
-      this.emit("unavailable");
+      this.emit(CoValueLoadingState.UNAVAILABLE);
     });
   }
   /**
@@ -3942,7 +4003,7 @@ var CoValueCoreSubscription = class {
       throw new Error("Branch is unavailable");
     }
     this.subscribeToUnavailableSource();
-    this.emit("unavailable");
+    this.emit(CoValueLoadingState.UNAVAILABLE);
   }
   /**
    * Loads the CoValue core from the network/storage.
@@ -3955,11 +4016,11 @@ var CoValueCoreSubscription = class {
         this.subscribe(value.getCurrentContent());
       } else {
         this.subscribeToUnavailableSource();
-        this.emit("unavailable");
+        this.emit(CoValueLoadingState.UNAVAILABLE);
       }
     }).catch((error) => {
       console.error(error);
-      this.emit("unavailable");
+      this.emit(CoValueLoadingState.UNAVAILABLE);
     });
   }
   /**
@@ -4083,7 +4144,7 @@ function createCoValue(ref2, raw, subscriptionScope) {
     configurable: false
   });
   return {
-    type: "loaded",
+    type: CoValueLoadingState.LOADED,
     value: freshValueInstance,
     id: subscriptionScope.id
   };
@@ -4121,13 +4182,13 @@ var SubscriptionScope = class _SubscriptionScope {
     this.closed = false;
     this.silenceUpdates = false;
     this.handleChildUpdate = (id, value, key) => {
-      if (value.type === "unloaded") {
+      if (value.type === CoValueLoadingState.LOADING) {
         return;
       }
       this.pendingLoadedChildren.delete(id);
       this.pendingAutoloadedChildren.delete(id);
       this.childValues.set(id, value);
-      if (value.type === "unavailable" || value.type === "unauthorized") {
+      if (value.type === CoValueLoadingState.UNAVAILABLE || value.type === CoValueLoadingState.UNAUTHORIZED) {
         this.childErrors.set(id, value.prependPath(key ?? id));
         this.errorFromChildren = this.computeChildErrors();
       } else if (this.errorFromChildren && this.childErrors.has(id)) {
@@ -4135,7 +4196,7 @@ var SubscriptionScope = class _SubscriptionScope {
         this.errorFromChildren = this.computeChildErrors();
       }
       if (this.shouldSendUpdates()) {
-        if (this.value.type === "loaded") {
+        if (this.value.type === CoValueLoadingState.LOADED) {
           this.updateValue(
             createCoValue(this.schema, this.value.value.$jazz.raw, this)
           );
@@ -4145,18 +4206,18 @@ var SubscriptionScope = class _SubscriptionScope {
     };
     this.subscribers = /* @__PURE__ */ new Set();
     this.resolve = resolve;
-    this.value = { type: "unloaded", id };
+    this.value = { type: CoValueLoadingState.LOADING, id };
     let lastUpdate;
     this.subscription = new CoValueCoreSubscription(
       node,
       id,
       (value) => {
         lastUpdate = value;
-        if (skipRetry && value === "unavailable") {
+        if (skipRetry && value === CoValueLoadingState.UNAVAILABLE) {
           this.handleUpdate(value);
           return;
         }
-        if (!this.migrated && value !== "unavailable") {
+        if (!this.migrated && value !== CoValueLoadingState.UNAVAILABLE) {
           if (this.migrating) {
             return;
           }
@@ -4179,12 +4240,12 @@ var SubscriptionScope = class _SubscriptionScope {
     this.dirty = true;
   }
   handleUpdate(update) {
-    if (update === "unavailable") {
-      if (this.value.type === "unloaded") {
+    if (update === CoValueLoadingState.UNAVAILABLE) {
+      if (this.value.type === CoValueLoadingState.LOADING) {
         this.updateValue(
-          new JazzError(this.id, "unavailable", [
+          new JazzError(this.id, CoValueLoadingState.UNAVAILABLE, [
             {
-              code: "unavailable",
+              code: CoValueLoadingState.UNAVAILABLE,
               message: "The value is unavailable",
               params: {
                 id: this.id
@@ -4200,11 +4261,11 @@ var SubscriptionScope = class _SubscriptionScope {
     const ruleset = update.core.verified.header.ruleset;
     const hasAccess = ruleset.type !== "ownedByGroup" || myRoleForRawValue(update) !== void 0;
     if (!hasAccess) {
-      if (this.value.type !== "unauthorized") {
+      if (this.value.type !== CoValueLoadingState.UNAUTHORIZED) {
         this.updateValue(
-          new JazzError(this.id, "unauthorized", [
+          new JazzError(this.id, CoValueLoadingState.UNAUTHORIZED, [
             {
-              code: "unauthorized",
+              code: CoValueLoadingState.UNAUTHORIZED,
               message: `The current user (${this.node.getCurrentAgent().id}) is not authorized to access this value`,
               params: {
                 id: this.id
@@ -4218,7 +4279,7 @@ var SubscriptionScope = class _SubscriptionScope {
       return;
     }
     this.silenceUpdates = true;
-    if (this.value.type !== "loaded") {
+    if (this.value.type !== CoValueLoadingState.LOADED) {
       this.updateValue(createCoValue(this.schema, update, this));
       this.loadChildren();
     } else {
@@ -4237,7 +4298,7 @@ var SubscriptionScope = class _SubscriptionScope {
   }
   computeChildErrors() {
     let issues = [];
-    let errorType = "unavailable";
+    let errorType = CoValueLoadingState.UNAVAILABLE;
     if (this.childErrors.size === 0 && this.validationErrors.size === 0) {
       return void 0;
     }
@@ -4271,26 +4332,26 @@ var SubscriptionScope = class _SubscriptionScope {
     return void 0;
   }
   shouldSendUpdates() {
-    if (this.value.type === "unloaded") return false;
-    if (this.value.type !== "loaded") return true;
+    if (this.value.type === CoValueLoadingState.LOADING) return false;
+    if (this.value.type !== CoValueLoadingState.LOADED) return true;
     return this.pendingLoadedChildren.size === 0;
   }
   getCurrentValue() {
-    if (this.value.type === "unauthorized" || this.value.type === "unavailable") {
+    if (this.value.type === CoValueLoadingState.UNAUTHORIZED || this.value.type === CoValueLoadingState.UNAVAILABLE) {
       console.error(this.value.toString());
-      return null;
+      return this.value.type;
     }
     if (!this.shouldSendUpdates()) {
-      return void 0;
+      return CoValueLoadingState.LOADING;
     }
     if (this.errorFromChildren) {
       console.error(this.errorFromChildren.toString());
-      return null;
+      return this.errorFromChildren.type;
     }
-    if (this.value.type === "loaded") {
+    if (this.value.type === CoValueLoadingState.LOADED) {
       return this.value.value;
     }
-    return void 0;
+    return CoValueLoadingState.LOADING;
   }
   triggerUpdate() {
     if (!this.shouldSendUpdates()) return;
@@ -4301,7 +4362,7 @@ var SubscriptionScope = class _SubscriptionScope {
     const value = this.value;
     if (error) {
       this.subscribers.forEach((listener) => listener(error));
-    } else if (value.type !== "unloaded") {
+    } else if (value.type !== CoValueLoadingState.LOADING) {
       this.subscribers.forEach((listener) => listener(value));
     }
     this.dirty = false;
@@ -4320,12 +4381,12 @@ var SubscriptionScope = class _SubscriptionScope {
     if (this.resolve === true || !this.resolve) {
       this.resolve = {};
     }
-    if (!this.resolve.$each && !(key in this.resolve)) {
-      const resolve = this.resolve;
+    const resolve = this.resolve;
+    if (!resolve.$each && !(key in resolve)) {
       resolve[key] = true;
       this.autoloadedKeys.add(key);
     }
-    if (this.value.type !== "loaded") {
+    if (this.value.type !== CoValueLoadingState.LOADED) {
       return;
     }
     const value = this.value.value;
@@ -4351,14 +4412,14 @@ var SubscriptionScope = class _SubscriptionScope {
     if (!this.closed) {
       throw new Error("Cannot pull a non-closed subscription scope");
     }
-    if (this.value.type === "loaded") {
+    if (this.value.type === CoValueLoadingState.LOADED) {
       return;
     }
     this.subscription.pullValue();
     const value = this.getCurrentValue();
-    if (value) {
+    if (typeof value !== "string") {
       listener({
-        type: "loaded",
+        type: CoValueLoadingState.LOADED,
         value,
         id: this.id
       });
@@ -4397,7 +4458,7 @@ var SubscriptionScope = class _SubscriptionScope {
   }
   loadChildren() {
     const { resolve } = this;
-    if (this.value.type !== "loaded") {
+    if (this.value.type !== CoValueLoadingState.LOADED) {
       return false;
     }
     const value = this.value.value;
@@ -4448,7 +4509,7 @@ var SubscriptionScope = class _SubscriptionScope {
               } else if (!descriptor.optional) {
                 this.validationErrors.set(
                   key,
-                  new JazzError(void 0, "unavailable", [
+                  new JazzError(void 0, CoValueLoadingState.UNAVAILABLE, [
                     {
                       code: "validationError",
                       message: `The ref on position ${key} requested on ${stream.constructor.name} is missing`,
@@ -4488,7 +4549,7 @@ var SubscriptionScope = class _SubscriptionScope {
     if (!descriptor) {
       this.childErrors.set(
         key,
-        new JazzError(void 0, "unavailable", [
+        new JazzError(void 0, CoValueLoadingState.UNAVAILABLE, [
           {
             code: "validationError",
             message: `The ref ${key} requested on ${map.constructor.name} is not defined in the schema`,
@@ -4507,7 +4568,7 @@ var SubscriptionScope = class _SubscriptionScope {
       } else if (!descriptor.optional) {
         this.validationErrors.set(
           key,
-          new JazzError(void 0, "unavailable", [
+          new JazzError(void 0, CoValueLoadingState.UNAVAILABLE, [
             {
               code: "validationError",
               message: `The ref ${key} requested on ${map.constructor.name} is missing`,
@@ -4538,7 +4599,7 @@ var SubscriptionScope = class _SubscriptionScope {
     } else if (!descriptor.optional) {
       this.validationErrors.set(
         key,
-        new JazzError(void 0, "unavailable", [
+        new JazzError(void 0, CoValueLoadingState.UNAVAILABLE, [
           {
             code: "validationError",
             message: `The ref on position ${key} requested on ${list.constructor.name} is missing`,
@@ -4558,7 +4619,7 @@ var SubscriptionScope = class _SubscriptionScope {
     if (isAutoloaded) {
       this.autoloaded.add(id);
     }
-    const skipInvalid = typeof query === "object" && query.$onError === null;
+    const skipInvalid = typeof query === "object" && query.$onError === "catch";
     if (skipInvalid) {
       if (key) {
         this.skipInvalidKeys.add(key);
@@ -4627,20 +4688,26 @@ function accessChildByKey(parent, childId, key) {
     );
   }
   const value = subscriptionScope.childValues.get(childId);
-  if (value?.type === "loaded") {
+  if (value?.type === CoValueLoadingState.LOADED) {
     return value.value;
   } else {
-    return null;
+    return createUnloadedCoValue(
+      childId,
+      value?.type ?? CoValueLoadingState.LOADING
+    );
   }
 }
 function accessChildById(parent, childId, schema) {
   const subscriptionScope = getSubscriptionScope(parent);
   subscriptionScope.subscribeToId(childId, schema);
   const value = subscriptionScope.childValues.get(childId);
-  if (value?.type === "loaded") {
+  if (value?.type === CoValueLoadingState.LOADED) {
     return value.value;
   } else {
-    return null;
+    return createUnloadedCoValue(
+      childId,
+      value?.type ?? CoValueLoadingState.LOADING
+    );
   }
 }
 
@@ -4827,6 +4894,7 @@ var CoDiscriminatedUnionSchema = class {
     this.coValueClass = coValueClass;
     this.collaborative = true;
     this.builtin = "CoDiscriminatedUnion";
+    this.resolveQuery = true;
     this.getDefinition = coreSchema.getDefinition;
   }
   load(id, options) {
@@ -4868,7 +4936,8 @@ function createCoreCoDiscriminatedUnionSchema(discriminator, schemas) {
       get options() {
         return schemas;
       }
-    })
+    }),
+    resolveQuery: true
   };
 }
 
@@ -4881,6 +4950,7 @@ var CoOptionalSchema = class {
     this.getDefinition = () => ({
       innerType: this.innerType
     });
+    this.resolveQuery = true;
   }
   getCoValueClass() {
     return this.innerType.getCoValueClass();
@@ -4891,7 +4961,8 @@ var CoOptionalSchema = class {
 function createCoreCoRichTextSchema() {
   return {
     collaborative: true,
-    builtin: "CoRichText"
+    builtin: "CoRichText",
+    resolveQuery: true
   };
 }
 var RichTextSchema = class {
@@ -4899,6 +4970,7 @@ var RichTextSchema = class {
     this.coValueClass = coValueClass;
     this.collaborative = true;
     this.builtin = "CoRichText";
+    this.resolveQuery = true;
   }
   create(text, options) {
     return this.coValueClass.create(text, options);
@@ -4910,7 +4982,7 @@ var RichTextSchema = class {
     return this.coValueClass.subscribe(...args);
   }
   unstable_merge(id, options) {
-    return unstable_mergeBranchWithResolve2(this.coValueClass, id, options);
+    return unstable_mergeBranchWithResolve(this.coValueClass, id, options);
   }
   getCoValueClass() {
     return this.coValueClass;
@@ -4924,13 +4996,15 @@ var RichTextSchema = class {
 function createCoreGroupSchema() {
   return {
     collaborative: true,
-    builtin: "Group"
+    builtin: "Group",
+    resolveQuery: true
   };
 }
 var GroupSchema = class {
   constructor() {
     this.collaborative = true;
     this.builtin = "Group";
+    this.resolveQuery = true;
   }
   getCoValueClass() {
     return Group2;
@@ -5062,11 +5136,13 @@ var coDiscriminatedUnionDefiner = (discriminator, schemas) => {
 // src/tools/implementation/zodSchema/coExport.ts
 var coExport_exports = {};
 __export(coExport_exports, {
+  Account: () => AccountSchema,
   DiscriminatedUnion: () => CoDiscriminatedUnionSchema,
   Feed: () => CoFeedSchema,
   FileStream: () => FileStreamSchema,
   Group: () => GroupSchema,
   List: () => CoListSchema,
+  Map: () => CoMapSchema,
   Optional: () => CoOptionalSchema,
   PlainText: () => PlainTextSchema,
   RichText: () => RichTextSchema,
@@ -5088,6 +5164,156 @@ __export(coExport_exports, {
 });
 
 // src/tools/implementation/zodSchema/schemaTypes/CoMapSchema.ts
+var CoMapSchema = class _CoMapSchema {
+  constructor(coreSchema, coValueClass) {
+    this.coValueClass = coValueClass;
+    this.collaborative = true;
+    this.builtin = "CoMap";
+    /**
+     * Default resolve query to be used when loading instances of this schema.
+     * This resolve query will be used when no resolve query is provided to the load method.
+     * @default true
+     */
+    this.resolveQuery = true;
+    this.shape = coreSchema.shape;
+    this.catchAll = coreSchema.catchAll;
+    this.getDefinition = coreSchema.getDefinition;
+  }
+  create(...args) {
+    return this.coValueClass.create(...args);
+  }
+  load(id, options) {
+    return this.coValueClass.load(
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery)
+    );
+  }
+  unstable_merge(id, options) {
+    return unstable_mergeBranchWithResolve(
+      this.coValueClass,
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery)
+    );
+  }
+  subscribe(id, options, listener) {
+    return this.coValueClass.subscribe(
+      id,
+      withSchemaResolveQuery(options, this.resolveQuery),
+      listener
+    );
+  }
+  /** @deprecated Use `CoMap.upsertUnique` and `CoMap.loadUnique` instead. */
+  findUnique(unique, ownerID, as) {
+    return this.coValueClass.findUnique(unique, ownerID, as);
+  }
+  upsertUnique(options) {
+    return this.coValueClass.upsertUnique(
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery)
+    );
+  }
+  loadUnique(unique, ownerID, options) {
+    return this.coValueClass.loadUnique(
+      unique,
+      ownerID,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery)
+    );
+  }
+  /**
+   * @deprecated `co.map().catchall` will be removed in an upcoming version.
+   *
+   * Use a `co.record` nested inside a `co.map` if you need to store key-value properties.
+   *
+   * @example
+   * ```ts
+   * // Instead of:
+   * const Image = co.map({
+   *   original: co.fileStream(),
+   * }).catchall(co.fileStream());
+   *
+   * // Use:
+   * const Image = co.map({
+   *   original: co.fileStream(),
+   *   resolutions: co.record(z.string(), co.fileStream()),
+   * });
+   * ```
+   */
+  catchall(schema) {
+    const schemaWithCatchAll = createCoreCoMapSchema(this.shape, schema);
+    return hydrateCoreCoValueSchema(schemaWithCatchAll);
+  }
+  withMigration(migration) {
+    this.coValueClass.prototype.migrate = migration;
+    return this;
+  }
+  getCoValueClass() {
+    return this.coValueClass;
+  }
+  optional() {
+    return coOptionalDefiner(this);
+  }
+  /**
+   * Creates a new CoMap schema by picking the specified keys from the original schema.
+   *
+   * @param keys - The keys to pick from the original schema.
+   * @returns A new CoMap schema with the picked keys.
+   */
+  pick(keys) {
+    const keysSet = new Set(Object.keys(keys));
+    const pickedShape = {};
+    for (const [key, value] of Object.entries(this.shape)) {
+      if (keysSet.has(key)) {
+        pickedShape[key] = value;
+      }
+    }
+    return coMapDefiner(pickedShape);
+  }
+  /**
+   * Creates a new CoMap schema by making all fields optional.
+   *
+   * @returns A new CoMap schema with all fields optional.
+   */
+  partial(keys) {
+    const partialShape = {};
+    for (const [key, value] of Object.entries(this.shape)) {
+      if (keys && !keys[key]) {
+        partialShape[key] = value;
+        continue;
+      }
+      if (isAnyCoValueSchema2(value)) {
+        partialShape[key] = coOptionalDefiner(value);
+      } else {
+        partialShape[key] = z.optional(this.shape[key]);
+      }
+    }
+    const partialCoMapSchema = coMapDefiner(partialShape);
+    if (this.catchAll) {
+      return partialCoMapSchema.catchall(
+        this.catchAll
+      );
+    }
+    return partialCoMapSchema;
+  }
+  /**
+   * Adds a default resolve query to be used when loading instances of this schema.
+   * This resolve query will be used when no resolve query is provided to the load method.
+   */
+  resolved(resolveQuery) {
+    const coreSchema = createCoreCoMapSchema(
+      this.shape,
+      this.catchAll
+    );
+    const copy = new _CoMapSchema(
+      coreSchema,
+      this.coValueClass
+    );
+    copy.resolveQuery = resolveQuery;
+    return copy;
+  }
+};
 function createCoreCoMapSchema(shape, catchAll) {
   return {
     collaborative: true,
@@ -5115,103 +5341,49 @@ function createCoreCoMapSchema(shape, catchAll) {
         }
         return propValues;
       }
-    })
+    }),
+    resolveQuery: true
   };
 }
-function enrichCoMapSchema(schema, coValueClass) {
-  const coValueSchema = Object.assign(schema, {
-    create: (...args) => {
-      return coValueClass.create(...args);
-    },
-    load: (...args) => {
-      return coValueClass.load(...args);
-    },
-    subscribe: (...args) => {
-      return coValueClass.subscribe(...args);
-    },
-    findUnique: (...args) => {
-      return coValueClass.findUnique(...args);
-    },
-    upsertUnique: (...args) => {
-      return coValueClass.upsertUnique(...args);
-    },
-    loadUnique: (...args) => {
-      return coValueClass.loadUnique(...args);
-    },
-    unstable_merge: (...args) => {
-      return unstable_mergeBranchWithResolve2(coValueClass, ...args);
-    },
-    catchall: (catchAll) => {
-      const schemaWithCatchAll = createCoreCoMapSchema(
-        coValueSchema.getDefinition().shape,
-        catchAll
-      );
-      return hydrateCoreCoValueSchema(schemaWithCatchAll);
-    },
-    withMigration: (migration) => {
-      coValueClass.prototype.migrate = migration;
-      return coValueSchema;
-    },
-    getCoValueClass: () => {
-      return coValueClass;
-    },
-    optional: () => {
-      return coOptionalDefiner(coValueSchema);
-    },
-    pick: (keys) => {
-      const keysSet = new Set(Object.keys(keys));
-      const pickedShape = {};
-      for (const [key, value] of Object.entries(coValueSchema.shape)) {
-        if (keysSet.has(key)) {
-          pickedShape[key] = value;
-        }
-      }
-      return coMapDefiner(pickedShape);
-    },
-    partial: (keys) => {
-      const partialShape = {};
-      for (const [key, value] of Object.entries(coValueSchema.shape)) {
-        if (keys && !keys[key]) {
-          partialShape[key] = value;
-          continue;
-        }
-        if (isAnyCoValueSchema2(value)) {
-          partialShape[key] = coOptionalDefiner(value);
-        } else {
-          partialShape[key] = z.optional(coValueSchema.shape[key]);
-        }
-      }
-      const partialCoMapSchema = coMapDefiner(partialShape);
-      if (coValueSchema.catchAll) {
-        return partialCoMapSchema.catchall(
-          coValueSchema.catchAll
-        );
-      }
-      return partialCoMapSchema;
-    }
-  });
-  return coValueSchema;
-}
 
 // src/tools/implementation/zodSchema/schemaTypes/CoListSchema.ts
-var CoListSchema = class {
+var CoListSchema = class _CoListSchema {
   constructor(element, coValueClass) {
     this.element = element;
     this.coValueClass = coValueClass;
     this.collaborative = true;
     this.builtin = "CoList";
+    /**
+     * Default resolve query to be used when loading instances of this schema.
+     * This resolve query will be used when no resolve query is provided to the load method.
+     * @default true
+     */
+    this.resolveQuery = true;
   }
   create(items, options) {
     return this.coValueClass.create(items, options);
   }
   load(id, options) {
-    return this.coValueClass.load(id, options);
+    return this.coValueClass.load(
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery)
+    );
   }
   unstable_merge(id, options) {
-    return unstable_mergeBranchWithResolve2(this.coValueClass, id, options);
+    return unstable_mergeBranchWithResolve(
+      this.coValueClass,
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery)
+    );
   }
   subscribe(id, options, listener) {
-    return this.coValueClass.subscribe(id, options, listener);
+    return this.coValueClass.subscribe(
+      id,
+      withSchemaResolveQuery(options, this.resolveQuery),
+      listener
+    );
   }
   getCoValueClass() {
     return this.coValueClass;
@@ -5221,42 +5393,81 @@ var CoListSchema = class {
     return this.coValueClass.findUnique(unique, ownerID, as);
   }
   upsertUnique(options) {
-    return this.coValueClass.upsertUnique(options);
+    return this.coValueClass.upsertUnique(
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery)
+    );
   }
   loadUnique(unique, ownerID, options) {
-    return this.coValueClass.loadUnique(unique, ownerID, options);
+    return this.coValueClass.loadUnique(
+      unique,
+      ownerID,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery)
+    );
   }
   optional() {
     return coOptionalDefiner(this);
   }
+  /**
+   * Adds a default resolve query to be used when loading instances of this schema.
+   * This resolve query will be used when no resolve query is provided to the load method.
+   */
+  resolved(resolveQuery) {
+    const copy = new _CoListSchema(this.element, this.coValueClass);
+    copy.resolveQuery = resolveQuery;
+    return copy;
+  }
 };
 function createCoreCoListSchema(element) {
   return {
     collaborative: true,
     builtin: "CoList",
-    element
+    element,
+    resolveQuery: true
   };
 }
 
 // src/tools/implementation/zodSchema/schemaTypes/CoFeedSchema.ts
-var CoFeedSchema = class {
+var CoFeedSchema = class _CoFeedSchema {
   constructor(element, coValueClass) {
     this.element = element;
     this.coValueClass = coValueClass;
     this.collaborative = true;
     this.builtin = "CoFeed";
+    /**
+     * Default resolve query to be used when loading instances of this schema.
+     * This resolve query will be used when no resolve query is provided to the load method.
+     * @default true
+     */
+    this.resolveQuery = true;
   }
   create(init, options) {
     return this.coValueClass.create(init, options);
   }
   load(id, options) {
-    return this.coValueClass.load(id, options);
+    return this.coValueClass.load(
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery)
+    );
   }
   unstable_merge(id, options) {
-    return unstable_mergeBranchWithResolve2(this.coValueClass, id, options);
+    return unstable_mergeBranchWithResolve(
+      this.coValueClass,
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery)
+    );
   }
-  subscribe(...args) {
-    return this.coValueClass.subscribe(...args);
+  subscribe(id, ...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return this.coValueClass.subscribe(
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery),
+      listener
+    );
   }
   getCoValueClass() {
     return this.coValueClass;
@@ -5264,12 +5475,22 @@ var CoFeedSchema = class {
   optional() {
     return coOptionalDefiner(this);
   }
+  /**
+   * Adds a default resolve query to be used when loading instances of this schema.
+   * This resolve query will be used when no resolve query is provided to the load method.
+   */
+  resolved(resolveQuery) {
+    const copy = new _CoFeedSchema(this.element, this.coValueClass);
+    copy.resolveQuery = resolveQuery;
+    return copy;
+  }
 };
 function createCoreCoFeedSchema(element) {
   return {
     collaborative: true,
     builtin: "CoFeed",
-    element
+    element,
+    resolveQuery: true
   };
 }
 
@@ -5277,7 +5498,8 @@ function createCoreCoFeedSchema(element) {
 function createCoreCoPlainTextSchema() {
   return {
     collaborative: true,
-    builtin: "CoPlainText"
+    builtin: "CoPlainText",
+    resolveQuery: true
   };
 }
 var PlainTextSchema = class {
@@ -5285,6 +5507,7 @@ var PlainTextSchema = class {
     this.coValueClass = coValueClass;
     this.collaborative = true;
     this.builtin = "CoPlainText";
+    this.resolveQuery = true;
   }
   create(text, options) {
     return this.coValueClass.create(text, options);
@@ -5296,7 +5519,7 @@ var PlainTextSchema = class {
     return this.coValueClass.subscribe(...args);
   }
   unstable_merge(id, options) {
-    return unstable_mergeBranchWithResolve2(this.coValueClass, id, options);
+    return unstable_mergeBranchWithResolve(this.coValueClass, id, options);
   }
   fromRaw(raw) {
     return this.coValueClass.fromRaw(raw);
@@ -5313,7 +5536,8 @@ var PlainTextSchema = class {
 function createCoreFileStreamSchema() {
   return {
     collaborative: true,
-    builtin: "FileStream"
+    builtin: "FileStream",
+    resolveQuery: true
   };
 }
 var FileStreamSchema = class {
@@ -5321,6 +5545,7 @@ var FileStreamSchema = class {
     this.coValueClass = coValueClass;
     this.collaborative = true;
     this.builtin = "FileStream";
+    this.resolveQuery = true;
   }
   create(options) {
     return this.coValueClass.create(options);
@@ -5338,7 +5563,7 @@ var FileStreamSchema = class {
     return this.coValueClass.load(id, options);
   }
   unstable_merge(id, options) {
-    return unstable_mergeBranchWithResolve2(this.coValueClass, id, options);
+    return unstable_mergeBranchWithResolve(this.coValueClass, id, options);
   }
   subscribe(...args) {
     return this.coValueClass.subscribe(...args);
@@ -5356,7 +5581,8 @@ function createCoreCoVectorSchema(dimensions) {
   return {
     collaborative: true,
     builtin: "CoVector",
-    dimensions
+    dimensions,
+    resolveQuery: true
   };
 }
 var CoVectorSchema = class {
@@ -5365,6 +5591,7 @@ var CoVectorSchema = class {
     this.coValueClass = coValueClass;
     this.collaborative = true;
     this.builtin = "CoVector";
+    this.resolveQuery = true;
   }
   create(vector, options) {
     return this.coValueClass.create(vector, options);
@@ -5387,48 +5614,84 @@ var CoVectorSchema = class {
 };
 
 // src/tools/implementation/zodSchema/schemaTypes/AccountSchema.ts
+var AccountSchema = class _AccountSchema {
+  constructor(coreSchema, coValueClass) {
+    this.coValueClass = coValueClass;
+    this.collaborative = true;
+    this.builtin = "Account";
+    /**
+     * Default resolve query to be used when loading instances of this schema.
+     * This resolve query will be used when no resolve query is provided to the load method.
+     * @default true
+     */
+    this.resolveQuery = true;
+    this.shape = coreSchema.shape;
+    this.getDefinition = coreSchema.getDefinition;
+  }
+  create(options) {
+    return this.coValueClass.create(options);
+  }
+  load(id, options) {
+    return this.coValueClass.load(
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery)
+    );
+  }
+  /** @internal */
+  createAs(as, options) {
+    return this.coValueClass.createAs(as, options);
+  }
+  unstable_merge(id, options) {
+    return unstable_mergeBranchWithResolve(
+      this.coValueClass,
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery)
+    );
+  }
+  subscribe(id, options, listener) {
+    return this.coValueClass.subscribe(
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery),
+      listener
+    );
+  }
+  getMe() {
+    return this.coValueClass.getMe();
+  }
+  withMigration(migration) {
+    this.coValueClass.prototype.migrate = async function(creationProps) {
+      await migration(this, creationProps);
+    };
+    return this;
+  }
+  getCoValueClass() {
+    return this.coValueClass;
+  }
+  optional() {
+    return coOptionalDefiner(this);
+  }
+  /**
+   * Adds a default resolve query to be used when loading instances of this schema.
+   * This resolve query will be used when no resolve query is provided to the load method.
+   */
+  resolved(resolveQuery) {
+    const coreSchema = createCoreAccountSchema(
+      this.shape
+    );
+    const copy = new _AccountSchema(coreSchema, this.coValueClass);
+    copy.resolveQuery = resolveQuery;
+    return copy;
+  }
+};
 function createCoreAccountSchema(shape) {
   return {
     ...createCoreCoMapSchema(shape),
     builtin: "Account"
   };
 }
-function enrichAccountSchema(schema, coValueClass) {
-  const enrichedSchema = Object.assign(schema, {
-    create: (...args) => {
-      return coValueClass.create(...args);
-    },
-    createAs: (...args) => {
-      return coValueClass.createAs(...args);
-    },
-    getMe: (...args) => {
-      return coValueClass.getMe(...args);
-    },
-    load: (...args) => {
-      return coValueClass.load(...args);
-    },
-    subscribe: (...args) => {
-      return coValueClass.subscribe(...args);
-    },
-    fromRaw: (...args) => {
-      return coValueClass.fromRaw(...args);
-    },
-    unstable_merge: (...args) => {
-      return unstable_mergeBranchWithResolve(coValueClass, ...args);
-    },
-    withMigration: (migration) => {
-      coValueClass.prototype.migrate = async function(creationProps) {
-        await migration(this, creationProps);
-      };
-      return enrichedSchema;
-    },
-    getCoValueClass: () => {
-      return coValueClass;
-    },
-    optional: () => coOptionalDefiner(enrichedSchema)
-  });
-  return enrichedSchema;
-}
 
 // src/tools/implementation/zodSchema/unionUtils.ts
 function schemaUnionDiscriminatorFor(schema) {
@@ -5679,7 +5942,7 @@ function hydrateCoreCoValueSchema(schema) {
         }
       }
     };
-    const coValueSchema = ClassToExtend === Account ? enrichAccountSchema(schema, coValueClass) : enrichCoMapSchema(schema, coValueClass);
+    const coValueSchema = ClassToExtend === Account ? new AccountSchema(schema, coValueClass) : new CoMapSchema(schema, coValueClass);
     return coValueSchema;
   } else if (schema.builtin === "CoList") {
     const element = schema.element;
@@ -6236,6 +6499,12 @@ globalThis.devtoolsFormatters = [
 function isCoValueClass(value) {
   return typeof value === "function" && value.fromRaw !== void 0;
 }
+function createUnloadedCoValue(id, loadingState) {
+  return {
+    $jazz: { id, loadingState },
+    $isLoaded: false
+  };
+}
 function loadCoValueWithoutMe(cls, id, options) {
   return loadCoValue(cls, id, {
     ...options,
@@ -6254,10 +6523,10 @@ function loadCoValue(cls, id, options) {
         syncResolution: true,
         skipRetry: options.skipRetry,
         onUnavailable: () => {
-          resolve(null);
+          resolve(createUnloadedCoValue(id, CoValueLoadingState.UNAVAILABLE));
         },
         onUnauthorized: () => {
-          resolve(null);
+          resolve(createUnloadedCoValue(id, CoValueLoadingState.UNAUTHORIZED));
         },
         unstable_branch: options.unstable_branch
       },
@@ -6278,7 +6547,7 @@ async function ensureCoValueLoaded(existing, options) {
       unstable_branch: options?.unstable_branch
     }
   );
-  if (!response) {
+  if (!response.$isLoaded) {
     throw new Error("Failed to deeply load CoValue " + existing.$jazz.id);
   }
   return response;
@@ -6337,15 +6606,15 @@ function subscribeToCoValue(cls, id, options, listener) {
   );
   const handleUpdate = (value) => {
     if (unsubscribed) return;
-    if (value.type === "unavailable") {
+    if (value.type === CoValueLoadingState.UNAVAILABLE) {
       options.onUnavailable?.();
       if (!options.skipRetry) {
         console.error(value.toString());
       }
-    } else if (value.type === "unauthorized") {
+    } else if (value.type === CoValueLoadingState.UNAUTHORIZED) {
       options.onUnauthorized?.();
       console.error(value.toString());
-    } else if (value.type === "loaded") {
+    } else if (value.type === CoValueLoadingState.LOADED) {
       listener(value.value, unsubscribe);
     }
   };
@@ -6431,10 +6700,8 @@ async function unstable_loadUnique(schema, options) {
   return internalLoadUnique(cls, {
     header,
     onCreateWhenMissing: options.onCreateWhenMissing,
-    // @ts-expect-error loaded is not compatible with Resolved at type level, but they are the same thing
     onUpdateWhenFound: options.onUpdateWhenFound,
     owner: options.owner,
-    // @ts-expect-error loaded is not compatible with Resolved at type level, but they are the same thing
     resolve: options.resolve
   });
 }
@@ -6442,7 +6709,7 @@ async function internalLoadUnique(cls, options) {
   const loadAs = options.owner.$jazz.loadedAs;
   const node = loadAs[TypeSym] === "Anonymous" ? loadAs.node : loadAs.$jazz.localNode;
   const id = cojsonInternals6.idforHeader(options.header, node.crypto);
-  await loadCoValueWithoutMe(cls, id, {
+  const maybeLoadedCoValue = await loadCoValueWithoutMe(cls, id, {
     skipRetry: true,
     loadAs
   });
@@ -6455,14 +6722,14 @@ async function internalLoadUnique(cls, options) {
     });
   }
   if (!isAvailable) {
-    return null;
+    return maybeLoadedCoValue;
   }
   if (options.onUpdateWhenFound) {
     const loaded = await loadCoValueWithoutMe(cls, id, {
       loadAs,
       resolve: options.resolve
     });
-    if (loaded) {
+    if (loaded.$isLoaded) {
       options.onUpdateWhenFound(loaded);
     } else {
       return loaded;
@@ -6491,13 +6758,13 @@ async function exportCoValue(cls, id, options) {
   );
   const value = await new Promise((resolve2) => {
     rootNode.setListener((value2) => {
-      if (value2.type === "unavailable") {
+      if (value2.type === CoValueLoadingState.UNAVAILABLE) {
         resolve2(null);
         console.error(value2.toString());
-      } else if (value2.type === "unauthorized") {
+      } else if (value2.type === CoValueLoadingState.UNAUTHORIZED) {
         resolve2(null);
         console.error(value2.toString());
-      } else if (value2.type === "loaded") {
+      } else if (value2.type === CoValueLoadingState.LOADED) {
         resolve2(value2.value);
       }
       rootNode.destroy();
@@ -6516,8 +6783,9 @@ function loadContentPiecesFromSubscription(subscription, valuesExported, content
     return;
   }
   valuesExported.add(subscription.id);
-  const core2 = subscription.getCurrentValue()?.$jazz.raw.core;
-  if (core2) {
+  const currentValue = subscription.getCurrentValue();
+  if (typeof currentValue !== "string") {
+    const core2 = currentValue.$jazz.raw.core;
     loadContentPiecesFromCoValue(core2, valuesExported, contentPieces);
   }
   for (const child of subscription.childNodes.values()) {
@@ -6552,7 +6820,7 @@ function unstable_mergeBranch(subscriptionScope) {
     return;
   }
   function handleMerge(subscriptionNode) {
-    if (subscriptionNode.value.type === "loaded") {
+    if (subscriptionNode.value.type === CoValueLoadingState.LOADED) {
       subscriptionNode.value.value.$jazz.raw.core.mergeBranch();
     }
     for (const childNode of subscriptionNode.childNodes.values()) {
@@ -6561,7 +6829,7 @@ function unstable_mergeBranch(subscriptionScope) {
   }
   handleMerge(subscriptionScope);
 }
-async function unstable_mergeBranchWithResolve2(cls, id, options) {
+async function unstable_mergeBranchWithResolve(cls, id, options) {
   const loadAs = options.loadAs ?? activeAccountContext3.get();
   const node = "node" in loadAs ? loadAs.node : loadAs.$jazz.localNode;
   const resolve = options.resolve ?? true;
@@ -6579,11 +6847,11 @@ async function unstable_mergeBranchWithResolve2(cls, id, options) {
   );
   await new Promise((resolve2, reject) => {
     rootNode.setListener((value) => {
-      if (value.type === "unavailable") {
+      if (value.type === CoValueLoadingState.UNAVAILABLE) {
         reject(new Error("Unable to load the branch. " + value.toString()));
-      } else if (value.type === "unauthorized") {
+      } else if (value.type === CoValueLoadingState.UNAUTHORIZED) {
         reject(new Error("Unable to load the branch. " + value.toString()));
-      } else if (value.type === "loaded") {
+      } else if (value.type === CoValueLoadingState.LOADED) {
         resolve2();
       }
       rootNode.destroy();
@@ -6594,6 +6862,7 @@ async function unstable_mergeBranchWithResolve2(cls, id, options) {
 
 export {
   zodReExport_exports,
+  createUnloadedCoValue,
   loadCoValue,
   subscribeToCoValue,
   unstable_loadUnique,
@@ -6609,6 +6878,8 @@ export {
   Group2 as Group,
   Profile,
   isCoValueId,
+  assertLoaded,
+  getLoadedOrUndefined,
   Inbox,
   InboxSender,
   CoPlainText,
@@ -6619,6 +6890,7 @@ export {
   Ref,
   Encoders,
   coField,
+  CoValueLoadingState,
   SubscriptionScope,
   randomSessionProvider,
   createJazzContextFromExistingCredentials,
@@ -6635,4 +6907,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-OSQ7S47Q.js.map
+//# sourceMappingURL=chunk-P3YLNFN4.js.map