jazz-tools 0.13.31 → 0.14.0

package/src/implementation/zodSchema/runtimeConverters/zodSchemaToCoSchema.ts

@@ -0,0 +1,191 @@
+import { RawCoList, RawCoMap } from "cojson";
+import z from "zod/v4";
+import {
+  Account,
+  CoFeed,
+  CoList,
+  CoMap,
+  CoPlainText,
+  CoRichText,
+  CoValueClass,
+  FileStream,
+  SchemaUnion,
+  isCoValueClass,
+} from "../../../internal.js";
+import { coField } from "../../schema.js";
+import {
+  isUnionOfCoMapsDeeply,
+  schemaUnionDiscriminatorFor,
+} from "../unionUtils.js";
+import {
+  CoValueClassFromZodSchema,
+  ZodPrimitiveSchema,
+  getDef,
+  isZodArray,
+  isZodCustom,
+  isZodObject,
+} from "../zodSchema.js";
+import { zodFieldToCoFieldDef } from "./zodFieldToCoFieldDef.js";
+
+let coSchemasForZodSchemas = new Map<z.core.$ZodType, CoValueClass>();
+
+export function tryZodSchemaToCoSchema<S extends z.core.$ZodType>(
+  schema: S,
+): CoValueClassFromZodSchema<S> | null {
+  if ("collaborative" in schema && schema.collaborative) {
+    if (coSchemasForZodSchemas.has(schema)) {
+      return coSchemasForZodSchemas.get(schema) as CoValueClassFromZodSchema<S>;
+    }
+
+    if (isZodObject(schema)) {
+      const def = getDef(schema);
+
+      const ClassToExtend =
+        "builtin" in schema && schema.builtin === "Account" ? Account : CoMap;
+
+      const coSchema = class ZCoMap extends ClassToExtend {
+        constructor(options: { fromRaw: RawCoMap } | undefined) {
+          super(options);
+          for (const [field, fieldType] of Object.entries(
+            def.shape as z.core.$ZodShape,
+          )) {
+            (this as any)[field] = zodFieldToCoFieldDef(
+              zodSchemaToCoSchemaOrKeepPrimitive(fieldType),
+            );
+          }
+          if (def.catchall) {
+            (this as any)[coField.items] = zodFieldToCoFieldDef(
+              zodSchemaToCoSchemaOrKeepPrimitive(def.catchall),
+            );
+          }
+        }
+      };
+
+      if ("migration" in schema) {
+        const migration = schema.migration;
+        if (typeof migration !== "function") {
+          throw new Error("migration must be a function");
+        }
+        (coSchema.prototype as Account).migrate = async function (
+          this,
+          creationProps,
+        ) {
+          await migration(this, creationProps);
+        };
+      }
+
+      coSchemasForZodSchemas.set(schema, coSchema as unknown as CoValueClass);
+      return coSchema as unknown as CoValueClassFromZodSchema<S>;
+    } else if (isZodArray(schema)) {
+      const def = getDef(schema);
+      const coSchema = class ZCoList extends CoList {
+        constructor(options: { fromRaw: RawCoList } | undefined) {
+          super(options);
+          (this as any)[coField.items] = zodFieldToCoFieldDef(
+            zodSchemaToCoSchemaOrKeepPrimitive(def.element),
+          );
+        }
+      };
+
+      coSchemasForZodSchemas.set(schema, coSchema);
+      return coSchema as unknown as CoValueClassFromZodSchema<S>;
+    } else if (isZodCustom(schema)) {
+      if ("builtin" in schema) {
+        if (schema.builtin === "CoFeed" && "element" in schema) {
+          return CoFeed.Of(
+            zodFieldToCoFieldDef(
+              zodSchemaToCoSchemaOrKeepPrimitive(
+                schema.element as z.core.$ZodType,
+              ),
+            ),
+          ) as unknown as CoValueClassFromZodSchema<S>;
+        } else if (schema.builtin === "FileStream") {
+          return FileStream as unknown as CoValueClassFromZodSchema<S>;
+        } else if (schema.builtin === "CoPlainText") {
+          return CoPlainText as unknown as CoValueClassFromZodSchema<S>;
+        } else if (schema.builtin === "CoRichText") {
+          return CoRichText as unknown as CoValueClassFromZodSchema<S>;
+        } else {
+          throw new Error(`Unsupported builtin type: ${schema.builtin}`);
+        }
+      } else {
+        throw new Error(`Unsupported custom zod type`);
+      }
+    } else {
+      throw new Error(
+        `Unsupported zod CoValue type for top-level schema: ${schema._zod?.def?.type || JSON.stringify(schema, undefined, 2)}`,
+      );
+    }
+  } else if (schema instanceof z.core.$ZodDiscriminatedUnion) {
+    if (isUnionOfCoMapsDeeply(schema)) {
+      return SchemaUnion.Of(
+        schemaUnionDiscriminatorFor(schema),
+      ) as unknown as CoValueClassFromZodSchema<S>;
+    } else {
+      throw new Error(
+        "z.discriminatedUnion() of non-collaborative types is not supported as a top-level schema",
+      );
+    }
+  } else {
+    return null;
+  }
+}
+
+export function zodSchemaToCoSchema<
+  S extends
+    | z.core.$ZodType
+    | (z.core.$ZodObject<any, any> & {
+        builtin: "Account";
+        migration?: (account: any, creationProps?: { name: string }) => void;
+      })
+    | (z.core.$ZodCustom<any, any> & { builtin: "FileStream" })
+    | (z.core.$ZodCustom<any, any> & {
+        builtin: "CoFeed";
+        element: z.core.$ZodType;
+      }),
+>(schema: S): CoValueClassFromZodSchema<S> {
+  const coSchema = tryZodSchemaToCoSchema(schema);
+  if (!coSchema) {
+    throw new Error(
+      `Unsupported zod type: ${schema._zod?.def?.type || JSON.stringify(schema)}`,
+    );
+  }
+  return coSchema;
+}
+
+export function anySchemaToCoSchema<
+  S extends
+    | CoValueClass
+    | z.core.$ZodType
+    | (z.core.$ZodObject<any, any> & {
+        builtin: "Account";
+        migration?: (account: any, creationProps?: { name: string }) => void;
+      })
+    | (z.core.$ZodCustom<any, any> & { builtin: "FileStream" })
+    | (z.core.$ZodCustom<any, any> & {
+        builtin: "CoFeed";
+        element: z.core.$ZodType;
+      }),
+>(
+  schema: S,
+): S extends CoValueClass
+  ? S
+  : S extends z.core.$ZodType
+    ? CoValueClassFromZodSchema<S>
+    : never {
+  if (isCoValueClass(schema)) {
+    return schema as any;
+  } else {
+    return zodSchemaToCoSchema(schema as any) as any;
+  }
+}
+
+export function zodSchemaToCoSchemaOrKeepPrimitive<S extends z.core.$ZodType>(
+  schema: S,
+): CoValueClassFromZodSchema<S> | ZodPrimitiveSchema {
+  const coSchema = tryZodSchemaToCoSchema(schema);
+  if (!coSchema) {
+    return schema as any;
+  }
+  return coSchema;
+}

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

@@ -0,0 +1,102 @@
+import { CryptoProvider } from "cojson";
+import z from "zod/v4";
+import {
+  Account,
+  Group,
+  RefsToResolveStrict,
+  Simplify,
+} from "../../../internal.js";
+import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
+import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
+import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
+import { Loaded, ResolveQuery } from "../zodSchema.js";
+import {
+  AnyCoMapSchema,
+  CoMapInitZod,
+  CoMapInstance,
+  CoMapSchema,
+} from "./CoMapSchema.js";
+
+export type AccountSchema<
+  Shape extends {
+    profile: AnyCoMapSchema<{
+      name: z.core.$ZodString<string>;
+      inbox?: z.core.$ZodOptional<z.core.$ZodString>;
+      inboxInvite?: z.core.$ZodOptional<z.core.$ZodString>;
+    }>;
+    root: AnyCoMapSchema;
+  } = {
+    profile: CoMapSchema<{
+      name: z.core.$ZodString<string>;
+      inbox?: z.core.$ZodOptional<z.core.$ZodString>;
+      inboxInvite?: z.core.$ZodOptional<z.core.$ZodString>;
+    }>;
+    root: CoMapSchema<{}>;
+  },
+> = Omit<CoMapSchema<Shape>, "create" | "load"> & {
+  builtin: "Account";
+
+  create: (options: {
+    creationProps?: { name: string };
+    crypto?: CryptoProvider;
+  }) => Promise<AccountInstance<Shape>>;
+
+  load: <R extends ResolveQuery<AccountSchema<Shape>>>(
+    id: string,
+    options?: {
+      loadAs?: Account | AnonymousJazzAgent;
+      resolve?: RefsToResolveStrict<AccountSchema<Shape>, R>;
+    },
+  ) => Promise<Loaded<AccountSchema<Shape>, R> | null>;
+
+  createAs: (
+    as: Account,
+    options: {
+      creationProps?: { name: string };
+    },
+  ) => Promise<AccountInstance<Shape>>;
+
+  getMe: () => AccountInstanceCoValuesNullable<Shape>;
+
+  withMigration(
+    migration: (
+      account: InstanceOrPrimitiveOfSchema<AccountSchema<Shape>>,
+      creationProps?: { name: string },
+    ) => void,
+  ): AccountSchema<Shape>;
+};
+
+export type DefaultProfileShape = {
+  name: z.core.$ZodString<string>;
+  inbox: z.core.$ZodOptional<z.core.$ZodString>;
+  inboxInvite: z.core.$ZodOptional<z.core.$ZodString>;
+};
+
+export type CoProfileSchema<
+  Shape extends z.core.$ZodLooseShape = DefaultProfileShape,
+> = Omit<CoMapSchema<Shape & DefaultProfileShape>, "create"> & {
+  create: (
+    init: Simplify<CoMapInitZod<Shape & DefaultProfileShape>>,
+    options: { owner: Exclude<Group, Account> } | Exclude<Group, Account>,
+  ) => CoMapInstance<Shape & Simplify<DefaultProfileShape>>;
+};
+
+// less precise verion to avoid circularity issues and allow matching against
+export type AnyAccountSchema<
+  Shape extends z.core.$ZodLooseShape = z.core.$ZodLooseShape,
+> = z.core.$ZodObject<Shape> & {
+  collaborative: true;
+  builtin: "Account";
+};
+
+export type AccountInstance<Shape extends z.core.$ZodLooseShape> = {
+  -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
+} & Account;
+
+export type AccountInstanceCoValuesNullable<
+  Shape extends z.core.$ZodLooseShape,
+> = {
+  -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
+    Shape[key]
+  >;
+} & Account;

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

@@ -0,0 +1,70 @@
+import z from "zod/v4";
+import {
+  Account,
+  CoFeed,
+  Group,
+  RefsToResolve,
+  RefsToResolveStrict,
+  Resolved,
+  SubscribeListenerOptions,
+} from "../../../internal.js";
+import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
+import { InstanceOfSchema } from "../typeConverters/InstanceOfSchema.js";
+import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
+import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
+
+export type CoFeedSchema<T extends z.core.$ZodType> = z.core.$ZodCustom<
+  CoFeed<InstanceOfSchema<T>>,
+  unknown
+> & {
+  collaborative: true;
+  builtin: "CoFeed";
+  element: T;
+
+  create(
+    init: InstanceOrPrimitiveOfSchema<T>[],
+    options?: { owner: Account | Group } | Account | Group,
+  ): CoFeedInstance<T>;
+
+  load<const R extends RefsToResolve<CoFeedInstanceCoValuesNullable<T>> = true>(
+    id: string,
+    options?: {
+      resolve?: RefsToResolveStrict<CoFeedInstanceCoValuesNullable<T>, R>;
+      loadAs?: Account | AnonymousJazzAgent;
+    },
+  ): Promise<Resolved<CoFeedInstanceCoValuesNullable<T>, R> | null>;
+
+  subscribe(
+    id: string,
+    listener: (
+      value: Resolved<CoFeedInstanceCoValuesNullable<T>, true>,
+      unsubscribe: () => void,
+    ) => void,
+  ): () => void;
+  subscribe<
+    const R extends RefsToResolve<CoFeedInstanceCoValuesNullable<T>> = true,
+  >(
+    id: string,
+    options: SubscribeListenerOptions<CoFeedInstanceCoValuesNullable<T>, R>,
+    listener: (
+      value: Resolved<CoFeedInstanceCoValuesNullable<T>, R>,
+      unsubscribe: () => void,
+    ) => void,
+  ): () => void;
+};
+
+// less precise verion to avoid circularity issues and allow matching against
+export type AnyCoFeedSchema<T extends z.core.$ZodType = z.core.$ZodType> =
+  z.core.$ZodCustom<any, unknown> & {
+    collaborative: true;
+    builtin: "CoFeed";
+    element: T;
+  };
+
+export type CoFeedInstance<T extends z.core.$ZodType> = CoFeed<
+  InstanceOrPrimitiveOfSchema<T>
+>;
+
+export type CoFeedInstanceCoValuesNullable<T extends z.core.$ZodType> = CoFeed<
+  InstanceOrPrimitiveOfSchemaCoValuesNullable<T>
+>;

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

@@ -0,0 +1,59 @@
+import z from "zod/v4";
+import {
+  Account,
+  CoList,
+  Group,
+  RefsToResolve,
+  RefsToResolveStrict,
+  Resolved,
+  SubscribeListenerOptions,
+} from "../../../internal.js";
+import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
+import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
+import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
+import { WithHelpers } from "../zodSchema.js";
+
+export type CoListSchema<T extends z.core.$ZodType> = z.core.$ZodArray<T> & {
+  collaborative: true;
+
+  create: (
+    items: InstanceOrPrimitiveOfSchema<T>[],
+    options?: { owner: Account | Group } | Account | Group,
+  ) => CoList<InstanceOrPrimitiveOfSchema<T>>;
+
+  load<const R extends RefsToResolve<CoListInstanceCoValuesNullable<T>> = true>(
+    id: string,
+    options?: {
+      resolve?: RefsToResolveStrict<CoListInstanceCoValuesNullable<T>, R>;
+      loadAs?: Account | AnonymousJazzAgent;
+    },
+  ): Promise<Resolved<CoListInstanceCoValuesNullable<T>, R> | null>;
+
+  subscribe<
+    const R extends RefsToResolve<CoListInstanceCoValuesNullable<T>> = true,
+  >(
+    id: string,
+    options: SubscribeListenerOptions<CoListInstanceCoValuesNullable<T>, R>,
+    listener: (
+      value: Resolved<CoListInstanceCoValuesNullable<T>, R>,
+      unsubscribe: () => void,
+    ) => void,
+  ): () => void;
+
+  withHelpers<S extends z.core.$ZodType, T extends object>(
+    this: S,
+    helpers: (Self: S) => T,
+  ): WithHelpers<S, T>;
+};
+
+// less precise verion to avoid circularity issues and allow matching against
+export type AnyCoListSchema<T extends z.core.$ZodType = z.core.$ZodType> =
+  z.core.$ZodArray<T> & { collaborative: true };
+
+export type CoListInstance<T extends z.core.$ZodType> = CoList<
+  InstanceOrPrimitiveOfSchema<T>
+>;
+
+export type CoListInstanceCoValuesNullable<T extends z.core.$ZodType> = CoList<
+  InstanceOrPrimitiveOfSchemaCoValuesNullable<T>
+>;

package/src/implementation/zodSchema/schemaTypes/CoMapSchema.ts

@@ -0,0 +1,126 @@
+import { CoValueUniqueness } from "cojson";
+import z from "zod/v4";
+import {
+  Account,
+  CoMap,
+  Group,
+  RefsToResolve,
+  RefsToResolveStrict,
+  Resolved,
+  Simplify,
+  SubscribeListenerOptions,
+} from "../../../internal.js";
+import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
+import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
+import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
+import { FullyOrPartiallyLoaded, WithHelpers } from "../zodSchema.js";
+
+export type CoMapSchema<
+  Shape extends z.core.$ZodLooseShape,
+  Config extends z.core.$ZodObjectConfig = z.core.$ZodObjectConfig,
+> = z.core.$ZodObject<Shape, Config> &
+  z.$ZodTypeDiscriminable & {
+    collaborative: true;
+
+    create: (
+      init: Simplify<CoMapInitZod<Shape>>,
+      options?:
+        | {
+            owner: Account | Group;
+            unique?: CoValueUniqueness["uniqueness"];
+          }
+        | Account
+        | Group,
+    ) => (Shape extends Record<string, never>
+      ? {}
+      : {
+          -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
+            Shape[key]
+          >;
+        }) &
+      (unknown extends Config["out"][string]
+        ? {}
+        : {
+            [key: string]: Config["out"][string];
+          }) &
+      CoMap;
+
+    load<
+      const R extends RefsToResolve<
+        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
+      > = true,
+    >(
+      id: string,
+      options?: {
+        resolve?: RefsToResolveStrict<
+          Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+          R
+        >;
+        loadAs?: Account | AnonymousJazzAgent;
+      },
+    ): Promise<Resolved<
+      Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+      R
+    > | null>;
+
+    subscribe<
+      const R extends RefsToResolve<
+        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
+      > = true,
+    >(
+      id: string,
+      options: SubscribeListenerOptions<
+        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+        R
+      >,
+      listener: (
+        value: Resolved<
+          Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+          R
+        >,
+        unsubscribe: () => void,
+      ) => void,
+    ): () => void;
+
+    findUnique(
+      unique: CoValueUniqueness["uniqueness"],
+      ownerID: string,
+      as?: Account | Group | AnonymousJazzAgent,
+    ): string;
+
+    catchall<T extends z.core.$ZodType>(
+      schema: T,
+    ): CoMapSchema<Shape, z.core.$catchall<T>>;
+
+    withHelpers<S extends z.core.$ZodType, T extends object>(
+      this: S,
+      helpers: (Self: S) => T,
+    ): WithHelpers<S, T>;
+  };
+
+export type CoMapInitZod<Shape extends z.core.$ZodLooseShape> = {
+  [key in keyof Shape as Shape[key] extends z.core.$ZodOptional<any>
+    ? key
+    : never]?: FullyOrPartiallyLoaded<Shape[key]>;
+} & {
+  [key in keyof Shape as Shape[key] extends z.core.$ZodOptional<any>
+    ? never
+    : key]: FullyOrPartiallyLoaded<Shape[key]>;
+};
+
+// less precise verion to avoid circularity issues and allow matching against
+export type AnyCoMapSchema<
+  Shape extends z.core.$ZodLooseShape = z.core.$ZodLooseShape,
+  Config extends z.core.$ZodObjectConfig = z.core.$ZodObjectConfig,
+> = z.core.$ZodObject<Shape, Config> & { collaborative: true };
+
+export type CoMapInstance<Shape extends z.core.$ZodLooseShape> = {
+  -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
+} & CoMap;
+
+export type CoMapInstanceCoValuesNullable<Shape extends z.core.$ZodLooseShape> =
+  {
+    -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
+      Shape[key]
+    >;
+  };

package/src/implementation/zodSchema/schemaTypes/CoRecordSchema.ts

@@ -0,0 +1,98 @@
+import { CoValueUniqueness } from "cojson";
+import z from "zod/v4";
+import {
+  Account,
+  CoMap,
+  Group,
+  ID,
+  RefsToResolve,
+  RefsToResolveStrict,
+  Resolved,
+  Simplify,
+  SubscribeListenerOptions,
+} from "../../../internal.js";
+import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
+import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
+import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
+import { WithHelpers } from "../zodSchema.js";
+
+export type CoRecordSchema<
+  K extends z.core.$ZodString<string>,
+  V extends z.core.$ZodType,
+> = z.core.$ZodRecord<K, V> & {
+  collaborative: true;
+
+  create: (
+    init: Simplify<{
+      [key in z.output<K>]?: InstanceOrPrimitiveOfSchema<V>;
+    }>,
+    options?:
+      | {
+          owner: Account | Group;
+          unique?: CoValueUniqueness["uniqueness"];
+        }
+      | Account
+      | Group,
+  ) => {
+    [key in z.output<K>]: InstanceOrPrimitiveOfSchema<V>;
+  } & CoMap;
+
+  load<
+    const R extends RefsToResolve<
+      CoRecordInstanceCoValuesNullable<K, V>
+    > = true,
+  >(
+    id: ID<CoRecordInstanceCoValuesNullable<K, V>>,
+    options?: {
+      resolve?: RefsToResolveStrict<CoRecordInstanceCoValuesNullable<K, V>, R>;
+      loadAs?: Account | AnonymousJazzAgent;
+    },
+  ): Promise<Resolved<CoRecordInstanceCoValuesNullable<K, V>, R> | null>;
+
+  subscribe<
+    const R extends RefsToResolve<
+      CoRecordInstanceCoValuesNullable<K, V>
+    > = true,
+  >(
+    id: ID<CoRecordInstanceCoValuesNullable<K, V>>,
+    options: SubscribeListenerOptions<
+      CoRecordInstanceCoValuesNullable<K, V>,
+      R
+    >,
+    listener: (
+      value: Resolved<CoRecordInstanceCoValuesNullable<K, V>, R>,
+      unsubscribe: () => void,
+    ) => void,
+  ): () => void;
+
+  findUnique(
+    unique: CoValueUniqueness["uniqueness"],
+    ownerID: ID<Account> | ID<Group>,
+    as?: Account | Group | AnonymousJazzAgent,
+  ): ID<CoRecordInstanceCoValuesNullable<K, V>>;
+
+  withHelpers<S extends z.core.$ZodType, T extends object>(
+    this: S,
+    helpers: (Self: S) => T,
+  ): WithHelpers<S, T>;
+};
+
+// less precise verion to avoid circularity issues and allow matching against
+export type AnyCoRecordSchema<
+  K extends z.core.$ZodString<string> = z.core.$ZodString<string>,
+  V extends z.core.$ZodType = z.core.$ZodType,
+> = z.core.$ZodRecord<K, V> & { collaborative: true };
+
+export type CoRecordInstance<
+  K extends z.core.$ZodString<string>,
+  V extends z.core.$ZodType,
+> = {
+  [key in z.output<K>]: InstanceOrPrimitiveOfSchema<V>;
+} & CoMap;
+
+export type CoRecordInstanceCoValuesNullable<
+  K extends z.core.$ZodString<string>,
+  V extends z.core.$ZodType,
+> = {
+  [key in z.output<K>]: InstanceOrPrimitiveOfSchemaCoValuesNullable<V>;
+} & CoMap;

package/src/implementation/zodSchema/schemaTypes/FileStreamSchema.ts

@@ -0,0 +1,9 @@
+import z from "zod/v4";
+import { FileStream } from "../../../internal.js";
+
+export type FileStreamSchema = z.core.$ZodCustom<FileStream, unknown> & {
+  collaborative: true;
+  builtin: "FileStream";
+  create: (typeof FileStream)["create"];
+  createFromBlob: (typeof FileStream)["createFromBlob"];
+};

package/src/implementation/zodSchema/schemaTypes/PlainTextSchema.ts

@@ -0,0 +1,27 @@
+import { RawCoPlainText } from "cojson";
+import z from "zod/v4";
+import { Account, CoPlainText, Group } from "../../../internal.js";
+import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
+
+export type PlainTextSchema = z.core.$ZodCustom<CoPlainText, unknown> & {
+  collaborative: true;
+  builtin: "CoPlainText";
+  create(
+    text: string,
+    options?: { owner: Account | Group } | Account | Group,
+  ): CoPlainText;
+  load(
+    id: string,
+    options: { loadAs: Account | AnonymousJazzAgent },
+  ): Promise<CoPlainText>;
+  subscribe(
+    id: string,
+    options: { loadAs: Account | AnonymousJazzAgent },
+    listener: (value: CoPlainText, unsubscribe: () => void) => void,
+  ): () => void;
+  subscribe(
+    id: string,
+    listener: (value: CoPlainText, unsubscribe: () => void) => void,
+  ): () => void;
+  fromRaw(raw: RawCoPlainText): CoPlainText;
+};