jazz-tools 0.15.16 → 0.16.0

package/src/tools/coValues/coPlainText.ts

@@ -14,7 +14,7 @@ import {
   Resolved,
   SubscribeListenerOptions,
   SubscribeRestArgs,
-  anySchemaToCoSchema,
+  coValueClassFromCoValueClassOrSchema,
   parseCoValueCreateOptions,
 } from "../internal.js";
 import {
@@ -47,9 +47,9 @@ export class CoPlainText extends String implements CoValue {
 
     if (agent instanceof ControlledAccount) {
       return coValuesCache.get(agent.account, () =>
-        anySchemaToCoSchema(RegisteredSchemas["Account"]).fromRaw(
-          agent.account,
-        ),
+        coValueClassFromCoValueClassOrSchema(
+          RegisteredSchemas["Account"],
+        ).fromRaw(agent.account),
       );
     }
 

package/src/tools/coValues/deepLoading.ts

@@ -5,7 +5,10 @@ import { CoFeedEntry } from "./coFeed.js";
 import { type CoKeys } from "./coMap.js";
 import { type CoValue, type ID } from "./interfaces.js";
 
-type NotNull<T> = Exclude<T, null>;
+/**
+ * Similar to {@link NonNullable}, but removes only `null` and preserves `undefined`.
+ */
+export type NotNull<T> = Exclude<T, null>;
 
 /**
  * Used to check if T is a union type.

package/src/tools/coValues/extensions/imageDef.ts

@@ -8,9 +8,9 @@ const ImageDefinitionBase = coMapDefiner({
 }).catchall(coFileStreamDefiner());
 
 /** @category Media */
-export const ImageDefinition = ImageDefinitionBase.withHelpers((Self) => ({
+export const ImageDefinition = Object.assign({}, ImageDefinitionBase, {
   highestResAvailable(
-    imageDef: Loaded<typeof Self>,
+    imageDef: ImageDefinition,
     options?: {
       maxWidth?: number;
       targetWidth?: number;
@@ -56,5 +56,5 @@ export const ImageDefinition = ImageDefinitionBase.withHelpers((Self) => ({
       }
     );
   },
-}));
+});
 export type ImageDefinition = Loaded<typeof ImageDefinition>;

package/src/tools/coValues/inbox.ts

@@ -3,11 +3,11 @@ import { CoStreamItem, RawCoStream } from "cojson";
 import {
   type Account,
   CoValue,
-  CoValueOrZodSchema,
+  CoValueClassOrSchema,
   ID,
   InstanceOfSchema,
   activeAccountContext,
-  anySchemaToCoSchema,
+  coValueClassFromCoValueClassOrSchema,
   loadCoValue,
 } from "../internal.js";
 import { isCoValueId } from "../lib/id.js";
@@ -109,7 +109,7 @@ export class Inbox {
     this.failed = failed;
   }
 
-  subscribe<M extends CoValueOrZodSchema, O extends CoValue | undefined>(
+  subscribe<M extends CoValueClassOrSchema, O extends CoValue | undefined>(
     Schema: M,
     callback: (
       message: InstanceOfSchema<M>,
@@ -172,7 +172,7 @@ export class Inbox {
                 }
 
                 return loadCoValue(
-                  anySchemaToCoSchema(Schema),
+                  coValueClassFromCoValueClassOrSchema(Schema),
                   message.get("payload")!,
                   {
                     loadAs: account,

package/src/tools/coValues/interfaces.ts

@@ -1,5 +1,4 @@
 import {
-  CoValueCore,
   type CoValueUniqueness,
   type CojsonInternalTypes,
   type RawCoValue,
@@ -9,7 +8,7 @@ import { AvailableCoValueCore } from "cojson/dist/coValueCore/coValueCore.js";
 import {
   Account,
   AnonymousJazzAgent,
-  CoValueOrZodSchema,
+  CoValueClassOrSchema,
   type Group,
   Loaded,
   RefsToResolve,
@@ -21,8 +20,7 @@ import {
   SubscriptionScope,
   type SubscriptionValue,
   activeAccountContext,
-  anySchemaToCoSchema,
-  getSubscriptionScope,
+  coValueClassFromCoValueClassOrSchema,
   inspect,
 } from "../internal.js";
 
@@ -312,71 +310,6 @@ export function subscribeToCoValue<
   return unsubscribe;
 }
 
-/**
- * @deprecated Used for the React integration in the past, but we moved to use SubscriptionScope directly.
- *
- * Going to be removed in the next minor version.
- */
-export function createCoValueObservable<
-  S extends CoValueOrZodSchema,
-  const R extends ResolveQuery<S>,
->(initialValue: undefined | null = undefined) {
-  let currentValue: Loaded<S, R> | undefined | null = initialValue;
-  let subscriberCount = 0;
-
-  function subscribe(
-    cls: S,
-    id: string,
-    options: {
-      loadAs: Account | AnonymousJazzAgent;
-      resolve?: ResolveQueryStrict<S, R>;
-      onUnavailable?: () => void;
-      onUnauthorized?: () => void;
-      syncResolution?: boolean;
-    },
-    listener: () => void,
-  ) {
-    subscriberCount++;
-
-    const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(cls),
-      id,
-      {
-        loadAs: options.loadAs,
-        resolve: options.resolve as any,
-        onUnavailable: () => {
-          currentValue = null;
-          options.onUnavailable?.();
-        },
-        onUnauthorized: () => {
-          currentValue = null;
-          options.onUnauthorized?.();
-        },
-        syncResolution: options.syncResolution,
-      },
-      (value) => {
-        currentValue = value as Loaded<S, R>;
-        listener();
-      },
-    );
-
-    return () => {
-      unsubscribe();
-      subscriberCount--;
-      if (subscriberCount === 0) {
-        currentValue = undefined;
-      }
-    };
-  }
-
-  const observable = {
-    getCurrentValue: () => currentValue,
-    subscribe,
-  };
-
-  return observable;
-}
-
 export function subscribeToExistingCoValue<
   V extends CoValue,
   const R extends RefsToResolve<V>,
@@ -515,7 +448,7 @@ export function parseGroupCreateOptions(
  * ```
  */
 export async function exportCoValue<
-  S extends CoValueOrZodSchema | CoValueClass<CoValue>,
+  S extends CoValueClassOrSchema,
   const R extends ResolveQuery<S>,
 >(
   cls: S,
@@ -537,7 +470,7 @@ export async function exportCoValue<
     resolve as any,
     id,
     {
-      ref: anySchemaToCoSchema(cls),
+      ref: coValueClassFromCoValueClassOrSchema(cls),
       optional: false,
     },
     options.skipRetry,

package/src/tools/coValues/request.ts

@@ -8,19 +8,19 @@ import {
 } from "cojson";
 import z from "zod/v4";
 import {
-  AnyCoMapSchema,
-  AnyCoSchema,
+  AnyZodOrCoValueSchema,
   CoMap,
   CoMapInitZod,
   CoMapSchema,
   CoValueClass,
+  CoreCoMapSchema,
   Group,
   Loaded,
   ResolveQuery,
   ResolveQueryStrict,
   Simplify,
-  anySchemaToCoSchema,
   coMapDefiner,
+  coValueClassFromCoValueClassOrSchema,
   exportCoValue,
   importContentPieces,
   loadCoValue,
@@ -28,7 +28,7 @@ import {
 import { isCoValueId } from "../lib/id.js";
 import { Account } from "./account.js";
 
-type MessageShape = Record<string, z.core.$ZodType | AnyCoSchema>;
+type MessageShape = Record<string, AnyZodOrCoValueSchema>;
 
 type RequestSchemaDefinition<
   S extends MessageShape,
@@ -97,7 +97,7 @@ type MessageValuePayload<T extends MessageShape> =
   | AsNullablePayload<T>;
 
 function createMessageEnvelope<S extends MessageShape>(
-  schema: AnyCoMapSchema,
+  schema: CoreCoMapSchema,
   value: MessageValuePayload<S>,
   owner: Account,
   sharedWith: Account | Group,
@@ -111,7 +111,7 @@ function createMessageEnvelope<S extends MessageShape>(
     group.addMember(sharedWith, "reader");
   }
 
-  // @ts-expect-error - AnyCoMapSchema doesn't have static methods
+  // @ts-expect-error - CoreCoMapSchema doesn't have static methods
   return schema.create(value ?? {}, group);
 }
 
@@ -129,7 +129,7 @@ async function serializeMessagePayload({
 }: {
   // Skipping type validation here to avoid excessive type complexity that affects the typecheck performance
   type: "request" | "response";
-  schema: AnyCoMapSchema;
+  schema: CoreCoMapSchema;
   resolve: any;
   value: any;
   owner: Account;
@@ -198,7 +198,7 @@ async function handleMessagePayload({
 }: {
   type: "request" | "response";
   // Skipping type validation here to avoid excessive type complexity that affects the typecheck performance
-  schema: AnyCoMapSchema;
+  schema: CoreCoMapSchema;
   resolve: any;
   request: unknown;
   loadAs: Account;
@@ -290,7 +290,9 @@ async function handleMessagePayload({
     throw new JazzRequestError("Creator account not found", 400);
   }
 
-  const coSchema = anySchemaToCoSchema(schema) as CoValueClass<CoMap>;
+  const coSchema = coValueClassFromCoValueClassOrSchema(
+    schema,
+  ) as CoValueClass<CoMap>;
   const value = await loadCoValue<CoMap, true>(coSchema, requestData.id, {
     resolve,
     loadAs,
@@ -317,13 +319,13 @@ function parseSchemaAndResolve<
   if ("schema" in options) {
     return {
       // Using a type cast to reduce the type complexity
-      schema: coMapDefiner(options.schema) as AnyCoMapSchema,
+      schema: coMapDefiner(options.schema) as CoreCoMapSchema,
       resolve: options.resolve as any,
     };
   }
 
   return {
-    schema: coMapDefiner(options) as AnyCoMapSchema,
+    schema: coMapDefiner(options) as CoreCoMapSchema,
     resolve: true as any,
   };
 }
@@ -335,11 +337,11 @@ class HttpRoute<
   ResponseResolve extends ResolveQuery<CoMapSchema<ResponseShape>> = any,
 > {
   private requestDefinition: {
-    schema: AnyCoMapSchema;
+    schema: CoreCoMapSchema;
     resolve: any;
   };
   private responseDefinition: {
-    schema: AnyCoMapSchema;
+    schema: CoreCoMapSchema;
     resolve: any;
   };
   private url: string;

package/src/tools/coValues/schemaUnion.ts

@@ -6,8 +6,6 @@ import {
   CoValueClass,
   CoValueFromRaw,
   ID,
-  RefsToResolve,
-  RefsToResolveStrict,
   Resolved,
   SubscribeListenerOptions,
   SubscribeRestArgs,
@@ -16,6 +14,12 @@ import {
   subscribeToCoValueWithoutMe,
 } from "../internal.js";
 
+/**
+ * Extends `SchemaUnion` with a non-abstract constructor.
+ */
+export type SchemaUnionConcreteSubclass<V extends CoValue> =
+  typeof SchemaUnion & CoValueClass<V>;
+
 /**
  * SchemaUnion allows you to create union types of CoValues that can be discriminated at runtime.
  *
@@ -86,7 +90,7 @@ export abstract class SchemaUnion extends CoValueBase implements CoValue {
    **/
   static Of<V extends CoValue>(
     discriminator: (raw: V["_raw"]) => CoValueClass<V> & CoValueFromRaw<V>,
-  ): CoValueClass<V> & typeof SchemaUnion {
+  ): SchemaUnionConcreteSubclass<V> {
     return class SchemaUnionClass extends SchemaUnion {
       static override fromRaw<T extends CoValue>(
         this: CoValueClass<T> & CoValueFromRaw<T>,
@@ -97,7 +101,7 @@ export abstract class SchemaUnion extends CoValueBase implements CoValue {
         ) as unknown as CoValueClass<T> & CoValueFromRaw<T>;
         return ResolvedClass.fromRaw(raw);
       }
-    } as unknown as CoValueClass<V> & typeof SchemaUnion;
+    } as unknown as SchemaUnionConcreteSubclass<V>;
   }
 
   /**

package/src/tools/exports.ts

@@ -35,7 +35,6 @@ export type {
   TextPos,
   AccountClass,
   AccountCreationProps,
-  WithHelpers,
 } from "./internal.js";
 
 export {
@@ -49,7 +48,6 @@ export {
   CoRichText,
   Account,
   isControlledAccount,
-  createCoValueObservable,
   loadCoValue,
   subscribeToCoValue,
   ImageDefinition,
@@ -99,26 +97,17 @@ export {
 export type * from "./types.js";
 
 export {
-  zodSchemaToCoSchema,
-  anySchemaToCoSchema,
+  coValueClassFromCoValueClassOrSchema,
   type InstanceOfSchema,
   type InstanceOfSchemaCoValuesNullable,
-  type CoValueOrZodSchema,
+  type CoValueClassOrSchema,
   type Loaded,
   type BaseAccountShape,
   type DefaultAccountShape,
-  type AccountSchema,
-  type AnyAccountSchema,
-  type CoListSchema,
-  type CoMapSchema,
-  type CoFeedSchema,
-  type PlainTextSchema,
-  type FileStreamSchema,
+  type CoreAccountSchema as AnyAccountSchema,
   type ResolveQuery,
   type ResolveQueryStrict,
   type InitFor,
-  type CoRecordSchema,
-  type CoProfileSchema,
 } from "./internal.js";
 
 export {

package/src/tools/implementation/createContext.ts

@@ -1,7 +1,6 @@
 import {
   AgentSecret,
   CoID,
-  ControlledAgent,
   CryptoProvider,
   LocalNode,
   Peer,
@@ -14,12 +13,11 @@ import { AuthSecretStorage } from "../auth/AuthSecretStorage.js";
 import { type Account, type AccountClass } from "../coValues/account.js";
 import { RegisteredSchemas } from "../coValues/registeredSchemas.js";
 import {
-  type AccountSchema,
-  type AnyAccountSchema,
   CoValueFromRaw,
+  type CoreAccountSchema,
   type ID,
   type InstanceOfSchema,
-  anySchemaToCoSchema,
+  coValueClassFromCoValueClassOrSchema,
 } from "../internal.js";
 import { AuthCredentials, NewAccountProps } from "../types.js";
 import { activeAccountContext } from "./activeAccountContext.js";
@@ -89,7 +87,7 @@ export type JazzContext<Acc extends Account> =
 export async function createJazzContextFromExistingCredentials<
   S extends
     | (AccountClass<Account> & CoValueFromRaw<Account>)
-    | AnyAccountSchema,
+    | CoreAccountSchema,
 >({
   credentials,
   peersToLoadFrom,
@@ -115,7 +113,8 @@ export async function createJazzContextFromExistingCredentials<
   const CurrentAccountSchema =
     PropsAccountSchema ?? (RegisteredSchemas["Account"] as unknown as S);
 
-  const AccountClass = anySchemaToCoSchema(CurrentAccountSchema);
+  const AccountClass =
+    coValueClassFromCoValueClassOrSchema(CurrentAccountSchema);
 
   const node = await LocalNode.withLoadedAccount({
     accountID: credentials.accountID as unknown as CoID<RawAccount>,
@@ -153,7 +152,7 @@ export async function createJazzContextFromExistingCredentials<
 export async function createJazzContextForNewAccount<
   S extends
     | (AccountClass<Account> & CoValueFromRaw<Account>)
-    | AnyAccountSchema,
+    | CoreAccountSchema,
 >({
   creationProps,
   initialAgentSecret,
@@ -174,7 +173,8 @@ export async function createJazzContextForNewAccount<
   const CurrentAccountSchema =
     PropsAccountSchema ?? (RegisteredSchemas["Account"] as unknown as S);
 
-  const AccountClass = anySchemaToCoSchema(CurrentAccountSchema);
+  const AccountClass =
+    coValueClassFromCoValueClassOrSchema(CurrentAccountSchema);
 
   const { node } = await LocalNode.withNewlyCreatedAccount({
     creationProps,
@@ -209,7 +209,7 @@ export async function createJazzContextForNewAccount<
 export async function createJazzContext<
   S extends
     | (AccountClass<Account> & CoValueFromRaw<Account>)
-    | AnyAccountSchema,
+    | CoreAccountSchema,
 >(options: {
   credentials?: AuthCredentials;
   newAccountProps?: NewAccountProps;

package/src/tools/implementation/invites.ts

@@ -3,7 +3,7 @@ import { Account } from "../coValues/account.js";
 import type {
   CoValue,
   CoValueClass,
-  CoValueOrZodSchema,
+  CoValueClassOrSchema,
   ID,
 } from "../internal.js";
 
@@ -68,7 +68,7 @@ export function parseInviteLink(inviteURL: string):
 }
 
 /** @category Invite Links */
-export function consumeInviteLink<S extends CoValueOrZodSchema>({
+export function consumeInviteLink<S extends CoValueClassOrSchema>({
   inviteURL,
   as = Account.getMe(),
   forValueHint,

package/src/tools/implementation/schemaUtils.ts

@@ -0,0 +1,18 @@
+/**
+ * Remove getters from an object
+ *
+ * @param obj - The object to remove getters from.
+ * @returns A new object with the getters removed.
+ */
+export function removeGetters<T extends object>(obj: T): Partial<T> {
+  const result: any = {};
+
+  for (const key of Object.keys(obj)) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+    if (!descriptor?.get) {
+      result[key] = (obj as any)[key];
+    }
+  }
+
+  return result;
+}

package/src/tools/implementation/zodSchema/coExport.ts

@@ -1,4 +1,17 @@
 export { Loaded as loaded } from "./zodSchema.js";
+export { CoMapSchema as Map } from "./schemaTypes/CoMapSchema.js";
+export { CoRecordSchema as Record } from "./schemaTypes/CoRecordSchema.js";
+export { CoListSchema as List } from "./schemaTypes/CoListSchema.js";
+export { CoFeedSchema as Feed } from "./schemaTypes/CoFeedSchema.js";
+export { PlainTextSchema as PlainText } from "./schemaTypes/PlainTextSchema.js";
+export { RichTextSchema as RichText } from "./schemaTypes/RichTextSchema.js";
+export { FileStreamSchema as FileStream } from "./schemaTypes/FileStreamSchema.js";
+export {
+  AccountSchema as Account,
+  CoProfileSchema as Profile,
+} from "./schemaTypes/AccountSchema.js";
+export { CoOptionalSchema as Optional } from "./schemaTypes/CoOptionalSchema.js";
+export { CoDiscriminatedUnionSchema as DiscriminatedUnion } from "./schemaTypes/CoDiscriminatedUnionSchema.js";
 export {
   coMapDefiner as map,
   coRecordDefiner as record,
@@ -12,4 +25,5 @@ export {
   coProfileDefiner as profile,
   coOptionalDefiner as optional,
   coDiscriminatedUnionDefiner as discriminatedUnion,
+  ImageDefinitionSchema as Image,
 } from "./zodCo.js";

package/src/tools/implementation/zodSchema/runtimeConverters/coValueSchemaTransformation.ts

@@ -0,0 +1,156 @@
+import { RawCoList, RawCoMap } from "cojson";
+import {
+  Account,
+  CoDiscriminatedUnionSchema,
+  CoFeed,
+  CoFeedSchema,
+  CoList,
+  CoListSchema,
+  CoMap,
+  CoPlainText,
+  CoRichText,
+  CoValueClass,
+  FileStream,
+  FileStreamSchema,
+  PlainTextSchema,
+  SchemaUnion,
+  enrichAccountSchema,
+  enrichCoMapSchema,
+  isCoValueClass,
+} from "../../../internal.js";
+import { coField } from "../../schema.js";
+
+import { CoreCoValueSchema } from "../schemaTypes/CoValueSchema.js";
+import { RichTextSchema } from "../schemaTypes/RichTextSchema.js";
+import { schemaUnionDiscriminatorFor } from "../unionUtils.js";
+import {
+  AnyCoreCoValueSchema,
+  AnyZodOrCoValueSchema,
+  CoValueClassFromAnySchema,
+  CoValueClassOrSchema,
+  CoValueSchemaFromCoreSchema,
+} from "../zodSchema.js";
+import {
+  SchemaField,
+  schemaFieldToCoFieldDef,
+} from "./schemaFieldToCoFieldDef.js";
+
+// Note: if you're editing this function, edit the `isAnyCoValueSchema`
+// function in `zodReExport.ts` as well
+export function isAnyCoValueSchema(
+  schema: AnyZodOrCoValueSchema | CoValueClass,
+): schema is AnyCoreCoValueSchema {
+  return "collaborative" in schema && schema.collaborative === true;
+}
+
+export function isCoValueSchema(
+  schema: AnyZodOrCoValueSchema | CoValueClass,
+): schema is CoValueSchemaFromCoreSchema<AnyCoreCoValueSchema> {
+  return isAnyCoValueSchema(schema) && "getCoValueClass" in schema;
+}
+
+/**
+ * Convert a "core" CoValue schema into a CoValue schema.
+ * See {@link CoreCoValueSchema} for more information.
+ *
+ * @returns The CoValue schema matching the provided CoreCoValueSchema
+ */
+export function hydrateCoreCoValueSchema<S extends AnyCoreCoValueSchema>(
+  schema: S,
+): CoValueSchemaFromCoreSchema<S> {
+  if (isCoValueSchema(schema)) {
+    // If the schema is already a CoValue schema, return it as is
+    return schema as any;
+  }
+
+  if (schema.builtin === "CoOptional") {
+    throw new Error(
+      `co.optional() of collaborative types is not supported as top-level schema: ${JSON.stringify(schema)}`,
+    );
+  } else if (schema.builtin === "CoMap" || schema.builtin === "Account") {
+    const def = schema.getDefinition();
+    const ClassToExtend = schema.builtin === "Account" ? Account : CoMap;
+
+    const coValueClass = class ZCoMap extends ClassToExtend {
+      constructor(options: { fromRaw: RawCoMap } | undefined) {
+        super(options);
+        for (const [fieldName, fieldType] of Object.entries(def.shape)) {
+          (this as any)[fieldName] = schemaFieldToCoFieldDef(
+            fieldType as SchemaField,
+          );
+        }
+        if (def.catchall) {
+          (this as any)[coField.items] = schemaFieldToCoFieldDef(
+            def.catchall as SchemaField,
+          );
+        }
+      }
+    };
+
+    const coValueSchema =
+      ClassToExtend === Account
+        ? enrichAccountSchema(schema as any, coValueClass as any)
+        : enrichCoMapSchema(schema as any, coValueClass as any);
+
+    return coValueSchema as unknown as CoValueSchemaFromCoreSchema<S>;
+  } else if (schema.builtin === "CoList") {
+    const element = schema.element;
+    const coValueClass = class ZCoList extends CoList {
+      constructor(options: { fromRaw: RawCoList } | undefined) {
+        super(options);
+        (this as any)[coField.items] = schemaFieldToCoFieldDef(
+          element as SchemaField,
+        );
+      }
+    };
+
+    const coValueSchema = new CoListSchema(element, coValueClass as any);
+
+    return coValueSchema as unknown as CoValueSchemaFromCoreSchema<S>;
+  } else if (schema.builtin === "CoFeed") {
+    const coValueClass = CoFeed.Of(
+      schemaFieldToCoFieldDef(schema.element as SchemaField),
+    );
+    const coValueSchema = new CoFeedSchema(schema.element, coValueClass);
+    return coValueSchema as unknown as CoValueSchemaFromCoreSchema<S>;
+  } else if (schema.builtin === "FileStream") {
+    const coValueClass = FileStream;
+    return new FileStreamSchema(coValueClass) as CoValueSchemaFromCoreSchema<S>;
+  } else if (schema.builtin === "CoPlainText") {
+    const coValueClass = CoPlainText;
+    return new PlainTextSchema(coValueClass) as CoValueSchemaFromCoreSchema<S>;
+  } else if (schema.builtin === "CoRichText") {
+    const coValueClass = CoRichText;
+    return new RichTextSchema(coValueClass) as CoValueSchemaFromCoreSchema<S>;
+  } else if (schema.builtin === "CoDiscriminatedUnion") {
+    const coValueClass = SchemaUnion.Of(schemaUnionDiscriminatorFor(schema));
+    const coValueSchema = new CoDiscriminatedUnionSchema(schema, coValueClass);
+    return coValueSchema as CoValueSchemaFromCoreSchema<S>;
+  } else {
+    const notReachable: never = schema;
+    throw new Error(
+      `Unsupported zod CoValue type for top-level schema: ${JSON.stringify(notReachable, undefined, 2)}`,
+    );
+  }
+}
+
+/**
+ * Convert a CoValue class or a CoValue schema into a CoValue class.
+ *
+ * This function bridges the gap between CoValue classes created with the class syntax,
+ * and CoValue classes created with our `co.` definers.
+ *
+ * @param schema A CoValue class or a CoValue schema
+ * @returns The same CoValue class, or a CoValue class that matches the provided schema
+ */
+export function coValueClassFromCoValueClassOrSchema<
+  S extends CoValueClassOrSchema,
+>(schema: S): CoValueClassFromAnySchema<S> {
+  if (isCoValueClass(schema)) {
+    return schema as any;
+  } else if (isCoValueSchema(schema)) {
+    return schema.getCoValueClass() as any;
+  }
+
+  throw new Error(`Unsupported schema: ${JSON.stringify(schema)}`);
+}