jazz-tools 0.15.9 → 0.15.11

package/dist/{chunk-5PFEKHX5.js → chunk-MLLG3GBR.js}

@@ -41,16 +41,18 @@ __export(zodReExport_exports, {
   uuid: () => uuid,
   z: () => z
 });
+import {
+  array as zodArray,
+  tuple as zodTuple,
+  union as zodUnion
+} from "zod/v4";
 import {
   string,
   number,
   boolean,
-  union,
   object,
-  array,
   templateLiteral,
   json,
-  tuple,
   date,
   emoji,
   base64,
@@ -76,6 +78,15 @@ import {
   optional,
   z
 } from "zod/v4";
+function union(options, params) {
+  return zodUnion(options, params);
+}
+function array(element, params) {
+  return zodArray(element, params);
+}
+function tuple(options, params) {
+  return zodTuple(options, params);
+}
 
 // src/tools/coValues/CoValueBase.ts
 import { ControlledAccount, RawAccount } from "cojson";
@@ -124,7 +135,7 @@ var CoValueBase = class {
   }
   /** @category Type Helpers */
   castAs(schema) {
-    const cl = "getCoSchema" in schema ? schema.getCoSchema() : schema;
+    const cl = isCoValueSchema(schema) ? schema.getCoValueClass() : schema;
     if (this.constructor === cl) {
       return this;
     }
@@ -2653,6 +2664,20 @@ var SchemaUnion = class _SchemaUnion extends CoValueBase {
   static fromRaw(raw) {
     throw new Error("Not implemented");
   }
+  /**
+   * 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) {
+    return loadCoValueWithoutMe(this, id, options);
+  }
+  static subscribe(id, ...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToCoValueWithoutMe(this, id, options, listener);
+  }
 };
 
 // src/tools/implementation/anonymousJazzAgent.ts
@@ -2911,13 +2936,13 @@ var CoValueCoreSubscription = class {
   }
   subscribeToState() {
     const entry = this.node.getCoValue(this.id);
-    const handleStateChange = (core, unsubFromStateChange2) => {
+    const handleStateChange = (core2, unsubFromStateChange2) => {
       if (this.unsubscribed) {
         unsubFromStateChange2();
         return;
       }
-      if (core.isAvailable()) {
-        this.subscribe(core.getCurrentContent());
+      if (core2.isAvailable()) {
+        this.subscribe(core2.getCurrentContent());
         unsubFromStateChange2();
       }
     };
@@ -3098,7 +3123,7 @@ var SubscriptionScope = class _SubscriptionScope {
           new JazzError(this.id, "unauthorized", [
             {
               code: "unauthorized",
-              message: "The current user is not authorized to access this value",
+              message: `The current user (${this.node.getCurrentAgent().id}) is not authorized to access this value`,
               params: {
                 id: this.id
               },
@@ -3682,265 +3707,23 @@ function getDef(schema) {
   return schema.def;
 }
 
-// src/tools/implementation/zodSchema/zodCo.ts
-function enrichCoMapSchema(schema) {
-  const baseCatchall = schema.catchall;
-  const enrichedSchema = Object.assign(schema, {
-    collaborative: true,
-    create: (...args) => {
-      return coSchema.create(...args);
-    },
-    load: (...args) => {
-      return coSchema.load(...args);
-    },
-    subscribe: (...args) => {
-      return coSchema.subscribe(...args);
-    },
-    findUnique: (...args) => {
-      return coSchema.findUnique(...args);
-    },
-    upsertUnique: (...args) => {
-      return coSchema.upsertUnique(...args);
-    },
-    loadUnique: (...args) => {
-      return coSchema.loadUnique(...args);
-    },
-    catchall: (index) => {
-      return enrichCoMapSchema(baseCatchall(index));
-    },
-    withHelpers: (helpers) => {
-      return Object.assign(schema, helpers(schema));
-    },
-    withMigration: (migration) => {
-      coSchema.prototype.migrate = migration;
-      return enrichedSchema;
-    },
-    getCoSchema: () => {
-      return coSchema;
-    }
-  });
-  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
-  return enrichedSchema;
-}
-var coMapDefiner = (shape) => {
-  const objectSchema = z.object(shape).meta({
-    collaborative: true
-  });
-  return enrichCoMapSchema(objectSchema);
-};
-function enrichAccountSchema(schema) {
-  const enrichedSchema = Object.assign(schema, {
-    collaborative: true,
-    builtin: "Account",
-    create: (...args) => {
-      return coSchema.create(...args);
-    },
-    createAs: (...args) => {
-      return coSchema.createAs(...args);
-    },
-    getMe: (...args) => {
-      return coSchema.getMe(...args);
-    },
-    load: (...args) => {
-      return coSchema.load(...args);
-    },
-    subscribe: (...args) => {
-      return coSchema.subscribe(...args);
-    },
-    withHelpers: (helpers) => {
-      return Object.assign(schema, helpers(schema));
-    },
-    fromRaw: (...args) => {
-      return coSchema.fromRaw(...args);
-    },
-    withMigration: (migration) => {
-      coSchema.prototype.migrate = async function(creationProps) {
-        await migration(this, creationProps);
-      };
-      return enrichedSchema;
-    },
-    getCoSchema: () => {
-      return coSchema;
-    }
-  });
-  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
-  return enrichedSchema;
-}
-var coAccountDefiner = (shape = {
-  profile: coMapDefiner({
-    name: z.string(),
-    inbox: z.optional(z.string()),
-    inboxInvite: z.optional(z.string())
-  }),
-  root: coMapDefiner({})
-}) => {
-  const objectSchema = z.object(shape).meta({
-    collaborative: true
-  });
-  return enrichAccountSchema(objectSchema);
-};
-var coRecordDefiner = (_keyType, valueType) => {
-  return coMapDefiner({}).catchall(valueType);
-};
-function enrichCoListSchema(schema) {
-  const enrichedSchema = Object.assign(schema, {
-    collaborative: true,
-    create: (...args) => {
-      return coSchema.create(...args);
-    },
-    load: (...args) => {
-      return coSchema.load(...args);
-    },
-    subscribe: (...args) => {
-      return coSchema.subscribe(...args);
-    },
-    withHelpers: (helpers) => {
-      return Object.assign(schema, helpers(schema));
-    },
-    getCoSchema: () => {
-      return coSchema;
-    }
-  });
-  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
-  return enrichedSchema;
-}
-var coListDefiner = (element) => {
-  const arraySchema = z.array(element).meta({
-    collaborative: true
-  });
-  return enrichCoListSchema(arraySchema);
-};
-var coProfileDefiner = (shape = {}) => {
-  const ehnancedShape = Object.assign(shape ?? {}, {
-    name: z.string(),
-    inbox: z.optional(z.string()),
-    inboxInvite: z.optional(z.string())
-  });
-  return coMapDefiner(ehnancedShape);
-};
-function enrichCoFeedSchema(schema, element) {
-  const enrichedSchema = Object.assign(schema, {
-    collaborative: true,
-    builtin: "CoFeed",
-    element,
-    create: (...args) => {
-      return coSchema.create(...args);
-    },
-    load: (...args) => {
-      return coSchema.load(...args);
-    },
-    subscribe: (...args) => {
-      return coSchema.subscribe(...args);
-    },
-    withHelpers: (helpers) => {
-      return Object.assign(schema, helpers(schema));
-    },
-    getCoSchema: () => {
-      return coSchema;
-    }
-  });
-  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
-  return enrichedSchema;
-}
-var coFeedDefiner = (element) => {
-  return enrichCoFeedSchema(z.instanceof(CoFeed), element);
-};
-function enrichFileStreamSchema(schema) {
-  const enrichedSchema = Object.assign(schema, {
-    collaborative: true,
-    builtin: "FileStream",
-    create: (...args) => {
-      return coSchema.create(...args);
-    },
-    createFromBlob: (...args) => {
-      return coSchema.createFromBlob(...args);
-    },
-    load: (...args) => {
-      return coSchema.load(...args);
-    },
-    loadAsBlob: (...args) => {
-      return coSchema.loadAsBlob(...args);
-    },
-    subscribe: (...args) => {
-      return coSchema.subscribe(...args);
-    },
-    getCoSchema: () => {
-      return coSchema;
-    }
-  });
-  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
-  return enrichedSchema;
-}
-var coFileStreamDefiner = () => {
-  return enrichFileStreamSchema(z.instanceof(FileStream));
-};
-function enrichPlainTextSchema(schema) {
-  const enrichedSchema = Object.assign(schema, {
-    collaborative: true,
-    builtin: "CoPlainText",
+// src/tools/implementation/zodSchema/schemaTypes/RichTextSchema.ts
+function enrichRichTextSchema(schema, coValueClass) {
+  return Object.assign(schema, {
     create: (...args) => {
-      return coSchema.create(...args);
+      return coValueClass.create(...args);
     },
     load: (...args) => {
-      return coSchema.load(...args);
+      return coValueClass.load(...args);
     },
     subscribe: (...args) => {
-      return coSchema.subscribe(...args);
-    },
-    fromRaw: (...args) => {
-      return coSchema.fromRaw(...args);
+      return coValueClass.subscribe(...args);
     },
-    getCoSchema: () => {
-      return coSchema;
+    getCoValueClass: () => {
+      return coValueClass;
     }
   });
-  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
-  return enrichedSchema;
 }
-var coPlainTextDefiner = () => {
-  return enrichPlainTextSchema(z.instanceof(CoPlainText));
-};
-function enrichRichTextSchema(schema) {
-  const enrichedSchema = Object.assign(schema, {
-    collaborative: true,
-    builtin: "CoRichText",
-    create: (...args) => {
-      return coSchema.create(...args);
-    },
-    load: (...args) => {
-      return coSchema.load(...args);
-    },
-    subscribe: (...args) => {
-      return coSchema.subscribe(...args);
-    },
-    getCoSchema: () => {
-      return coSchema;
-    }
-  });
-  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
-  return enrichedSchema;
-}
-var coRichTextDefiner = () => {
-  return enrichRichTextSchema(z.instanceof(CoRichText));
-};
-var coImageDefiner = () => {
-  return ImageDefinition;
-};
-
-// src/tools/implementation/zodSchema/coExport.ts
-var coExport_exports = {};
-__export(coExport_exports, {
-  account: () => coAccountDefiner,
-  feed: () => coFeedDefiner,
-  fileStream: () => coFileStreamDefiner,
-  image: () => coImageDefiner,
-  list: () => coListDefiner,
-  map: () => coMapDefiner,
-  plainText: () => coPlainTextDefiner,
-  profile: () => coProfileDefiner,
-  record: () => coRecordDefiner,
-  richText: () => coRichTextDefiner
-});
 
 // src/tools/implementation/zodSchema/unionUtils.ts
 import { RawCoList } from "cojson";
@@ -3948,20 +3731,20 @@ function schemaUnionDiscriminatorFor(schema) {
   if (isUnionOfCoMapsDeeply(schema)) {
     if (!schema._zod.disc || schema._zod.disc.size == 0) {
       throw new Error(
-        "z.union() of collaborative types is not supported, use z.discriminatedUnion() instead"
+        "z.union() of collaborative types is not supported, use co.discriminatedUnion() instead"
       );
     }
     const discriminator = schema._zod.def.discriminator;
     const field = schema._zod.disc.get(discriminator);
     if (!field) {
       throw new Error(
-        "z.discriminatedUnion() of collaborative types with non-existent discriminator key is not supported"
+        "co.discriminatedUnion() of collaborative types with non-existent discriminator key is not supported"
       );
     }
     for (const value of field.values) {
       if (typeof value !== "string" && typeof value !== "number") {
         throw new Error(
-          "z.discriminatedUnion() of collaborative types with non-string or non-number discriminator value is not supported"
+          "co.discriminatedUnion() of collaborative types with non-string or non-number discriminator value is not supported"
         );
       }
     }
@@ -3977,14 +3760,14 @@ function schemaUnionDiscriminatorFor(schema) {
         }
       } else {
         throw new Error(
-          "Unsupported zod type in z.discriminatedUnion() of collaborative types"
+          "Unsupported zod type in co.discriminatedUnion() of collaborative types"
         );
       }
     }
     const determineSchema = (_raw) => {
       if (_raw instanceof RawCoList) {
         throw new Error(
-          "z.discriminatedUnion() of collaborative types is not supported for CoLists"
+          "co.discriminatedUnion() of collaborative types is not supported for CoLists"
         );
       }
       for (const option of availableOptions) {
@@ -4013,11 +3796,12 @@ function schemaUnionDiscriminatorFor(schema) {
           }
         }
         if (match) {
-          return zodSchemaToCoSchema2(option);
+          const coValueSchema = zodSchemaToCoSchema(option);
+          return coValueSchema.getCoValueClass();
         }
       }
       throw new Error(
-        "z.discriminatedUnion() of collaborative types with no matching discriminator value found"
+        "co.discriminatedUnion() of collaborative types with no matching discriminator value found"
       );
     };
     return determineSchema;
@@ -4035,7 +3819,7 @@ function isUnionOfCoMapsDeeply(schema) {
   }
 }
 function isCoMapOrUnionOfCoMapsDeeply(schema) {
-  if (schema instanceof z.core.$ZodObject && "collaborative" in schema && schema.collaborative) {
+  if (schema instanceof z.core.$ZodObject && isAnyCoValueSchema(schema)) {
     return true;
   } else if (schema instanceof z.core.$ZodUnion) {
     return schema._zod.def.options.every(isCoMapOrUnionOfCoMapsDeeply);
@@ -4047,14 +3831,21 @@ function isUnionOfPrimitivesDeeply(schema) {
   if (schema instanceof z.core.$ZodUnion) {
     return schema._zod.def.options.every(isUnionOfPrimitivesDeeply);
   } else {
-    return !("collaborative" in schema);
+    return !isAnyCoValueSchema(schema);
   }
 }
 
 // src/tools/implementation/zodSchema/runtimeConverters/zodFieldToCoFieldDef.ts
-function zodFieldToCoFieldDef(schema) {
+function schemaFieldToCoFieldDef(schema) {
   if (isCoValueClass(schema)) {
     return coField.ref(schema);
+  } else if (isCoValueSchema(schema)) {
+    if (isAnyCoOptionalSchema(schema)) {
+      return coField.ref(schema.getCoValueClass(), {
+        optional: true
+      });
+    }
+    return coField.ref(schema.getCoValueClass());
   } else {
     if ("_zod" in schema) {
       if (schema._zod.def.type === "optional") {
@@ -4064,7 +3855,7 @@ function zodFieldToCoFieldDef(schema) {
         if (isCoValueClass(inner)) {
           return coField.ref(inner, { optional: true });
         } else {
-          return zodFieldToCoFieldDef(inner);
+          return schemaFieldToCoFieldDef(inner);
         }
       } else if (schema._zod.def.type === "string") {
         return coField.string;
@@ -4077,7 +3868,7 @@ function zodFieldToCoFieldDef(schema) {
       } else if (schema._zod.def.type === "enum") {
         return coField.string;
       } else if (schema._zod.def.type === "readonly") {
-        return zodFieldToCoFieldDef(
+        return schemaFieldToCoFieldDef(
           schema.def.innerType
         );
       } else if (schema._zod.def.type === "date") {
@@ -4085,14 +3876,14 @@ function zodFieldToCoFieldDef(schema) {
       } else if (schema._zod.def.type === "template_literal") {
         return coField.string;
       } else if (schema._zod.def.type === "lazy") {
-        return zodFieldToCoFieldDef(
+        return schemaFieldToCoFieldDef(
           schema.unwrap()
         );
       } else if (schema._zod.def.type === "default" || schema._zod.def.type === "catch") {
         console.warn(
           "z.default()/z.catch() are not supported in collaborative schemas. They will be ignored."
         );
-        return zodFieldToCoFieldDef(
+        return schemaFieldToCoFieldDef(
           schema.def.innerType
         );
       } else if (schema._zod.def.type === "literal") {
@@ -4114,7 +3905,7 @@ function zodFieldToCoFieldDef(schema) {
         return coField.json();
       } else if (schema._zod.def.type === "custom") {
         if ("builtin" in schema) {
-          return zodFieldToCoFieldDef(schema.builtin);
+          return schemaFieldToCoFieldDef(schema.builtin);
         } else {
           throw new Error(`Unsupported custom zod type`);
         }
@@ -4143,61 +3934,81 @@ function zodFieldToCoFieldDef(schema) {
 
 // src/tools/implementation/zodSchema/runtimeConverters/zodSchemaToCoSchema.ts
 var coSchemasForZodSchemas = /* @__PURE__ */ new Map();
+function isAnyCoValueSchema(schema) {
+  return "collaborative" in schema && schema.collaborative === true;
+}
+function isCoValueSchema(schema) {
+  return isAnyCoValueSchema(schema) && "getCoValueClass" in schema;
+}
 function tryZodSchemaToCoSchema(schema) {
-  if ("collaborative" in schema && schema.collaborative) {
+  if (isAnyCoValueSchema(schema)) {
     if (coSchemasForZodSchemas.has(schema)) {
-      return coSchemasForZodSchemas.get(schema);
+      return coSchemasForZodSchemas.get(
+        schema
+      );
     }
-    if (isZodObject(schema)) {
+    if (isAnyCoOptionalSchema(schema)) {
+      return null;
+    } else if (isZodObject(schema)) {
       const def = getDef(schema);
       const ClassToExtend = "builtin" in schema && schema.builtin === "Account" ? Account : CoMap;
-      const coSchema = class ZCoMap extends ClassToExtend {
+      const coValueClass = class ZCoMap extends ClassToExtend {
         constructor(options) {
           super(options);
           for (const [field, fieldType] of Object.entries(
             def.shape
           )) {
-            this[field] = zodFieldToCoFieldDef(
+            this[field] = schemaFieldToCoFieldDef(
               zodSchemaToCoSchemaOrKeepPrimitive(fieldType)
             );
           }
           if (def.catchall) {
-            this[coField.items] = zodFieldToCoFieldDef(
+            this[coField.items] = schemaFieldToCoFieldDef(
               zodSchemaToCoSchemaOrKeepPrimitive(def.catchall)
             );
           }
         }
       };
-      coSchemasForZodSchemas.set(schema, coSchema);
-      return coSchema;
+      const coValueSchema = ClassToExtend === Account ? enrichAccountSchema(schema, coValueClass) : enrichCoMapSchema(schema, coValueClass);
+      coSchemasForZodSchemas.set(schema, coValueSchema);
+      return coValueSchema;
     } else if (isZodArray(schema)) {
       const def = getDef(schema);
-      const coSchema = class ZCoList extends CoList {
+      const coValueClass = class ZCoList extends CoList {
         constructor(options) {
           super(options);
-          this[coField.items] = zodFieldToCoFieldDef(
+          this[coField.items] = schemaFieldToCoFieldDef(
             zodSchemaToCoSchemaOrKeepPrimitive(def.element)
           );
         }
       };
-      coSchemasForZodSchemas.set(schema, coSchema);
-      return coSchema;
+      const coValueSchema = enrichCoListSchema(schema, coValueClass);
+      coSchemasForZodSchemas.set(schema, coValueSchema);
+      return coValueSchema;
     } else if (isZodCustom(schema)) {
       if ("builtin" in schema) {
         if (schema.builtin === "CoFeed" && "element" in schema) {
-          return CoFeed.Of(
-            zodFieldToCoFieldDef(
+          const coValueClass = CoFeed.Of(
+            schemaFieldToCoFieldDef(
               zodSchemaToCoSchemaOrKeepPrimitive(
                 schema.element
               )
             )
           );
+          const coValueSchema = enrichCoFeedSchema(schema, coValueClass);
+          return coValueSchema;
         } else if (schema.builtin === "FileStream") {
-          return FileStream;
+          const coValueClass = FileStream;
+          const coValueSchema = enrichFileStreamSchema(schema, coValueClass);
+          return coValueSchema;
         } else if (schema.builtin === "CoPlainText") {
-          return CoPlainText;
+          const coValueClass = CoPlainText;
+          const coValueSchema = enrichPlainTextSchema(schema, coValueClass);
+          return coValueSchema;
         } else if (schema.builtin === "CoRichText") {
-          return CoRichText;
+          const coValueClass = CoRichText;
+          const coValueSchema = enrichRichTextSchema(schema, coValueClass);
+          return coValueSchema;
         } else {
           throw new Error(`Unsupported builtin type: ${schema.builtin}`);
         }
@@ -4211,9 +4022,12 @@ function tryZodSchemaToCoSchema(schema) {
     }
   } else if (schema instanceof z.core.$ZodDiscriminatedUnion) {
     if (isUnionOfCoMapsDeeply(schema)) {
-      return SchemaUnion.Of(
-        schemaUnionDiscriminatorFor(schema)
+      const coValueClass = SchemaUnion.Of(schemaUnionDiscriminatorFor(schema));
+      const coValueSchema = enrichCoDiscriminatedUnionSchema(
+        schema,
+        coValueClass
       );
+      return coValueSchema;
     } else {
       throw new Error(
         "z.discriminatedUnion() of non-collaborative types is not supported as a top-level schema"
@@ -4223,7 +4037,7 @@ function tryZodSchemaToCoSchema(schema) {
     return null;
   }
 }
-function zodSchemaToCoSchema2(schema) {
+function zodSchemaToCoSchema(schema) {
   const coSchema = tryZodSchemaToCoSchema(schema);
   if (!coSchema) {
     throw new Error(
@@ -4235,16 +4049,18 @@ function zodSchemaToCoSchema2(schema) {
 function anySchemaToCoSchema(schema) {
   if (isCoValueClass(schema)) {
     return schema;
-  } else if ("getCoSchema" in schema) {
-    return schema.getCoSchema();
+  } else if (isCoValueSchema(schema)) {
+    return schema.getCoValueClass();
   } else if ("def" in schema) {
-    const coSchema = tryZodSchemaToCoSchema(schema);
+    const coSchema = tryZodSchemaToCoSchema(
+      schema
+    );
     if (!coSchema) {
       throw new Error(
         `Unsupported zod type: ${schema.def?.type || JSON.stringify(schema)}`
       );
     }
-    return coSchema;
+    return coSchema.getCoValueClass();
   }
   throw new Error(`Unsupported schema: ${JSON.stringify(schema)}`);
 }
@@ -4256,6 +4072,309 @@ function zodSchemaToCoSchemaOrKeepPrimitive(schema) {
   return coSchema;
 }
 
+// src/tools/implementation/zodSchema/schemaTypes/CoOptionalSchema.ts
+function createCoOptionalSchema(schema) {
+  return Object.assign(z.optional(schema), {
+    collaborative: true,
+    getCoValueClass: () => {
+      return schema.getCoValueClass();
+    }
+  });
+}
+function isAnyCoOptionalSchema(schema) {
+  return isAnyCoValueSchema(schema) && schema._zod.def.type === "optional";
+}
+
+// src/tools/implementation/zodSchema/zodCo.ts
+var coMapDefiner = (shape) => {
+  const objectSchema = z.object(shape).meta({
+    collaborative: true
+  });
+  const enrichedSchema = Object.assign(objectSchema, {
+    collaborative: true
+  });
+  return zodSchemaToCoSchema(enrichedSchema);
+};
+var coAccountDefiner = (shape = {
+  profile: coMapDefiner({
+    name: z.string(),
+    inbox: z.optional(z.string()),
+    inboxInvite: z.optional(z.string())
+  }),
+  root: coMapDefiner({})
+}) => {
+  const schema = z.object(shape).meta({
+    collaborative: true
+  });
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "Account"
+  });
+  return zodSchemaToCoSchema(enrichedSchema);
+};
+var coRecordDefiner = (_keyType, valueType) => {
+  return coMapDefiner({}).catchall(valueType);
+};
+var coListDefiner = (element) => {
+  const schema = z.array(element).meta({
+    collaborative: true
+  });
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true
+  });
+  return zodSchemaToCoSchema(enrichedSchema);
+};
+var coProfileDefiner = (shape = {}) => {
+  const ehnancedShape = Object.assign(shape, {
+    name: z.string(),
+    inbox: z.optional(z.string()),
+    inboxInvite: z.optional(z.string())
+  });
+  return coMapDefiner(ehnancedShape);
+};
+var coFeedDefiner = (element) => {
+  const schema = z.instanceof(CoFeed);
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "CoFeed",
+    element
+  });
+  return zodSchemaToCoSchema(enrichedSchema);
+};
+var coFileStreamDefiner = () => {
+  const schema = z.instanceof(FileStream);
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "FileStream"
+  });
+  return zodSchemaToCoSchema(enrichedSchema);
+};
+var coPlainTextDefiner = () => {
+  const schema = z.instanceof(CoPlainText);
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "CoPlainText"
+  });
+  return zodSchemaToCoSchema(enrichedSchema);
+};
+var coRichTextDefiner = () => {
+  const schema = z.instanceof(CoRichText);
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "CoRichText"
+  });
+  return zodSchemaToCoSchema(enrichedSchema);
+};
+var coImageDefiner = () => {
+  return ImageDefinition;
+};
+var coOptionalDefiner = (schema) => {
+  return createCoOptionalSchema(schema);
+};
+var coDiscriminatedUnionDefiner = (discriminator, schemas) => {
+  const schema = z.discriminatedUnion(discriminator, schemas);
+  return zodSchemaToCoSchema(schema);
+};
+
+// src/tools/implementation/zodSchema/coExport.ts
+var coExport_exports = {};
+__export(coExport_exports, {
+  account: () => coAccountDefiner,
+  discriminatedUnion: () => coDiscriminatedUnionDefiner,
+  feed: () => coFeedDefiner,
+  fileStream: () => coFileStreamDefiner,
+  image: () => coImageDefiner,
+  list: () => coListDefiner,
+  map: () => coMapDefiner,
+  optional: () => coOptionalDefiner,
+  plainText: () => coPlainTextDefiner,
+  profile: () => coProfileDefiner,
+  record: () => coRecordDefiner,
+  richText: () => coRichTextDefiner
+});
+
+// src/tools/implementation/zodSchema/schemaTypes/CoMapSchema.ts
+function enrichCoMapSchema(schema, coValueClass) {
+  const baseCatchall = schema.catchall;
+  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);
+    },
+    catchall: (index) => {
+      const newSchema = baseCatchall(index);
+      const enrichedSchema = Object.assign(newSchema, {
+        collaborative: true
+      });
+      return zodSchemaToCoSchema(enrichedSchema);
+    },
+    withHelpers: (helpers) => {
+      return Object.assign(schema, helpers(schema));
+    },
+    withMigration: (migration) => {
+      coValueClass.prototype.migrate = migration;
+      return coValueSchema;
+    },
+    getCoValueClass: () => {
+      return coValueClass;
+    }
+  });
+  return coValueSchema;
+}
+
+// src/tools/implementation/zodSchema/schemaTypes/CoDiscriminatedUnionSchema.ts
+function enrichCoDiscriminatedUnionSchema(schema, coValueClass) {
+  return Object.assign(schema, {
+    load: (...args) => {
+      return coValueClass.load(...args);
+    },
+    subscribe: (...args) => {
+      return coValueClass.subscribe(...args);
+    },
+    getCoValueClass: () => {
+      return coValueClass;
+    }
+  });
+}
+
+// src/tools/implementation/zodSchema/schemaTypes/CoListSchema.ts
+function enrichCoListSchema(schema, coValueClass) {
+  return Object.assign(schema, {
+    create: (...args) => {
+      return coValueClass.create(...args);
+    },
+    load: (...args) => {
+      return coValueClass.load(...args);
+    },
+    subscribe: (...args) => {
+      return coValueClass.subscribe(...args);
+    },
+    withHelpers: (helpers) => {
+      return Object.assign(schema, helpers(schema));
+    },
+    getCoValueClass: () => {
+      return coValueClass;
+    }
+  });
+}
+
+// src/tools/implementation/zodSchema/schemaTypes/CoFeedSchema.ts
+function enrichCoFeedSchema(schema, coValueClass) {
+  return Object.assign(schema, {
+    create: (...args) => {
+      return coValueClass.create(...args);
+    },
+    load: (...args) => {
+      return coValueClass.load(...args);
+    },
+    subscribe: (...args) => {
+      return coValueClass.subscribe(...args);
+    },
+    withHelpers: (helpers) => {
+      return Object.assign(schema, helpers(schema));
+    },
+    getCoValueClass: () => {
+      return coValueClass;
+    }
+  });
+}
+
+// src/tools/implementation/zodSchema/schemaTypes/AccountSchema.ts
+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);
+    },
+    withHelpers: (helpers) => {
+      return Object.assign(schema, helpers(schema));
+    },
+    fromRaw: (...args) => {
+      return coValueClass.fromRaw(...args);
+    },
+    withMigration: (migration) => {
+      coValueClass.prototype.migrate = async function(creationProps) {
+        await migration(this, creationProps);
+      };
+      return enrichedSchema;
+    },
+    getCoValueClass: () => {
+      return coValueClass;
+    }
+  });
+  return enrichedSchema;
+}
+
+// src/tools/implementation/zodSchema/schemaTypes/FileStreamSchema.ts
+function enrichFileStreamSchema(schema, coValueClass) {
+  return Object.assign(schema, {
+    create: (...args) => {
+      return coValueClass.create(...args);
+    },
+    createFromBlob: (...args) => {
+      return coValueClass.createFromBlob(...args);
+    },
+    load: (...args) => {
+      return coValueClass.load(...args);
+    },
+    loadAsBlob: (...args) => {
+      return coValueClass.loadAsBlob(...args);
+    },
+    subscribe: (...args) => {
+      return coValueClass.subscribe(...args);
+    },
+    getCoValueClass: () => {
+      return coValueClass;
+    }
+  });
+}
+
+// src/tools/implementation/zodSchema/schemaTypes/PlainTextSchema.ts
+function enrichPlainTextSchema(schema, coValueClass) {
+  return Object.assign(schema, {
+    create: (...args) => {
+      return coValueClass.create(...args);
+    },
+    load: (...args) => {
+      return coValueClass.load(...args);
+    },
+    subscribe: (...args) => {
+      return coValueClass.subscribe(...args);
+    },
+    fromRaw: (...args) => {
+      return coValueClass.fromRaw(...args);
+    },
+    getCoValueClass: () => {
+      return coValueClass;
+    }
+  });
+}
+
 // src/tools/coValues/extensions/imageDef.ts
 var ImageDefinitionBase = coMapDefiner({
   originalSize: z.tuple([z.number(), z.number()]),
@@ -4921,9 +5040,9 @@ function isAccountInstance(instance) {
   return "_type" in instance && instance._type === "Account";
 }
 function parseCoValueCreateOptions(options) {
-  const Group3 = RegisteredSchemas["Group"];
+  const Group4 = RegisteredSchemas["Group"];
   if (!options) {
-    return { owner: Group3.create(), uniqueness: void 0 };
+    return { owner: Group4.create(), uniqueness: void 0 };
   }
   if ("_type" in options) {
     if (options._type === "Account" || options._type === "Group") {
@@ -4932,7 +5051,7 @@ function parseCoValueCreateOptions(options) {
   }
   const uniqueness = options.unique ? { uniqueness: options.unique } : void 0;
   return {
-    owner: options.owner ?? Group3.create(),
+    owner: options.owner ?? Group4.create(),
     uniqueness
   };
 }
@@ -4972,9 +5091,9 @@ export {
   createJazzContextForNewAccount,
   createJazzContext,
   createAnonymousJazzContext,
-  coExport_exports,
-  zodSchemaToCoSchema2 as zodSchemaToCoSchema,
+  zodSchemaToCoSchema,
   anySchemaToCoSchema,
+  coExport_exports,
   ImageDefinition,
   KvStoreContext,
   AuthSecretStorage,
@@ -4982,4 +5101,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-5PFEKHX5.js.map
+//# sourceMappingURL=chunk-MLLG3GBR.js.map