jazz-tools 0.16.2 → 0.16.3

package/src/tools/coValues/coList.ts

@@ -29,6 +29,7 @@ import {
   coValuesCache,
   ensureCoValueLoaded,
   inspect,
+  instantiateRefEncodedWithInit,
   isRefEncoded,
   loadCoValueWithoutMe,
   makeRefs,
@@ -240,7 +241,7 @@ export class CoList<out Item = any> extends Array<Item> implements CoValue {
     const { owner } = parseCoValueCreateOptions(options);
     const instance = new this({ init: items, owner });
     const raw = owner._raw.createList(
-      toRawItems(items, instance._schema[ItemsSym]),
+      toRawItems(items, instance._schema[ItemsSym], owner),
     );
 
     Object.defineProperties(instance, {
@@ -256,7 +257,7 @@ export class CoList<out Item = any> extends Array<Item> implements CoValue {
 
   push(...items: Item[]): number {
     this._raw.appendItems(
-      toRawItems(items, this._schema[ItemsSym]),
+      toRawItems(items, this._schema[ItemsSym], this._owner),
       undefined,
       "private",
     );
@@ -265,7 +266,11 @@ export class CoList<out Item = any> extends Array<Item> implements CoValue {
   }
 
   unshift(...items: Item[]): number {
-    for (const item of toRawItems(items as Item[], this._schema[ItemsSym])) {
+    for (const item of toRawItems(
+      items as Item[],
+      this._schema[ItemsSym],
+      this._owner,
+    )) {
       this._raw.prepend(item);
     }
 
@@ -306,7 +311,11 @@ export class CoList<out Item = any> extends Array<Item> implements CoValue {
       this._raw.delete(idxToDelete);
     }
 
-    const rawItems = toRawItems(items as Item[], this._schema[ItemsSym]);
+    const rawItems = toRawItems(
+      items as Item[],
+      this._schema[ItemsSym],
+      this._owner,
+    );
 
     // If there are no items to insert, return the deleted items
     if (rawItems.length === 0) {
@@ -551,23 +560,36 @@ export class CoList<out Item = any> extends Array<Item> implements CoValue {
  * Convert an array of items to a raw array of items.
  * @param items - The array of items to convert.
  * @param itemDescriptor - The descriptor of the items.
+ * @param owner - The owner of the CoList.
  * @returns The raw array of items.
  */
-function toRawItems<Item>(items: Item[], itemDescriptor: Schema) {
-  const rawItems =
-    itemDescriptor === "json"
-      ? (items as JsonValue[])
-      : "encoded" in itemDescriptor
-        ? items?.map((e) => itemDescriptor.encoded.encode(e))
-        : isRefEncoded(itemDescriptor)
-          ? items?.map((v) => {
-              if (!v) return null;
-
-              return (v as unknown as CoValue).id;
-            })
-          : (() => {
-              throw new Error("Invalid element descriptor");
-            })();
+function toRawItems<Item>(
+  items: Item[],
+  itemDescriptor: Schema,
+  owner: Account | Group,
+) {
+  let rawItems: JsonValue[] = [];
+  if (itemDescriptor === "json") {
+    rawItems = items as JsonValue[];
+  } else if ("encoded" in itemDescriptor) {
+    rawItems = items?.map((e) => itemDescriptor.encoded.encode(e));
+  } else if (isRefEncoded(itemDescriptor)) {
+    rawItems = items?.map((value) => {
+      if (value == null) return null;
+      let refId = (value as unknown as CoValue).id;
+      if (!refId) {
+        const coValue = instantiateRefEncodedWithInit(
+          itemDescriptor,
+          value,
+          owner,
+        );
+        refId = coValue.id;
+      }
+      return refId;
+    });
+  } else {
+    throw new Error("Invalid element descriptor");
+  }
   return rawItems;
 }
 

package/src/tools/coValues/coMap.ts

@@ -37,6 +37,7 @@ import {
   activeAccountContext,
   ensureCoValueLoaded,
   inspect,
+  instantiateRefEncodedWithInit,
   isRefEncoded,
   loadCoValueWithoutMe,
   makeRefs,
@@ -424,8 +425,17 @@ export class CoMap extends CoValueBase implements CoValue {
         if (descriptor === "json") {
           rawInit[key] = initValue as JsonValue;
         } else if (isRefEncoded(descriptor)) {
-          if (initValue) {
-            rawInit[key] = (initValue as unknown as CoValue).id;
+          if (initValue != null) {
+            let refId = (initValue as unknown as CoValue).id;
+            if (!refId) {
+              const coValue = instantiateRefEncodedWithInit(
+                descriptor,
+                initValue,
+                owner,
+              );
+              refId = coValue.id;
+            }
+            rawInit[key] = refId;
           }
         } else if ("encoded" in descriptor) {
           rawInit[key] = descriptor.encoded.encode(

package/src/tools/coValues/inbox.ts

@@ -145,7 +145,7 @@ export class Inbox {
 
       for (const [sessionID, items] of Object.entries(stream.items) as [
         SessionID,
-        CoStreamItem<CoID<InboxMessage<InstanceOfSchema<M>, O>>>[],
+        CoStreamItem<CoID<InboxMessage<NonNullable<InstanceOfSchema<M>>, O>>>[],
       ][]) {
         const accountID = getAccountIDfromSessionID(sessionID);
 

package/src/tools/coValues/schemaUnion.ts

@@ -1,12 +1,16 @@
+import { JsonValue, RawCoMap } from "cojson";
 import {
   Account,
   AnonymousJazzAgent,
+  CoMapInit,
   CoValue,
   CoValueBase,
   CoValueClass,
   CoValueFromRaw,
+  Group,
   ID,
   Resolved,
+  Simplify,
   SubscribeListenerOptions,
   SubscribeRestArgs,
   loadCoValueWithoutMe,
@@ -20,6 +24,10 @@ import {
 export type SchemaUnionConcreteSubclass<V extends CoValue> =
   typeof SchemaUnion & CoValueClass<V>;
 
+export type SchemaUnionDiscriminator<V extends CoValue> = (discriminable: {
+  get(key: string): JsonValue | undefined;
+}) => CoValueClass<V> & CoValueFromRaw<V>;
+
 /**
  * SchemaUnion allows you to create union types of CoValues that can be discriminated at runtime.
  *
@@ -89,28 +97,45 @@ export abstract class SchemaUnion extends CoValueBase implements CoValue {
    * @category Declaration
    **/
   static Of<V extends CoValue>(
-    discriminator: (raw: V["_raw"]) => CoValueClass<V> & CoValueFromRaw<V>,
+    discriminator: SchemaUnionDiscriminator<V>,
   ): SchemaUnionConcreteSubclass<V> {
     return class SchemaUnionClass extends SchemaUnion {
+      static override create<V extends CoValue>(
+        this: CoValueClass<V>,
+        init: Simplify<CoMapInit<V>>,
+        owner: Account | Group,
+      ): V {
+        const ResolvedClass = discriminator(new Map(Object.entries(init)));
+        // @ts-expect-error - create is a static method in the CoMap class
+        return ResolvedClass.create(init, owner);
+      }
+
       static override fromRaw<T extends CoValue>(
         this: CoValueClass<T> & CoValueFromRaw<T>,
         raw: T["_raw"],
       ): T {
         const ResolvedClass = discriminator(
-          raw as V["_raw"],
+          raw as RawCoMap,
         ) as unknown as CoValueClass<T> & CoValueFromRaw<T>;
         return ResolvedClass.fromRaw(raw);
       }
     } as unknown as SchemaUnionConcreteSubclass<V>;
   }
 
+  static create<V extends CoValue>(
+    this: CoValueClass<V>,
+    init: Simplify<CoMapInit<V>>,
+    owner: Account | Group,
+  ): V {
+    throw new Error("Not implemented");
+  }
+
   /**
    * Create an instance from raw data. This is called internally and should not be used directly.
    * Use {@link SchemaUnion.Of} to create a union type instead.
    *
    * @internal
    */
-  // @ts-ignore
   static fromRaw<V extends CoValue>(this: CoValueClass<V>, raw: V["_raw"]): V {
     throw new Error("Not implemented");
   }

package/src/tools/exports.ts

@@ -107,7 +107,6 @@ export {
   type CoreAccountSchema as AnyAccountSchema,
   type ResolveQuery,
   type ResolveQueryStrict,
-  type InitFor,
 } from "./internal.js";
 
 export {

package/src/tools/implementation/schema.ts

@@ -1,11 +1,12 @@
 import type { JsonValue, RawCoValue } from "cojson";
 import { CojsonInternalTypes } from "cojson";
 import {
+  Account,
   type CoValue,
   type CoValueClass,
   CoValueFromRaw,
+  Group,
   ItemsSym,
-  JazzToolsSymbol,
   SchemaInit,
   isCoValueClass,
 } from "../internal.js";
@@ -140,7 +141,7 @@ export function isRefEncoded<V extends CoValue>(
   );
 }
 
-export function instantiateRefEncoded<V extends CoValue>(
+export function instantiateRefEncodedFromRaw<V extends CoValue>(
   schema: RefEncoded<V>,
   raw: RawCoValue,
 ): V {
@@ -151,6 +152,31 @@ export function instantiateRefEncoded<V extends CoValue>(
       ).fromRaw(raw);
 }
 
+/**
+ * Creates a new CoValue of the given ref type, using the provided init values.
+ *
+ * @param schema - The schema of the CoValue to create.
+ * @param init - The init values to use to create the CoValue.
+ * @param parentOwner - The owner of the referencing CoValue. Will be used
+ * as the parent group of the created CoValue's group
+ * @returns The created CoValue.
+ */
+export function instantiateRefEncodedWithInit<V extends CoValue>(
+  schema: RefEncoded<V>,
+  init: any,
+  parentOwner: Account | Group,
+): V {
+  if (!isCoValueClass<V>(schema.ref)) {
+    throw Error(
+      `Cannot automatically create CoValue from value: ${JSON.stringify(init)}. Use the CoValue schema's create() method instead.`,
+    );
+  }
+  const owner = Group.create();
+  owner.addMember(parentOwner.castAs(Group));
+  // @ts-expect-error - create is a static method in all CoValue classes
+  return schema.ref.create(init, owner);
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Schema = JsonEncoded | RefEncoded<CoValue> | EncodedAs<any>;
 

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

@@ -6,21 +6,16 @@ import {
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
-  Simplify,
   SubscribeListenerOptions,
   coOptionalDefiner,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
-import { CoFieldInit } from "../typeConverters/CoFieldInit.js";
+import { CoFeedInit } from "../typeConverters/CoFieldInit.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
 import { CoreCoValueSchema } from "./CoValueSchema.js";
 
-type CoFeedInit<T extends AnyZodOrCoValueSchema> = Simplify<
-  Array<CoFieldInit<T>>
->;
-
 export class CoFeedSchema<T extends AnyZodOrCoValueSchema>
   implements CoreCoFeedSchema<T>
 {
@@ -36,7 +31,7 @@ export class CoFeedSchema<T extends AnyZodOrCoValueSchema>
     init: CoFeedInit<T>,
     options?: { owner: Account | Group } | Account | Group,
   ): CoFeedInstance<T> {
-    return this.coValueClass.create(init, options) as CoFeedInstance<T>;
+    return this.coValueClass.create(init as any, options) as CoFeedInstance<T>;
   }
 
   load<const R extends RefsToResolve<CoFeedInstanceCoValuesNullable<T>> = true>(

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

@@ -5,22 +5,17 @@ import {
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
-  Simplify,
   SubscribeListenerOptions,
   coOptionalDefiner,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
-import { CoFieldInit } from "../typeConverters/CoFieldInit.js";
+import { CoListInit } from "../typeConverters/CoFieldInit.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 import { AnyZodOrCoValueSchema } from "../zodSchema.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
 import { CoreCoValueSchema } from "./CoValueSchema.js";
 
-type CoListInit<T extends AnyZodOrCoValueSchema> = Simplify<
-  Array<CoFieldInit<T>>
->;
-
 export class CoListSchema<T extends AnyZodOrCoValueSchema>
   implements CoreCoListSchema<T>
 {
@@ -36,7 +31,7 @@ export class CoListSchema<T extends AnyZodOrCoValueSchema>
     items: CoListInit<T>,
     options?: { owner: Account | Group } | Account | Group,
   ): CoListInstance<T> {
-    return this.coValueClass.create(items, options) as CoListInstance<T>;
+    return this.coValueClass.create(items as any, options) as CoListInstance<T>;
   }
 
   load<const R extends RefsToResolve<CoListInstanceCoValuesNullable<T>> = true>(

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

@@ -5,7 +5,6 @@ import {
   DiscriminableCoValueSchemaDefinition,
   DiscriminableCoreCoValueSchema,
   Group,
-  PartialOnUndefined,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
@@ -17,7 +16,7 @@ import {
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { removeGetters } from "../../schemaUtils.js";
-import { CoFieldInit } from "../typeConverters/CoFieldInit.js";
+import { CoMapSchemaInit } from "../typeConverters/CoFieldInit.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 import { z } from "../zodReExport.js";
@@ -30,7 +29,7 @@ export interface CoMapSchema<
   Owner extends Account | Group = Account | Group,
 > extends CoreCoMapSchema<Shape, CatchAll> {
   create: (
-    init: Simplify<CoMapSchemaInit<Shape>>,
+    init: CoMapSchemaInit<Shape>,
     options?:
       | {
           owner: Owner;
@@ -227,13 +226,6 @@ export function enrichCoMapSchema<
   return coValueSchema;
 }
 
-// Due to a TS limitation with types that contain known properties and
-// an index signature, we cannot accept catchall properties on creation
-export type CoMapSchemaInit<Shape extends z.core.$ZodLooseShape> =
-  PartialOnUndefined<{
-    [key in keyof Shape]: CoFieldInit<Shape[key]>;
-  }>;
-
 export interface CoMapSchemaDefinition<
   Shape extends z.core.$ZodLooseShape = z.core.$ZodLooseShape,
   CatchAll extends AnyZodOrCoValueSchema | unknown = unknown,

package/src/tools/implementation/zodSchema/typeConverters/CoFieldInit.ts

@@ -1,13 +1,78 @@
-import { NotNull } from "../../../internal.js";
+import {
+  CoDiscriminatedUnionSchema,
+  CoValueClass,
+  CoreCoFeedSchema,
+  CoreCoListSchema,
+  CoreCoMapSchema,
+  CoreCoRecordSchema,
+  CorePlainTextSchema,
+  PartialOnUndefined,
+  Simplify,
+} from "../../../internal.js";
+import { CoreCoOptionalSchema } from "../schemaTypes/CoOptionalSchema.js";
+import { CoreCoValueSchema } from "../schemaTypes/CoValueSchema.js";
+import { CoreRichTextSchema } from "../schemaTypes/RichTextSchema.js";
 import { z } from "../zodReExport.js";
-import { AnyZodOrCoValueSchema } from "../zodSchema.js";
-import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "./InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
+import { AnyZodOrCoValueSchema, Loaded } from "../zodSchema.js";
+import { TypeOfZodSchema } from "./TypeOfZodSchema.js";
 
 /**
- * Returns the type of the value that should be used to initialize a coField
- * of the given schema.
+ * The type of value that can be used to initialize a CoField of the given schema.
+ *
+ * For CoValue fields, this can be either a shallowly-loaded CoValue instance
+ * or a JSON object that will be used to create the CoValue.
  */
-export type CoFieldInit<T extends AnyZodOrCoValueSchema> =
-  T extends z.core.$ZodNullable
-    ? InstanceOrPrimitiveOfSchemaCoValuesNullable<T>
-    : NotNull<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>>;
+export type CoFieldInit<S extends CoValueClass | AnyZodOrCoValueSchema> =
+  S extends CoreCoValueSchema
+    ?
+        | Loaded<S>
+        | (S extends CoreCoRecordSchema<infer K, infer V>
+            ? CoMapSchemaInit<{ [key in z.output<K> & string]: V }>
+            : S extends CoreCoMapSchema<infer Shape>
+              ? CoMapSchemaInit<Shape>
+              : S extends CoreCoListSchema<infer T>
+                ? CoListInit<T>
+                : S extends CoreCoFeedSchema<infer T>
+                  ? CoFeedInit<T>
+                  : S extends CorePlainTextSchema | CoreRichTextSchema
+                    ? string
+                    : S extends CoreCoOptionalSchema<infer T>
+                      ? CoFieldInit<T> | undefined
+                      : S extends CoDiscriminatedUnionSchema<infer Members>
+                        ? CoFieldInit<Members[number]>
+                        : never)
+    : S extends z.core.$ZodType
+      ? TypeOfZodSchema<S>
+      : S extends CoValueClass
+        ? InstanceType<S>
+        : never;
+
+// Due to a TS limitation with types that contain known properties and
+// an index signature, we cannot accept catchall properties on creation
+export type CoMapSchemaInit<Shape extends z.core.$ZodLooseShape> = Simplify<
+  {
+    /**
+     * Cannot use {@link PartialOnUndefined} because evaluating CoFieldInit<Shape[Key]>
+     * to know if the value can be undefined does not work with recursive types.
+     */
+    [Key in keyof Shape as Shape[Key] extends
+      | CoreCoOptionalSchema
+      | z.core.$ZodOptional
+      ? never
+      : Key]: CoFieldInit<Shape[Key]>;
+  } & {
+    [Key in keyof Shape as Shape[Key] extends
+      | CoreCoOptionalSchema
+      | z.core.$ZodOptional
+      ? Key
+      : never]?: CoFieldInit<Shape[Key]>;
+  }
+>;
+
+export type CoListInit<T extends AnyZodOrCoValueSchema> = Simplify<
+  ReadonlyArray<CoFieldInit<T>>
+>;
+
+export type CoFeedInit<T extends AnyZodOrCoValueSchema> = Simplify<
+  ReadonlyArray<CoFieldInit<T>>
+>;

package/src/tools/implementation/zodSchema/typeConverters/InstanceOfSchema.ts

@@ -27,15 +27,20 @@ export type InstanceOfSchema<S extends CoValueClass | AnyZodOrCoValueSchema> =
   S extends CoreCoValueSchema
     ? S extends CoreAccountSchema<infer Shape>
       ? {
-          [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
+          -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
+            Shape[key]
+          >;
         } & Account
       : S extends CoreCoRecordSchema<infer K, infer V>
         ? {
-            [key in z.output<K> & string]: InstanceOrPrimitiveOfSchema<V>;
+            -readonly [key in z.output<K> &
+              string]: InstanceOrPrimitiveOfSchema<V>;
           } & CoMap
         : S extends CoreCoMapSchema<infer Shape, infer CatchAll>
           ? {
-              [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
+              -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
+                Shape[key]
+              >;
             } & (CatchAll extends AnyZodOrCoValueSchema
               ? {
                   [key: string]: InstanceOrPrimitiveOfSchema<CatchAll>;
@@ -53,7 +58,7 @@ export type InstanceOfSchema<S extends CoValueClass | AnyZodOrCoValueSchema> =
                   : S extends CoreFileStreamSchema
                     ? FileStream
                     : S extends CoreCoOptionalSchema<infer T>
-                      ? InstanceOrPrimitiveOfSchema<T>
+                      ? InstanceOrPrimitiveOfSchema<T> | undefined
                       : S extends CoDiscriminatedUnionSchema<infer Members>
                         ? InstanceOrPrimitiveOfSchema<Members[number]>
                         : never

package/src/tools/implementation/zodSchema/typeConverters/InstanceOfSchemaCoValuesNullable.ts

@@ -29,7 +29,7 @@ export type InstanceOfSchemaCoValuesNullable<
   ? S extends CoreAccountSchema<infer Shape>
     ?
         | ({
-            [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
+            -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
               Shape[key]
             >;
           } & Account)
@@ -37,14 +37,14 @@ export type InstanceOfSchemaCoValuesNullable<
     : S extends CoreCoRecordSchema<infer K, infer V>
       ?
           | ({
-              [key in z.output<K> &
+              -readonly [key in z.output<K> &
                 string]: InstanceOrPrimitiveOfSchemaCoValuesNullable<V>;
             } & CoMap)
           | null
       : S extends CoreCoMapSchema<infer Shape, infer CatchAll>
         ?
             | ({
-                [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
+                -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
                   Shape[key]
                 >;
               } & (CatchAll extends AnyZodOrCoValueSchema

package/src/tools/implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSchema.ts

@@ -1,122 +1,11 @@
-import { JsonValue } from "cojson";
 import {
-  Account,
   AnyZodOrCoValueSchema,
-  CoDiscriminatedUnionSchema,
-  CoFeed,
-  CoList,
-  CoMap,
-  CoPlainText,
-  CoRichText,
   CoValueClass,
-  CoreAccountSchema,
-  CoreCoRecordSchema,
-  FileStream,
-  Profile,
+  InstanceOfSchema,
 } from "../../../internal.js";
-import { CoreCoFeedSchema } from "../schemaTypes/CoFeedSchema.js";
-import { CoreCoListSchema } from "../schemaTypes/CoListSchema.js";
-import { CoreCoMapSchema } from "../schemaTypes/CoMapSchema.js";
-import { CoreCoOptionalSchema } from "../schemaTypes/CoOptionalSchema.js";
-import { CoreCoValueSchema } from "../schemaTypes/CoValueSchema.js";
-import { CoreFileStreamSchema } from "../schemaTypes/FileStreamSchema.js";
-import { CorePlainTextSchema } from "../schemaTypes/PlainTextSchema.js";
-import { CoreRichTextSchema } from "../schemaTypes/RichTextSchema.js";
 import { z } from "../zodReExport.js";
+import { TypeOfZodSchema } from "./TypeOfZodSchema.js";
 
 export type InstanceOrPrimitiveOfSchema<
   S extends CoValueClass | AnyZodOrCoValueSchema,
-> = S extends CoreCoValueSchema
-  ? S extends CoreAccountSchema<infer Shape>
-    ? {
-        -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
-      } & { profile: Profile } & Account
-    : S extends CoreCoRecordSchema<infer K, infer V>
-      ? {
-          -readonly [key in z.output<K> &
-            string]: InstanceOrPrimitiveOfSchema<V>;
-        } & CoMap
-      : S extends CoreCoMapSchema<infer Shape, infer CatchAll>
-        ? {
-            -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
-              Shape[key]
-            >;
-          } & (CatchAll extends AnyZodOrCoValueSchema
-            ? {
-                [key: string]: InstanceOrPrimitiveOfSchema<CatchAll>;
-              }
-            : {}) &
-            CoMap
-        : S extends CoreCoListSchema<infer T>
-          ? CoList<InstanceOrPrimitiveOfSchema<T>>
-          : S extends CoreCoFeedSchema<infer T>
-            ? CoFeed<InstanceOrPrimitiveOfSchema<T>>
-            : S extends CorePlainTextSchema
-              ? CoPlainText
-              : S extends CoreRichTextSchema
-                ? CoRichText
-                : S extends CoreFileStreamSchema
-                  ? FileStream
-                  : S extends CoreCoOptionalSchema<infer T>
-                    ? InstanceOrPrimitiveOfSchema<T> | undefined
-                    : S extends CoDiscriminatedUnionSchema<infer Members>
-                      ? InstanceOrPrimitiveOfSchema<Members[number]>
-                      : never
-  : S extends z.core.$ZodType
-    ? S extends z.core.$ZodOptional<infer Inner extends z.core.$ZodType>
-      ? InstanceOrPrimitiveOfSchema<Inner> | undefined
-      : S extends z.core.$ZodNullable<infer Inner extends z.core.$ZodType>
-        ? InstanceOrPrimitiveOfSchema<Inner> | null
-        : S extends z.ZodJSONSchema
-          ? JsonValue
-          : S extends z.core.$ZodUnion<infer Members extends z.core.$ZodType[]>
-            ? InstanceOrPrimitiveOfSchema<Members[number]>
-            : // primitives below here - we manually traverse to ensure we only allow what we can handle
-              S extends z.core.$ZodObject<infer Shape>
-              ? {
-                  -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
-                    Shape[key]
-                  >;
-                }
-              : S extends z.core.$ZodArray<infer Item extends z.core.$ZodType>
-                ? InstanceOrPrimitiveOfSchema<Item>[]
-                : S extends z.core.$ZodTuple<
-                      infer Items extends readonly z.core.$ZodType[]
-                    >
-                  ? {
-                      [key in keyof Items]: InstanceOrPrimitiveOfSchema<
-                        Items[key]
-                      >;
-                    }
-                  : S extends z.core.$ZodString
-                    ? string
-                    : S extends z.core.$ZodNumber
-                      ? number
-                      : S extends z.core.$ZodBoolean
-                        ? boolean
-                        : S extends z.core.$ZodLiteral<infer Literal>
-                          ? Literal
-                          : S extends z.core.$ZodDate
-                            ? Date
-                            : S extends z.core.$ZodEnum<infer Enum>
-                              ? Enum[keyof Enum]
-                              : S extends z.core.$ZodTemplateLiteral<
-                                    infer pattern
-                                  >
-                                ? pattern
-                                : S extends z.core.$ZodReadonly<
-                                      infer Inner extends z.core.$ZodType
-                                    >
-                                  ? InstanceOrPrimitiveOfSchema<Inner>
-                                  : S extends z.core.$ZodDefault<
-                                        infer Default extends z.core.$ZodType
-                                      >
-                                    ? InstanceOrPrimitiveOfSchema<Default>
-                                    : S extends z.core.$ZodCatch<
-                                          infer Catch extends z.core.$ZodType
-                                        >
-                                      ? InstanceOrPrimitiveOfSchema<Catch>
-                                      : never
-    : S extends CoValueClass
-      ? InstanceType<S>
-      : never;
+> = S extends z.core.$ZodType ? TypeOfZodSchema<S> : InstanceOfSchema<S>;