jazz-tools 0.19.7 → 0.19.10

package/src/react-core/use.ts

@@ -0,0 +1,46 @@
+import React from "react";
+
+// shim from https://github.com/pmndrs/jotai/blob/f287c5d665a807e676bc731e83174c62c1fe1fc9/src/react/useAtomValue.ts#L13C1-L56C1
+const attachPromiseStatus = <T>(
+  promise: PromiseLike<T> & {
+    status?: "pending" | "fulfilled" | "rejected";
+    value?: T;
+    reason?: unknown;
+  },
+) => {
+  if (!promise.status) {
+    promise.status = "pending";
+    promise.then(
+      (v) => {
+        promise.status = "fulfilled";
+        promise.value = v;
+      },
+      (e) => {
+        promise.status = "rejected";
+        promise.reason = e;
+      },
+    );
+  }
+};
+
+export const use =
+  React.use ||
+  // A shim for older React versions
+  (<T>(
+    promise: PromiseLike<T> & {
+      status?: "pending" | "fulfilled" | "rejected";
+      value?: T;
+      reason?: unknown;
+    },
+  ): T => {
+    if (promise.status === "pending") {
+      throw promise;
+    } else if (promise.status === "fulfilled") {
+      return promise.value as T;
+    } else if (promise.status === "rejected") {
+      throw promise.reason;
+    } else {
+      attachPromiseStatus(promise);
+      throw promise;
+    }
+  });

package/src/react-native/index.ts

@@ -1,4 +1,4 @@
-export * from "jazz-tools/react-native-core";
+export * from "../react-native-core/index.js";
 
 export * from "./provider.js";
 export * from "./storage/mmkv-store-adapter.js";

package/src/react-native-core/crypto/RNCrypto.ts

@@ -0,0 +1 @@
+export * from "cojson/crypto/RNCrypto";

package/src/react-native-core/hooks.tsx

@@ -19,6 +19,8 @@ export {
   useCoValueSubscription,
   useAccountSubscription,
   useSubscriptionSelector,
+  useSuspenseCoState,
+  useSuspenseAccount,
 } from "jazz-tools/react-core";
 
 export function useAcceptInviteNative<S extends CoValueClassOrSchema>({

package/src/react-native-core/index.ts

@@ -11,7 +11,9 @@ export {
 } from "jazz-tools/react-core";
 
 export { SQLiteDatabaseDriverAsync } from "cojson";
+
 export { parseInviteLink } from "jazz-tools";
+
 export { createInviteLink, setupKvStore } from "./platform.js";
 export {
   ReactNativeContextManager,

package/src/react-native-core/platform.ts

@@ -24,12 +24,13 @@ import { KvStore, KvStoreContext } from "./storage/kv-store-context.js";
 import { SQLiteDatabaseDriverAsync } from "cojson";
 import { WebSocketPeerWithReconnection } from "cojson-transport-ws";
 import type { RNQuickCrypto } from "jazz-tools/react-native-core/crypto";
+import type { RNCrypto } from "cojson/crypto/RNCrypto";
 
 export type BaseReactNativeContextOptions = {
   sync: SyncConfig;
   reconnectionTimeout?: number;
   storage?: SQLiteDatabaseDriverAsync | "disabled";
-  CryptoProvider?: typeof PureJSCrypto | typeof RNQuickCrypto;
+  CryptoProvider?: typeof PureJSCrypto | typeof RNQuickCrypto | typeof RNCrypto;
   authSecretStorage: AuthSecretStorage;
 };
 

package/src/react-native-core/polyfills/index.js

@@ -0,0 +1,28 @@
+import { ReadableStream } from "readable-stream"; // polyfill ReadableStream
+import "@azure/core-asynciterator-polyfill"; // polyfill Async Iterator
+import "react-native-get-random-values"; // polyfill getRandomValues
+import FastTextEncoder from "react-native-fast-encoder"; // polyfill TextEncoder/TextDecoder
+
+// Add encodeInto method which the fast encoder doesn't provide
+if (!FastTextEncoder.prototype.encodeInto) {
+  /**
+   * @param {string} source
+   * @param {Uint8Array} destination
+   */
+  FastTextEncoder.prototype.encodeInto = function (source, destination) {
+    const encoded = this.encode(source);
+    const writeLength = Math.min(encoded.length, destination.length);
+    for (let i = 0; i < writeLength; i++) {
+      destination[i] = encoded[i];
+    }
+    return { read: source.length, written: writeLength };
+  };
+}
+
+// Install polyfills
+globalThis.TextEncoder = FastTextEncoder;
+globalThis.TextDecoder = FastTextEncoder;
+globalThis.ReadableStream = ReadableStream;
+if (__DEV__) {
+  console.log("[Jazz] - Polyfills successfully installed");
+}

package/src/tools/coValues/account.ts

@@ -28,6 +28,7 @@ import {
   ID,
   InstanceOrPrimitiveOfSchema,
   MaybeLoaded,
+  Settled,
   Profile,
   Ref,
   type RefEncoded,
@@ -131,9 +132,7 @@ export class Account extends CoValueBase implements CoValue {
     valueID: string,
     inviteSecret: InviteSecret,
     coValueClass?: S,
-  ): Promise<
-    MaybeLoaded<Resolved<InstanceOfSchemaCoValuesMaybeLoaded<S>, true>>
-  > {
+  ): Promise<Settled<Resolved<InstanceOfSchemaCoValuesMaybeLoaded<S>, true>>> {
     if (!this.$jazz.isLocalNodeOwner) {
       throw new Error("Only a controlled account can accept invites");
     }
@@ -380,7 +379,7 @@ export class Account extends CoValueBase implements CoValue {
       resolve?: RefsToResolveStrict<A, R>;
       loadAs?: Account | AnonymousJazzAgent;
     },
-  ): Promise<MaybeLoaded<Resolved<A, R>>> {
+  ): Promise<Settled<Resolved<A, R>>> {
     return loadCoValueWithoutMe(this, id, options);
   }
 

package/src/tools/coValues/coFeed.ts

@@ -20,6 +20,7 @@ import {
   Group,
   ID,
   MaybeLoaded,
+  Settled,
   LoadedAndRequired,
   unstable_mergeBranch,
   RefsToResolve,
@@ -297,7 +298,7 @@ export class CoFeed<out Item = any> extends CoValueBase implements CoValue {
       resolve?: RefsToResolveStrict<F, R>;
       loadAs?: Account | AnonymousJazzAgent;
     },
-  ): Promise<MaybeLoaded<Resolved<F, R>>> {
+  ): Promise<Settled<Resolved<F, R>>> {
     return loadCoValueWithoutMe(this, id, options ?? {});
   }
 
@@ -983,7 +984,7 @@ export class FileStream extends CoValueBase implements CoValue {
       loadAs?: Account | AnonymousJazzAgent;
       allowUnfinished?: boolean;
     },
-  ): Promise<MaybeLoaded<FileStream>> {
+  ): Promise<Settled<FileStream>> {
     const stream = await loadCoValueWithoutMe(this, id, options);
 
     /**

package/src/tools/coValues/coList.ts

@@ -11,7 +11,7 @@ import {
   Group,
   ID,
   AsLoaded,
-  MaybeLoaded,
+  Settled,
   unstable_mergeBranch,
   RefEncoded,
   RefsToResolve,
@@ -268,7 +268,7 @@ export class CoList<out Item = any>
       resolve?: RefsToResolveStrict<L, R>;
       loadAs?: Account | AnonymousJazzAgent;
     },
-  ): Promise<MaybeLoaded<Resolved<L, R>>> {
+  ): Promise<Settled<Resolved<L, R>>> {
     return loadCoValueWithoutMe(this, id, options);
   }
 
@@ -380,7 +380,7 @@ export class CoList<out Item = any>
       owner: Account | Group;
       resolve?: RefsToResolveStrict<L, R>;
     },
-  ): Promise<MaybeLoaded<Resolved<L, R>>> {
+  ): Promise<Settled<Resolved<L, R>>> {
     const header = CoList._getUniqueHeader(
       options.unique,
       options.owner.$jazz.id,
@@ -420,7 +420,7 @@ export class CoList<out Item = any>
       resolve?: RefsToResolveStrict<L, R>;
       loadAs?: Account | AnonymousJazzAgent;
     },
-  ): Promise<MaybeLoaded<Resolved<L, R>>> {
+  ): Promise<Settled<Resolved<L, R>>> {
     const header = CoList._getUniqueHeader(unique, ownerID);
 
     const owner = await Group.load(ownerID, {

package/src/tools/coValues/coMap.ts

@@ -18,7 +18,7 @@ import {
   getCoValueOwner,
   Group,
   ID,
-  MaybeLoaded,
+  Settled,
   PartialOnUndefined,
   RefEncoded,
   RefIfCoValue,
@@ -377,7 +377,7 @@ export class CoMap extends CoValueBase implements CoValue {
       loadAs?: Account | AnonymousJazzAgent;
       skipRetry?: boolean;
     },
-  ): Promise<MaybeLoaded<Resolved<M, R>>> {
+  ): Promise<Settled<Resolved<M, R>>> {
     return loadCoValueWithoutMe(this, id, options);
   }
 
@@ -494,7 +494,7 @@ export class CoMap extends CoValueBase implements CoValue {
       owner: Account | Group;
       resolve?: RefsToResolveStrict<M, R>;
     },
-  ): Promise<MaybeLoaded<Resolved<M, R>>> {
+  ): Promise<Settled<Resolved<M, R>>> {
     const header = CoMap._getUniqueHeader(
       options.unique,
       options.owner.$jazz.id,
@@ -536,7 +536,7 @@ export class CoMap extends CoValueBase implements CoValue {
       resolve?: RefsToResolveStrict<M, R>;
       loadAs?: Account | AnonymousJazzAgent;
     },
-  ): Promise<MaybeLoaded<Resolved<M, R>>> {
+  ): Promise<Settled<Resolved<M, R>>> {
     const header = CoMap._getUniqueHeader(unique, ownerID);
 
     const owner = await Group.load(ownerID, {

package/src/tools/coValues/coPlainText.ts

@@ -7,7 +7,7 @@ import {
   CoValueJazzApi,
   CoValueLoadingState,
   ID,
-  MaybeLoaded,
+  Settled,
   Resolved,
   SubscribeListenerOptions,
   SubscribeRestArgs,
@@ -164,7 +164,7 @@ export class CoPlainText extends String implements CoValue {
     this: CoValueClass<T>,
     id: ID<T>,
     options?: { loadAs?: Account | AnonymousJazzAgent },
-  ): Promise<MaybeLoaded<T>> {
+  ): Promise<Settled<T>> {
     return loadCoValueWithoutMe(this, id, options);
   }
 

package/src/tools/coValues/coVector.ts

@@ -11,7 +11,7 @@ import {
   SubscribeListenerOptions,
   SubscribeRestArgs,
   TypeSym,
-  MaybeLoaded,
+  Settled,
   Account,
   CoValueJazzApi,
   inspect,
@@ -232,7 +232,7 @@ export class CoVector
     options?: {
       loadAs?: Account | AnonymousJazzAgent;
     },
-  ): Promise<MaybeLoaded<C>> {
+  ): Promise<Settled<C>> {
     const coVector = await loadCoValueWithoutMe(this, id, options);
 
     /**

package/src/tools/coValues/deepLoading.ts

@@ -31,9 +31,16 @@ type IsUnion<T, U = T> = (
 // into the definition of CoValues.
 export type MaybeLoaded<T> = T | NotLoaded<T>;
 
+/**
+ * A CoValue that is either successfully loaded or that could not be loaded.
+ */
+export type Settled<T> = T | Inaccessible<T>;
+
 /**
  * A CoValue that is not loaded.
  */
+// Manually inlining the type to reduce type-checking complexity
+// type NotLoaded<T> = Loading<T> | Inaccessible<T>;
 export type NotLoaded<T> = {
   $jazz: {
     id: ID<T>;
@@ -45,6 +52,30 @@ export type NotLoaded<T> = {
   $isLoaded: false;
 };
 
+/**
+ * A CoValue that is being loaded
+ */
+export type Loading<T> = {
+  $jazz: {
+    id: ID<T>;
+    loadingState: typeof CoValueLoadingState.LOADING;
+  };
+  $isLoaded: false;
+};
+
+/**
+ * A CoValue that could not be loaded
+ */
+export type Inaccessible<T> = {
+  $jazz: {
+    id: ID<T>;
+    loadingState:
+      | typeof CoValueLoadingState.UNAVAILABLE
+      | typeof CoValueLoadingState.UNAUTHORIZED;
+  };
+  $isLoaded: false;
+};
+
 /**
  * Narrows a maybe-loaded, optional CoValue to a loaded and required CoValue.
  */

package/src/tools/coValues/group.ts

@@ -14,7 +14,7 @@ import {
   CoValue,
   CoValueClass,
   ID,
-  MaybeLoaded,
+  Settled,
   RefEncoded,
   RefsToResolve,
   RefsToResolveStrict,
@@ -283,7 +283,7 @@ export class Group extends CoValueBase implements CoValue {
       resolve?: RefsToResolveStrict<G, R>;
       loadAs?: Account | AnonymousJazzAgent;
     },
-  ): Promise<MaybeLoaded<Resolved<G, R>>> {
+  ): Promise<Settled<Resolved<G, R>>> {
     return loadCoValueWithoutMe(this, id, options);
   }
 

package/src/tools/coValues/interfaces.ts

@@ -4,7 +4,7 @@ import {
   type CojsonInternalTypes,
   type RawCoValue,
 } from "cojson";
-import { AvailableCoValueCore } from "cojson/dist/coValueCore/coValueCore.js";
+import { AvailableCoValueCore } from "cojson";
 import {
   Account,
   AnonymousJazzAgent,
@@ -13,7 +13,9 @@ import {
   NotLoadedCoValueState,
   type Group,
   Loaded,
+  Inaccessible,
   MaybeLoaded,
+  Settled,
   RefsToResolve,
   RefsToResolveStrict,
   RegisteredSchemas,
@@ -21,7 +23,6 @@ import {
   ResolveQueryStrict,
   Resolved,
   SubscriptionScope,
-  type SubscriptionValue,
   TypeSym,
   NotLoaded,
   activeAccountContext,
@@ -29,7 +30,7 @@ import {
   inspect,
 } from "../internal.js";
 import type { BranchDefinition } from "../subscribe/types.js";
-import { CoValueHeader } from "cojson/dist/coValueCore/verifiedState.js";
+import { CoValueHeader } from "cojson";
 
 /** @category Abstract interfaces */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -145,7 +146,7 @@ export function loadCoValueWithoutMe<
     skipRetry?: boolean;
     unstable_branch?: BranchDefinition;
   },
-): Promise<MaybeLoaded<Resolved<V, R>>> {
+): Promise<Settled<Resolved<V, R>>> {
   return loadCoValue(cls, id, {
     ...options,
     loadAs: options?.loadAs ?? activeAccountContext.get(),
@@ -165,7 +166,7 @@ export function loadCoValue<
     skipRetry?: boolean;
     unstable_branch?: BranchDefinition;
   },
-): Promise<MaybeLoaded<Resolved<V, R>>> {
+): Promise<Settled<Resolved<V, R>>> {
   return new Promise((resolve) => {
     subscribeToCoValue<V, R>(
       cls,
@@ -302,8 +303,8 @@ export function subscribeToCoValue<
   options: {
     resolve?: RefsToResolveStrict<V, R>;
     loadAs: Account | AnonymousJazzAgent;
-    onUnavailable?: (value: NotLoaded<V>) => void;
-    onUnauthorized?: (value: NotLoaded<V>) => void;
+    onUnavailable?: (value: Inaccessible<V>) => void;
+    onUnauthorized?: (value: Inaccessible<V>) => void;
     syncResolution?: boolean;
     skipRetry?: boolean;
     unstable_branch?: BranchDefinition;
@@ -342,16 +343,10 @@ export function subscribeToCoValue<
 
     switch (value.$jazz.loadingState) {
       case CoValueLoadingState.UNAVAILABLE:
-        options.onUnavailable?.(value);
-
-        // Don't log unavailable errors when `loadUnique` or `upsertUnique` are used
-        if (!options.skipRetry) {
-          console.error(value.toString());
-        }
+        options.onUnavailable?.(value as Inaccessible<V>);
         break;
       case CoValueLoadingState.UNAUTHORIZED:
-        options.onUnauthorized?.(value);
-        console.error(value.toString());
+        options.onUnauthorized?.(value as Inaccessible<V>);
         break;
     }
   };
@@ -546,7 +541,7 @@ export async function internalLoadUnique<
     owner: Account | Group;
     resolve?: RefsToResolveStrict<V, R>;
   },
-): Promise<MaybeLoaded<Resolved<V, R>>> {
+): Promise<Settled<Resolved<V, R>>> {
   const loadAs = options.owner.$jazz.loadedAs;
 
   const node =
@@ -682,18 +677,18 @@ export async function exportCoValue<
   );
 
   const value = await new Promise<Loaded<S, R> | null>((resolve) => {
-    rootNode.setListener((value) => {
-      if (value.type === CoValueLoadingState.UNAVAILABLE) {
-        resolve(null);
-        console.error(value.toString());
-      } else if (value.type === CoValueLoadingState.UNAUTHORIZED) {
+    rootNode.setListener(() => {
+      const value = rootNode.getCurrentValue();
+
+      if (value.$isLoaded) {
+        resolve(value as Loaded<S, R>);
+      } else if (
+        value.$jazz.loadingState === CoValueLoadingState.UNAVAILABLE ||
+        value.$jazz.loadingState === CoValueLoadingState.UNAUTHORIZED
+      ) {
         resolve(null);
-        console.error(value.toString());
-      } else if (value.type === CoValueLoadingState.LOADED) {
-        resolve(value.value as Loaded<S, R>);
+        rootNode.destroy();
       }
-
-      rootNode.destroy();
     });
   });
 

package/src/tools/coValues/schemaUnion.ts

@@ -10,7 +10,7 @@ import {
   CoValueJazzApi,
   Group,
   ID,
-  MaybeLoaded,
+  Settled,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
@@ -162,7 +162,7 @@ export abstract class SchemaUnion extends CoValueBase implements CoValue {
       loadAs?: Account | AnonymousJazzAgent;
       skipRetry?: boolean;
     },
-  ): Promise<MaybeLoaded<Resolved<M, R>>> {
+  ): Promise<Settled<Resolved<M, R>>> {
     return loadCoValueWithoutMe(this, id, options);
   }
 

package/src/tools/config.ts

@@ -0,0 +1,9 @@
+export {
+  setCustomErrorReporter,
+  enableCaptureErrorCause,
+} from "./subscribe/errorReporting.js";
+
+export {
+  logger,
+  LogLevel,
+} from "cojson";

package/src/tools/exports.ts

@@ -137,3 +137,7 @@ export {
 } from "./coValues/request.js";
 
 export * from "./ssr/index.js";
+
+export { captureStack } from "./subscribe/errorReporting.js";
+
+export * as jazzConfig from "./config.js";

package/src/tools/implementation/ContextManager.ts

@@ -9,6 +9,7 @@ import { JazzContextType } from "../types.js";
 import { AnonymousJazzAgent } from "./anonymousJazzAgent.js";
 import { createAnonymousJazzContext } from "./createContext.js";
 import { InstanceOfSchema } from "./zodSchema/typeConverters/InstanceOfSchema.js";
+import { SubscriptionCache } from "../subscribe/SubscriptionCache.js";
 
 export type JazzContextManagerAuthProps = {
   credentials?: AuthCredentials;
@@ -75,6 +76,7 @@ export class JazzContextManager<
   protected keepContextOpen = false;
   contextPromise: Promise<void> | undefined;
   protected authenticatingAccountID: string | null = null;
+  private subscriptionCache: SubscriptionCache;
 
   constructor(opts?: {
     useAnonymousFallback?: boolean;
@@ -82,6 +84,7 @@ export class JazzContextManager<
   }) {
     KvStoreContext.getInstance().initialize(this.getKvStore());
     this.authSecretStorage = new AuthSecretStorage(opts?.authSecretStorageKey);
+    this.subscriptionCache = new SubscriptionCache();
 
     if (opts?.useAnonymousFallback) {
       this.value = getAnonymousFallback();
@@ -130,6 +133,9 @@ export class JazzContextManager<
     context: PlatformSpecificContext<Acc>,
     authProps?: JazzContextManagerAuthProps,
   ) {
+    // Clear cache before updating context to prevent subscription leaks across authentication boundaries
+    this.subscriptionCache.clear();
+
     // When keepContextOpen we don't want to close the previous context
     // because we might need to handle the onAnonymousAccountDiscarded callback
     if (!this.keepContextOpen) {
@@ -178,6 +184,10 @@ export class JazzContextManager<
     return this.authenticatingAccountID;
   }
 
+  getSubscriptionScopeCache(): SubscriptionCache {
+    return this.subscriptionCache;
+  }
+
   logOut = async () => {
     if (!this.context || !this.props) {
       return;
@@ -185,6 +195,9 @@ export class JazzContextManager<
 
     this.authenticatingAccountID = null;
 
+    // Clear cache on logout to prevent subscription leaks across authentication boundaries
+    this.subscriptionCache.clear();
+
     await this.props.onLogOut?.();
 
     if (this.props.logOutReplacement) {

package/src/tools/implementation/zodSchema/schemaTypes/AccountSchema.ts

@@ -5,7 +5,7 @@ import {
   CoMapSchemaDefinition,
   coOptionalDefiner,
   Group,
-  MaybeLoaded,
+  Settled,
   RefsToResolveStrict,
   RefsToResolve,
   Resolved,
@@ -84,7 +84,7 @@ export class AccountSchema<
       loadAs?: Account | AnonymousJazzAgent;
       resolve?: RefsToResolveStrict<AccountSchema<Shape>, R>;
     },
-  ): Promise<MaybeLoaded<Loaded<AccountSchema<Shape>, R>>> {
+  ): Promise<Settled<Loaded<AccountSchema<Shape>, R>>> {
     // @ts-expect-error
     return this.coValueClass.load(
       id,

package/src/tools/implementation/zodSchema/schemaTypes/CoDiscriminatedUnionSchema.ts

@@ -5,7 +5,7 @@ import {
   BranchDefinition,
   InstanceOfSchema,
   InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded,
-  MaybeLoaded,
+  Settled,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
@@ -87,7 +87,7 @@ export class CoDiscriminatedUnionSchema<
       unstable_branch?: BranchDefinition;
     },
   ): Promise<
-    MaybeLoaded<
+    Settled<
       Resolved<
         CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion,
         R

package/src/tools/implementation/zodSchema/schemaTypes/CoFeedSchema.ts

@@ -4,7 +4,7 @@ import {
   BranchDefinition,
   CoFeed,
   Group,
-  MaybeLoaded,
+  Settled,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
@@ -69,7 +69,7 @@ export class CoFeedSchema<
       loadAs?: Account | AnonymousJazzAgent;
       unstable_branch?: BranchDefinition;
     },
-  ): Promise<MaybeLoaded<Resolved<CoFeedInstanceCoValuesMaybeLoaded<T>, R>>> {
+  ): Promise<Settled<Resolved<CoFeedInstanceCoValuesMaybeLoaded<T>, R>>> {
     // @ts-expect-error
     return this.coValueClass.load(
       id,

package/src/tools/implementation/zodSchema/schemaTypes/CoListSchema.ts

@@ -4,7 +4,7 @@ import {
   CoList,
   Group,
   ID,
-  MaybeLoaded,
+  Settled,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
@@ -77,7 +77,7 @@ export class CoListSchema<
       loadAs?: Account | AnonymousJazzAgent;
       unstable_branch?: BranchDefinition;
     },
-  ): Promise<MaybeLoaded<Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>>> {
+  ): Promise<Settled<Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>>> {
     // @ts-expect-error
     return this.coValueClass.load(
       id,
@@ -147,7 +147,7 @@ export class CoListSchema<
     unique: CoValueUniqueness["uniqueness"];
     owner: Account | Group;
     resolve?: RefsToResolveStrict<CoListInstanceCoValuesMaybeLoaded<T>, R>;
-  }): Promise<MaybeLoaded<Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>>> {
+  }): Promise<Settled<Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>>> {
     // @ts-expect-error
     return this.coValueClass.upsertUnique(
       // @ts-expect-error
@@ -166,7 +166,7 @@ export class CoListSchema<
       resolve?: RefsToResolveStrict<CoListInstanceCoValuesMaybeLoaded<T>, R>;
       loadAs?: Account | AnonymousJazzAgent;
     },
-  ): Promise<MaybeLoaded<Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>>> {
+  ): Promise<Settled<Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>>> {
     // @ts-expect-error
     return this.coValueClass.loadUnique(
       unique,