jazz-tools 0.18.38 → 0.19.1

package/dist/{chunk-OSQ7S47Q.js → chunk-NCNM6UDZ.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;
     }
@@ -3306,8 +3340,6 @@ var SchemaUnion = class _SchemaUnion extends CoValueBase {
   /**
    * Load a `SchemaUnion` with a given ID, as a given account.
    *
-   * Note: The `resolve` option is not supported for `SchemaUnion`s due to https://github.com/garden-co/jazz/issues/2639
-   *
    * @category Subscription & Loading
    */
   static load(id, options) {
@@ -3341,6 +3373,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 +3474,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 +3695,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 +3892,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 +3981,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 +4001,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 +4014,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 +4142,7 @@ function createCoValue(ref2, raw, subscriptionScope) {
     configurable: false
   });
   return {
-    type: "loaded",
+    type: CoValueLoadingState.LOADED,
     value: freshValueInstance,
     id: subscriptionScope.id
   };
@@ -4116,18 +4175,19 @@ var SubscriptionScope = class _SubscriptionScope {
     this.autoloadedKeys = /* @__PURE__ */ new Set();
     this.skipInvalidKeys = /* @__PURE__ */ new Set();
     this.totalValidTransactions = 0;
+    this.version = 0;
     this.migrated = false;
     this.migrating = false;
     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 +4195,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 +4205,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 +4239,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 +4260,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,13 +4278,11 @@ 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 {
-      const hasChanged = update.totalValidTransactions !== this.totalValidTransactions || // Checking the identity of the raw value makes us cover the cases where the group
-      // has been updated and the coValues that don't update the totalValidTransactions value (e.g. FileStream)
-      this.value.value.$jazz.raw !== update;
+      const hasChanged = update.totalValidTransactions !== this.totalValidTransactions || update.version !== this.version;
       if (this.loadChildren()) {
         this.updateValue(createCoValue(this.schema, update, this));
       } else if (hasChanged) {
@@ -4232,12 +4290,13 @@ var SubscriptionScope = class _SubscriptionScope {
       }
     }
     this.totalValidTransactions = update.totalValidTransactions;
+    this.version = update.version;
     this.silenceUpdates = false;
     this.triggerUpdate();
   }
   computeChildErrors() {
     let issues = [];
-    let errorType = "unavailable";
+    let errorType = CoValueLoadingState.UNAVAILABLE;
     if (this.childErrors.size === 0 && this.validationErrors.size === 0) {
       return void 0;
     }
@@ -4271,26 +4330,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 +4360,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 +4379,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 +4410,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 +4456,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 +4507,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`,
@@ -4486,17 +4545,6 @@ var SubscriptionScope = class _SubscriptionScope {
     const id = map.$jazz.raw.get(key);
     const descriptor = map.$jazz.getDescriptor(key);
     if (!descriptor) {
-      this.childErrors.set(
-        key,
-        new JazzError(void 0, "unavailable", [
-          {
-            code: "validationError",
-            message: `The ref ${key} requested on ${map.constructor.name} is not defined in the schema`,
-            params: {},
-            path: [key]
-          }
-        ])
-      );
       return void 0;
     }
     if (isRefEncoded(descriptor)) {
@@ -4507,7 +4555,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 +4586,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 +4606,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 +4675,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
+    );
   }
 }
 
@@ -4822,18 +4876,32 @@ function createAnonymousJazzContext({
 }
 
 // src/tools/implementation/zodSchema/schemaTypes/CoDiscriminatedUnionSchema.ts
-var CoDiscriminatedUnionSchema = class {
+var CoDiscriminatedUnionSchema = class _CoDiscriminatedUnionSchema {
   constructor(coreSchema, coValueClass) {
     this.coValueClass = coValueClass;
     this.collaborative = true;
     this.builtin = "CoDiscriminatedUnion";
+    /**
+     * 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.getDefinition = coreSchema.getDefinition;
   }
   load(id, options) {
-    return this.coValueClass.load(id, options);
+    return this.coValueClass.load(
+      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;
@@ -4841,6 +4909,23 @@ var CoDiscriminatedUnionSchema = 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 definition = this.getDefinition();
+    const coreSchema = createCoreCoDiscriminatedUnionSchema(
+      definition.discriminator,
+      definition.options
+    );
+    const copy = new _CoDiscriminatedUnionSchema(
+      coreSchema,
+      this.coValueClass
+    );
+    copy.resolveQuery = resolveQuery;
+    return copy;
+  }
 };
 function createCoreCoDiscriminatedUnionSchema(discriminator, schemas) {
   return {
@@ -4868,7 +4953,8 @@ function createCoreCoDiscriminatedUnionSchema(discriminator, schemas) {
       get options() {
         return schemas;
       }
-    })
+    }),
+    resolveQuery: true
   };
 }
 
@@ -4881,6 +4967,7 @@ var CoOptionalSchema = class {
     this.getDefinition = () => ({
       innerType: this.innerType
     });
+    this.resolveQuery = true;
   }
   getCoValueClass() {
     return this.innerType.getCoValueClass();
@@ -4891,7 +4978,8 @@ var CoOptionalSchema = class {
 function createCoreCoRichTextSchema() {
   return {
     collaborative: true,
-    builtin: "CoRichText"
+    builtin: "CoRichText",
+    resolveQuery: true
   };
 }
 var RichTextSchema = class {
@@ -4899,6 +4987,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 +4999,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 +5013,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 +5153,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 +5181,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 +5358,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 +5410,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 +5492,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 +5515,8 @@ function createCoreCoFeedSchema(element) {
 function createCoreCoPlainTextSchema() {
   return {
     collaborative: true,
-    builtin: "CoPlainText"
+    builtin: "CoPlainText",
+    resolveQuery: true
   };
 }
 var PlainTextSchema = class {
@@ -5285,6 +5524,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 +5536,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 +5553,8 @@ var PlainTextSchema = class {
 function createCoreFileStreamSchema() {
   return {
     collaborative: true,
-    builtin: "FileStream"
+    builtin: "FileStream",
+    resolveQuery: true
   };
 }
 var FileStreamSchema = class {
@@ -5321,6 +5562,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 +5580,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 +5598,8 @@ function createCoreCoVectorSchema(dimensions) {
   return {
     collaborative: true,
     builtin: "CoVector",
-    dimensions
+    dimensions,
+    resolveQuery: true
   };
 }
 var CoVectorSchema = class {
@@ -5365,6 +5608,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 +5631,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) {
@@ -5465,10 +5745,20 @@ function schemaUnionDiscriminatorFor(schema) {
       }
     }
     const determineSchema = (discriminable) => {
+      const allNestedRefKeys = /* @__PURE__ */ new Set();
+      for (const option of availableOptions) {
+        const coMapShape = option.getDefinition().shape;
+        for (const [key, value] of Object.entries(coMapShape)) {
+          if (isAnyCoValueSchema2(value)) {
+            allNestedRefKeys.add(key);
+          }
+        }
+      }
       for (const option of availableOptions) {
         let match = true;
+        const optionDef = option.getDefinition();
         for (const key of Object.keys(discriminatorMap)) {
-          const discriminatorDef = option.getDefinition().shape[key];
+          const discriminatorDef = optionDef.shape[key];
           const discriminatorValue = discriminable.get(key);
           if (discriminatorValue && typeof discriminatorValue === "object") {
             throw new Error("Discriminator must be a primitive value");
@@ -5492,7 +5782,19 @@ function schemaUnionDiscriminatorFor(schema) {
         }
         if (match) {
           const coValueSchema = hydrateCoreCoValueSchema(option);
-          return coValueSchema.getCoValueClass();
+          const coValueClass = coValueSchema.getCoValueClass();
+          const dummyFieldNames = allNestedRefKeys.keys().filter((key) => !optionDef.shape[key]).toArray();
+          if (dummyFieldNames.length === 0) {
+            return coValueClass;
+          }
+          return class extends coValueClass {
+            constructor(...args) {
+              super(...args);
+              for (const key of dummyFieldNames) {
+                this[key] = coField.null;
+              }
+            }
+          };
         }
       }
       throw new Error(
@@ -5679,7 +5981,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 +6538,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 +6562,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 +6586,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 +6645,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 +6739,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 +6748,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 +6761,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 +6797,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 +6822,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 +6859,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 +6868,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 +6886,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 +6901,7 @@ async function unstable_mergeBranchWithResolve2(cls, id, options) {
 
 export {
   zodReExport_exports,
+  createUnloadedCoValue,
   loadCoValue,
   subscribeToCoValue,
   unstable_loadUnique,
@@ -6609,6 +6917,8 @@ export {
   Group2 as Group,
   Profile,
   isCoValueId,
+  assertLoaded,
+  getLoadedOrUndefined,
   Inbox,
   InboxSender,
   CoPlainText,
@@ -6619,6 +6929,7 @@ export {
   Ref,
   Encoders,
   coField,
+  CoValueLoadingState,
   SubscriptionScope,
   randomSessionProvider,
   createJazzContextFromExistingCredentials,
@@ -6635,4 +6946,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-OSQ7S47Q.js.map
+//# sourceMappingURL=chunk-NCNM6UDZ.js.map