jazz-tools 0.15.16 → 0.16.1

package/dist/{chunk-OSVAAVWQ.js → chunk-CL3ROOZM.js}

@@ -42,15 +42,27 @@ __export(zodReExport_exports, {
   z: () => z
 });
 import {
-  array as zodArray,
-  tuple as zodTuple,
-  union as zodUnion
+  object as zodObject,
+  strictObject as zodStrictObject
 } from "zod/v4";
+
+// src/tools/implementation/schemaUtils.ts
+function removeGetters(obj) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+    if (!descriptor?.get) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+
+// src/tools/implementation/zodSchema/zodReExport.ts
 import {
   string,
   number,
   boolean,
-  object,
   templateLiteral,
   json,
   date,
@@ -72,20 +84,38 @@ import {
   cidrv6,
   iso,
   int32,
-  strictObject,
+  union,
   discriminatedUnion,
   int,
   optional,
+  array,
+  tuple,
   z
 } from "zod/v4";
-function union(options, params) {
-  return zodUnion(options, params);
+function object(shape, params) {
+  rejectCoValueSchemas(
+    shape,
+    "z.object() does not support collaborative types as values. Use co.map() instead"
+  );
+  return zodObject(shape, params);
+}
+function strictObject(shape, params) {
+  rejectCoValueSchemas(
+    shape,
+    "z.strictObject() does not support collaborative types as values. Use co.map() instead"
+  );
+  return zodStrictObject(shape, params);
+}
+function rejectCoValueSchemas(shape, errorMessage) {
+  if (containsCoValueSchema(shape)) {
+    throw Error(errorMessage);
+  }
 }
-function array(element, params) {
-  return zodArray(element, params);
+function containsCoValueSchema(shape) {
+  return Object.values(removeGetters(shape ?? {})).some(isAnyCoValueSchema);
 }
-function tuple(options, params) {
-  return zodTuple(options, params);
+function isAnyCoValueSchema(schema) {
+  return "collaborative" in schema && schema.collaborative === true;
 }
 
 // src/tools/coValues/interfaces.ts
@@ -109,9 +139,9 @@ var CoValueBase = class {
     if (agent instanceof ControlledAccount) {
       return coValuesCache.get(
         agent.account,
-        () => anySchemaToCoSchema(RegisteredSchemas["Account"]).fromRaw(
-          agent.account
-        )
+        () => coValueClassFromCoValueClassOrSchema(
+          RegisteredSchemas["Account"]
+        ).fromRaw(agent.account)
       );
     }
     return new AnonymousJazzAgent(this._raw.core.node);
@@ -723,9 +753,9 @@ var _CoList = class _CoList extends Array {
   }
   /** @category Collaboration */
   get _owner() {
-    return this._raw.group instanceof RawAccount2 ? anySchemaToCoSchema(RegisteredSchemas["Account"]).fromRaw(
-      this._raw.group
-    ) : RegisteredSchemas["Group"].fromRaw(this._raw.group);
+    return this._raw.group instanceof RawAccount2 ? coValueClassFromCoValueClassOrSchema(
+      RegisteredSchemas["Account"]
+    ).fromRaw(this._raw.group) : RegisteredSchemas["Group"].fromRaw(this._raw.group);
   }
   /**
    * If a `CoList`'s items are a `coField.ref(...)`, you can use `coList._refs[i]` to access
@@ -761,9 +791,9 @@ var _CoList = class _CoList extends Array {
     if (agent instanceof ControlledAccount2) {
       return coValuesCache.get(
         agent.account,
-        () => anySchemaToCoSchema(RegisteredSchemas["Account"]).fromRaw(
-          agent.account
-        )
+        () => coValueClassFromCoValueClassOrSchema(
+          RegisteredSchemas["Account"]
+        ).fromRaw(agent.account)
       );
     }
     return new AnonymousJazzAgent(this._raw.core.node);
@@ -1776,9 +1806,13 @@ var _Account = class _Account extends CoValueBase {
       valueID,
       inviteSecret
     );
-    return loadCoValue(anySchemaToCoSchema(coValueClass), valueID, {
-      loadAs: this
-    });
+    return loadCoValue(
+      coValueClassFromCoValueClassOrSchema(coValueClass),
+      valueID,
+      {
+        loadAs: this
+      }
+    );
   }
   /** @private */
   static async create(options) {
@@ -1926,7 +1960,11 @@ var AccountAndGroupProxyHandler = {
       return true;
     } else if (key === "root") {
       if (value) {
-        target._raw.set("root", value.id);
+        target._raw.set(
+          "root",
+          value.id,
+          "trusting"
+        );
       }
       return true;
     } else {
@@ -2273,7 +2311,7 @@ var Inbox = class _Inbox {
                 );
               }
               return loadCoValue(
-                anySchemaToCoSchema(Schema),
+                coValueClassFromCoValueClassOrSchema(Schema),
                 message.get("payload"),
                 {
                   loadAs: account
@@ -2465,9 +2503,9 @@ var CoPlainText = class extends String {
     if (agent instanceof ControlledAccount4) {
       return coValuesCache.get(
         agent.account,
-        () => anySchemaToCoSchema(RegisteredSchemas["Account"]).fromRaw(
-          agent.account
-        )
+        () => coValueClassFromCoValueClassOrSchema(
+          RegisteredSchemas["Account"]
+        ).fromRaw(agent.account)
       );
     }
     return new AnonymousJazzAgent(this._raw.core.node);
@@ -3019,7 +3057,9 @@ function getOwnerFromRawValue(raw) {
   const owner = raw.group;
   return coValuesCache.get(
     owner,
-    () => owner instanceof RawAccount6 ? anySchemaToCoSchema(RegisteredSchemas["Account"]).fromRaw(owner) : RegisteredSchemas["Group"].fromRaw(owner)
+    () => owner instanceof RawAccount6 ? coValueClassFromCoValueClassOrSchema(
+      RegisteredSchemas["Account"]
+    ).fromRaw(owner) : RegisteredSchemas["Group"].fromRaw(owner)
   );
 }
 function createCoValue(ref2, raw, subscriptionScope) {
@@ -3569,7 +3609,7 @@ async function createJazzContextFromExistingCredentials({
     crypto
   );
   const CurrentAccountSchema = PropsAccountSchema ?? RegisteredSchemas["Account"];
-  const AccountClass = anySchemaToCoSchema(CurrentAccountSchema);
+  const AccountClass = coValueClassFromCoValueClassOrSchema(CurrentAccountSchema);
   const node = await LocalNode2.withLoadedAccount({
     accountID: credentials.accountID,
     accountSecret: credentials.secret,
@@ -3609,7 +3649,7 @@ async function createJazzContextForNewAccount({
   storage
 }) {
   const CurrentAccountSchema = PropsAccountSchema ?? RegisteredSchemas["Account"];
-  const AccountClass = anySchemaToCoSchema(CurrentAccountSchema);
+  const AccountClass = coValueClassFromCoValueClassOrSchema(CurrentAccountSchema);
   const { node } = await LocalNode2.withNewlyCreatedAccount({
     creationProps,
     peersToLoadFrom,
@@ -3715,55 +3755,445 @@ function createAnonymousJazzContext({
   };
 }
 
-// src/tools/implementation/zodSchema/zodSchema.ts
-function isZodObject(schema) {
-  return schema.def?.type === "object";
+// src/tools/implementation/zodSchema/schemaTypes/CoDiscriminatedUnionSchema.ts
+var CoDiscriminatedUnionSchema = class {
+  constructor(coreSchema, coValueClass) {
+    this.coValueClass = coValueClass;
+    this.collaborative = true;
+    this.builtin = "CoDiscriminatedUnion";
+    this.getDefinition = coreSchema.getDefinition;
+  }
+  load(id, options) {
+    return this.coValueClass.load(id, options);
+  }
+  subscribe(id, options, listener) {
+    return this.coValueClass.subscribe(id, options, listener);
+  }
+  getCoValueClass() {
+    return this.coValueClass;
+  }
+  optional() {
+    return coOptionalDefiner(this);
+  }
+};
+function createCoreCoDiscriminatedUnionSchema(discriminator, schemas) {
+  return {
+    collaborative: true,
+    builtin: "CoDiscriminatedUnion",
+    getDefinition: () => ({
+      discriminator,
+      get discriminatorMap() {
+        const propValues = {};
+        for (const option of schemas) {
+          const dm = option.getDefinition().discriminatorMap;
+          if (!dm || Object.keys(dm).length === 0)
+            throw new Error(
+              `Invalid discriminated union option at index "${schemas.indexOf(option)}"`
+            );
+          for (const [k, v] of Object.entries(dm)) {
+            propValues[k] ??= /* @__PURE__ */ new Set();
+            for (const val of v) {
+              propValues[k].add(val);
+            }
+          }
+        }
+        return propValues;
+      },
+      get options() {
+        return schemas;
+      }
+    })
+  };
+}
+
+// src/tools/implementation/zodSchema/schemaTypes/CoOptionalSchema.ts
+var CoOptionalSchema = class {
+  constructor(innerType) {
+    this.innerType = innerType;
+    this.collaborative = true;
+    this.builtin = "CoOptional";
+    this.getDefinition = () => ({
+      innerType: this.innerType
+    });
+  }
+  getCoValueClass() {
+    return this.innerType.getCoValueClass();
+  }
+};
+
+// src/tools/implementation/zodSchema/schemaTypes/RichTextSchema.ts
+function createCoreCoRichTextSchema() {
+  return {
+    collaborative: true,
+    builtin: "CoRichText"
+  };
+}
+var RichTextSchema = class {
+  constructor(coValueClass) {
+    this.coValueClass = coValueClass;
+    this.collaborative = true;
+    this.builtin = "CoRichText";
+  }
+  create(text, options) {
+    return this.coValueClass.create(text, options);
+  }
+  load(id, options) {
+    return this.coValueClass.load(id, options);
+  }
+  subscribe(...args) {
+    return this.coValueClass.subscribe(...args);
+  }
+  getCoValueClass() {
+    return this.coValueClass;
+  }
+  optional() {
+    return coOptionalDefiner(this);
+  }
+};
+
+// src/tools/implementation/zodSchema/zodCo.ts
+var coMapDefiner = (shape) => {
+  const coreSchema = createCoreCoMapSchema(shape);
+  return hydrateCoreCoValueSchema(coreSchema);
+};
+var coAccountDefiner = (shape = {
+  profile: coMapDefiner({
+    name: z.string(),
+    inbox: z.optional(z.string()),
+    inboxInvite: z.optional(z.string())
+  }),
+  root: coMapDefiner({})
+}) => {
+  const coreSchema = createCoreAccountSchema(shape);
+  return hydrateCoreCoValueSchema(coreSchema);
+};
+var coRecordDefiner = (_keyType, valueType) => {
+  return coMapDefiner({}).catchall(valueType);
+};
+var coListDefiner = (element) => {
+  const coreSchema = createCoreCoListSchema(element);
+  return hydrateCoreCoValueSchema(coreSchema);
+};
+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 coreSchema = createCoreCoFeedSchema(element);
+  return hydrateCoreCoValueSchema(coreSchema);
+};
+var coFileStreamDefiner = () => {
+  const coreSchema = createCoreFileStreamSchema();
+  return hydrateCoreCoValueSchema(coreSchema);
+};
+var coPlainTextDefiner = () => {
+  const coreSchema = createCoreCoPlainTextSchema();
+  return hydrateCoreCoValueSchema(coreSchema);
+};
+var coRichTextDefiner = () => {
+  const coreSchema = createCoreCoRichTextSchema();
+  return hydrateCoreCoValueSchema(coreSchema);
+};
+var coImageDefiner = () => {
+  return ImageDefinition;
+};
+var coOptionalDefiner = (schema) => {
+  return new CoOptionalSchema(schema);
+};
+var coDiscriminatedUnionDefiner = (discriminator, schemas) => {
+  const coreSchema = createCoreCoDiscriminatedUnionSchema(
+    discriminator,
+    schemas
+  );
+  return hydrateCoreCoValueSchema(coreSchema);
+};
+
+// src/tools/implementation/zodSchema/coExport.ts
+var coExport_exports = {};
+__export(coExport_exports, {
+  DiscriminatedUnion: () => CoDiscriminatedUnionSchema,
+  Feed: () => CoFeedSchema,
+  FileStream: () => FileStreamSchema,
+  List: () => CoListSchema,
+  Optional: () => CoOptionalSchema,
+  PlainText: () => PlainTextSchema,
+  RichText: () => RichTextSchema,
+  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 createCoreCoMapSchema(shape, catchAll) {
+  return {
+    collaborative: true,
+    builtin: "CoMap",
+    shape,
+    catchAll,
+    getDefinition: () => ({
+      get shape() {
+        return shape;
+      },
+      get catchall() {
+        return catchAll;
+      },
+      get discriminatorMap() {
+        const propValues = {};
+        for (const key in removeGetters(shape)) {
+          if (isAnyCoValueSchema2(shape[key])) {
+            continue;
+          }
+          const field = shape[key]._zod;
+          if (field.values) {
+            propValues[key] ??= /* @__PURE__ */ new Set();
+            for (const v of field.values) propValues[key].add(v);
+          }
+        }
+        return propValues;
+      }
+    })
+  };
+}
+function enrichCoMapSchema(schema, coValueClass) {
+  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: (catchAll) => {
+      const schemaWithCatchAll = createCoreCoMapSchema(
+        coValueSchema.getDefinition().shape,
+        catchAll
+      );
+      return hydrateCoreCoValueSchema(schemaWithCatchAll);
+    },
+    withMigration: (migration) => {
+      coValueClass.prototype.migrate = migration;
+      return coValueSchema;
+    },
+    getCoValueClass: () => {
+      return coValueClass;
+    },
+    optional: () => {
+      return coOptionalDefiner(coValueSchema);
+    }
+  });
+  return coValueSchema;
+}
+
+// src/tools/implementation/zodSchema/schemaTypes/CoListSchema.ts
+var CoListSchema = class {
+  constructor(element, coValueClass) {
+    this.element = element;
+    this.coValueClass = coValueClass;
+    this.collaborative = true;
+    this.builtin = "CoList";
+  }
+  create(items, options) {
+    return this.coValueClass.create(items, options);
+  }
+  load(id, options) {
+    return this.coValueClass.load(id, options);
+  }
+  subscribe(id, options, listener) {
+    return this.coValueClass.subscribe(id, options, listener);
+  }
+  getCoValueClass() {
+    return this.coValueClass;
+  }
+  optional() {
+    return coOptionalDefiner(this);
+  }
+};
+function createCoreCoListSchema(element) {
+  return {
+    collaborative: true,
+    builtin: "CoList",
+    element
+  };
 }
-function isZodArray(schema) {
-  return schema.def?.type === "array";
+
+// src/tools/implementation/zodSchema/schemaTypes/CoFeedSchema.ts
+var CoFeedSchema = class {
+  constructor(element, coValueClass) {
+    this.element = element;
+    this.coValueClass = coValueClass;
+    this.collaborative = true;
+    this.builtin = "CoFeed";
+  }
+  create(init, options) {
+    return this.coValueClass.create(init, options);
+  }
+  load(id, options) {
+    return this.coValueClass.load(id, options);
+  }
+  subscribe(...args) {
+    return this.coValueClass.subscribe(...args);
+  }
+  getCoValueClass() {
+    return this.coValueClass;
+  }
+  optional() {
+    return coOptionalDefiner(this);
+  }
+};
+function createCoreCoFeedSchema(element) {
+  return {
+    collaborative: true,
+    builtin: "CoFeed",
+    element
+  };
 }
-function isZodCustom(schema) {
-  return schema.def?.type === "custom";
+
+// src/tools/implementation/zodSchema/schemaTypes/PlainTextSchema.ts
+function createCoreCoPlainTextSchema() {
+  return {
+    collaborative: true,
+    builtin: "CoPlainText"
+  };
 }
-function getDef(schema) {
-  return schema.def;
+var PlainTextSchema = class {
+  constructor(coValueClass) {
+    this.coValueClass = coValueClass;
+    this.collaborative = true;
+    this.builtin = "CoPlainText";
+  }
+  create(text, options) {
+    return this.coValueClass.create(text, options);
+  }
+  load(id, options) {
+    return this.coValueClass.load(id, options);
+  }
+  subscribe(...args) {
+    return this.coValueClass.subscribe(...args);
+  }
+  fromRaw(raw) {
+    return this.coValueClass.fromRaw(raw);
+  }
+  getCoValueClass() {
+    return this.coValueClass;
+  }
+  optional() {
+    return coOptionalDefiner(this);
+  }
+};
+
+// src/tools/implementation/zodSchema/schemaTypes/FileStreamSchema.ts
+function createCoreFileStreamSchema() {
+  return {
+    collaborative: true,
+    builtin: "FileStream"
+  };
 }
+var FileStreamSchema = class {
+  constructor(coValueClass) {
+    this.coValueClass = coValueClass;
+    this.collaborative = true;
+    this.builtin = "FileStream";
+  }
+  create(options) {
+    return this.coValueClass.create(options);
+  }
+  createFromBlob(blob, options) {
+    return this.coValueClass.createFromBlob(blob, options);
+  }
+  loadAsBlob(id, options) {
+    return this.coValueClass.loadAsBlob(id, options);
+  }
+  load(id, options) {
+    return this.coValueClass.load(id, options);
+  }
+  subscribe(...args) {
+    return this.coValueClass.subscribe(...args);
+  }
+  getCoValueClass() {
+    return this.coValueClass;
+  }
+  optional() {
+    return coOptionalDefiner(this);
+  }
+};
 
-// src/tools/implementation/zodSchema/schemaTypes/RichTextSchema.ts
-function enrichRichTextSchema(schema, coValueClass) {
-  return Object.assign(schema, {
+// src/tools/implementation/zodSchema/schemaTypes/AccountSchema.ts
+function createCoreAccountSchema(shape) {
+  return {
+    ...createCoreCoMapSchema(shape),
+    builtin: "Account"
+  };
+}
+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);
     },
+    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/unionUtils.ts
 import { RawCoList } from "cojson";
 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 co.discriminatedUnion() instead"
-      );
-    }
-    const discriminator = schema._zod.def.discriminator;
-    const field = schema._zod.disc.get(discriminator);
+    const definition = schema.getDefinition();
+    const { discriminatorMap, discriminator, options } = definition;
+    const field = discriminatorMap[discriminator];
     if (!field) {
       throw new Error(
         "co.discriminatedUnion() of collaborative types with non-existent discriminator key is not supported"
       );
     }
-    for (const value of field.values) {
+    for (const value of field) {
       if (typeof value !== "string" && typeof value !== "number") {
         throw new Error(
           "co.discriminatedUnion() of collaborative types with non-string or non-number discriminator value is not supported"
@@ -3771,13 +4201,13 @@ function schemaUnionDiscriminatorFor(schema) {
       }
     }
     const availableOptions = [];
-    for (const option of schema._zod.def.options) {
-      if (option._zod.def.type === "object") {
+    for (const option of options) {
+      if (option.builtin === "CoMap") {
         availableOptions.push(option);
-      } else if (option._zod.def.type === "union") {
-        for (const subOption of option._zod.def.options) {
-          if (subOption._zod.def.type === "object") {
-            availableOptions.push(subOption);
+      } else if (option.builtin === "CoDiscriminatedUnion") {
+        for (const subOption of option.getDefinition().options) {
+          if (!options.includes(subOption)) {
+            options.push(subOption);
           }
         }
       } else {
@@ -3794,8 +4224,8 @@ function schemaUnionDiscriminatorFor(schema) {
       }
       for (const option of availableOptions) {
         let match = true;
-        for (const key of schema._zod.disc.keys()) {
-          const discriminatorDef = option._zod.def.shape[key];
+        for (const key of Object.keys(discriminatorMap)) {
+          const discriminatorDef = option.getDefinition().shape[key];
           const discriminatorValue = _raw.get(key);
           if (discriminatorValue && typeof discriminatorValue === "object") {
             throw new Error("Discriminator must be a primitive value");
@@ -3818,7 +4248,7 @@ function schemaUnionDiscriminatorFor(schema) {
           }
         }
         if (match) {
-          const coValueSchema = zodSchemaToCoSchema(option);
+          const coValueSchema = hydrateCoreCoValueSchema(option);
           return coValueSchema.getCoValueClass();
         }
       }
@@ -3829,22 +4259,18 @@ function schemaUnionDiscriminatorFor(schema) {
     return determineSchema;
   } else {
     throw new Error(
-      "z.discriminatedUnion() of non-collaborative types is not supported"
+      "co.discriminatedUnion() of non-collaborative types is not supported"
     );
   }
 }
 function isUnionOfCoMapsDeeply(schema) {
-  if (schema instanceof z.core.$ZodUnion) {
-    return schema._zod.def.options.every(isCoMapOrUnionOfCoMapsDeeply);
-  } else {
-    return false;
-  }
+  return schema.getDefinition().options.every(isCoMapOrUnionOfCoMapsDeeply);
 }
 function isCoMapOrUnionOfCoMapsDeeply(schema) {
-  if (schema instanceof z.core.$ZodObject && isAnyCoValueSchema(schema)) {
+  if (schema.builtin === "CoMap") {
     return true;
-  } else if (schema instanceof z.core.$ZodUnion) {
-    return schema._zod.def.options.every(isCoMapOrUnionOfCoMapsDeeply);
+  } else if (schema.builtin === "CoDiscriminatedUnion") {
+    return schema.getDefinition().options.every(isCoMapOrUnionOfCoMapsDeeply);
   } else {
     return false;
   }
@@ -3853,104 +4279,81 @@ function isUnionOfPrimitivesDeeply(schema) {
   if (schema instanceof z.core.$ZodUnion) {
     return schema._zod.def.options.every(isUnionOfPrimitivesDeeply);
   } else {
-    return !isAnyCoValueSchema(schema);
+    return !isAnyCoValueSchema2(schema);
   }
 }
 
-// src/tools/implementation/zodSchema/runtimeConverters/zodFieldToCoFieldDef.ts
-function schemaFieldToCoFieldDef(schema, isOptional = false) {
+// src/tools/implementation/zodSchema/runtimeConverters/schemaFieldToCoFieldDef.ts
+function schemaFieldToCoFieldDef(schema) {
   if (isCoValueClass(schema)) {
-    if (isOptional) {
-      return coField.ref(schema, { optional: true });
-    } else {
-      return coField.ref(schema);
-    }
+    return coField.ref(schema);
   } else if (isCoValueSchema(schema)) {
-    if (isAnyCoOptionalSchema(schema)) {
+    if (schema.builtin === "CoOptional") {
       return coField.ref(schema.getCoValueClass(), {
         optional: true
       });
     }
-    if (isOptional) {
-      return coField.ref(schema.getCoValueClass(), { optional: true });
-    } else {
-      return coField.ref(schema.getCoValueClass());
-    }
+    return coField.ref(schema.getCoValueClass());
   } else {
     if ("_zod" in schema) {
-      if (schema._zod.def.type === "optional") {
-        const inner = zodSchemaToCoSchemaOrKeepPrimitive(
-          schema._zod.def.innerType
-        );
-        return schemaFieldToCoFieldDef(inner, true);
-      } else if (schema._zod.def.type === "string") {
+      const zodSchemaDef = schema._zod.def;
+      if (zodSchemaDef.type === "optional" || zodSchemaDef.type === "nullable") {
+        const inner = zodSchemaDef.innerType;
+        const coFieldDef = schemaFieldToCoFieldDef(inner);
+        if (zodSchemaDef.type === "nullable" && coFieldDef === coField.optional.Date) {
+          throw new Error("Nullable z.date() is not supported");
+        }
+        return coFieldDef;
+      } else if (zodSchemaDef.type === "string") {
         return coField.string;
-      } else if (schema._zod.def.type === "number") {
+      } else if (zodSchemaDef.type === "number") {
         return coField.number;
-      } else if (schema._zod.def.type === "boolean") {
+      } else if (zodSchemaDef.type === "boolean") {
         return coField.boolean;
-      } else if (schema._zod.def.type === "null") {
+      } else if (zodSchemaDef.type === "null") {
         return coField.null;
-      } else if (schema._zod.def.type === "enum") {
+      } else if (zodSchemaDef.type === "enum") {
         return coField.string;
-      } else if (schema._zod.def.type === "readonly") {
+      } else if (zodSchemaDef.type === "readonly") {
         return schemaFieldToCoFieldDef(
-          schema.def.innerType,
-          isOptional
+          schema.def.innerType
         );
-      } else if (schema._zod.def.type === "date") {
+      } else if (zodSchemaDef.type === "date") {
         return coField.optional.Date;
-      } else if (schema._zod.def.type === "template_literal") {
+      } else if (zodSchemaDef.type === "template_literal") {
         return coField.string;
-      } else if (schema._zod.def.type === "lazy") {
+      } else if (zodSchemaDef.type === "lazy") {
         return schemaFieldToCoFieldDef(
-          schema.unwrap(),
-          isOptional
+          schema.unwrap()
         );
-      } else if (schema._zod.def.type === "default" || schema._zod.def.type === "catch") {
+      } else if (zodSchemaDef.type === "default" || zodSchemaDef.type === "catch") {
         console.warn(
           "z.default()/z.catch() are not supported in collaborative schemas. They will be ignored."
         );
         return schemaFieldToCoFieldDef(
-          schema.def.innerType,
-          isOptional
+          schema.def.innerType
         );
-      } else if (schema._zod.def.type === "literal") {
-        if (schema._zod.def.values.some(
-          (literal2) => typeof literal2 === "undefined"
-        )) {
+      } else if (zodSchemaDef.type === "literal") {
+        if (zodSchemaDef.values.some((literal2) => typeof literal2 === "undefined")) {
           throw new Error("z.literal() with undefined is not supported");
         }
-        if (schema._zod.def.values.some((literal2) => literal2 === null)) {
+        if (zodSchemaDef.values.some((literal2) => literal2 === null)) {
           throw new Error("z.literal() with null is not supported");
         }
-        if (schema._zod.def.values.some((literal2) => typeof literal2 === "bigint")) {
+        if (zodSchemaDef.values.some((literal2) => typeof literal2 === "bigint")) {
           throw new Error("z.literal() with bigint is not supported");
         }
         return coField.literal(
-          ...schema._zod.def.values
+          ...zodSchemaDef.values
         );
-      } else if (schema._zod.def.type === "object" || schema._zod.def.type === "array" || schema._zod.def.type === "tuple") {
+      } else if (zodSchemaDef.type === "object" || zodSchemaDef.type === "array" || zodSchemaDef.type === "tuple") {
         return coField.json();
-      } else if (schema._zod.def.type === "custom") {
-        if ("builtin" in schema) {
-          return schemaFieldToCoFieldDef(schema.builtin, isOptional);
-        } else {
-          throw new Error(`Unsupported custom zod type`);
-        }
-      } else if (schema._zod.def.type === "union") {
+      } else if (zodSchemaDef.type === "union") {
         if (isUnionOfPrimitivesDeeply(schema)) {
           return coField.json();
-        } else if (isUnionOfCoMapsDeeply(schema)) {
-          const result = schemaUnionDiscriminatorFor(schema);
-          if (isOptional) {
-            return coField.ref(result, { optional: true });
-          } else {
-            return coField.ref(result);
-          }
         } else {
           throw new Error(
-            "z.union()/z.discriminatedUnion() of mixed collaborative and non-collaborative types is not supported"
+            "z.union()/z.discriminatedUnion() of collaborative types is not supported. Use co.discriminatedUnion() instead."
           );
         }
       } else {
@@ -3964,455 +4367,94 @@ function schemaFieldToCoFieldDef(schema, isOptional = false) {
   }
 }
 
-// src/tools/implementation/zodSchema/runtimeConverters/zodSchemaToCoSchema.ts
-var coSchemasForZodSchemas = /* @__PURE__ */ new Map();
-function isAnyCoValueSchema(schema) {
+// src/tools/implementation/zodSchema/runtimeConverters/coValueSchemaTransformation.ts
+function isAnyCoValueSchema2(schema) {
   return "collaborative" in schema && schema.collaborative === true;
 }
 function isCoValueSchema(schema) {
-  return isAnyCoValueSchema(schema) && "getCoValueClass" in schema;
+  return isAnyCoValueSchema2(schema) && "getCoValueClass" in schema;
 }
-function tryZodSchemaToCoSchema(schema) {
-  if (isAnyCoValueSchema(schema)) {
-    if (coSchemasForZodSchemas.has(schema)) {
-      return coSchemasForZodSchemas.get(
-        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 coValueClass = class ZCoMap extends ClassToExtend {
-        constructor(options) {
-          super(options);
-          for (const [field, fieldType] of Object.entries(
-            def.shape
-          )) {
-            this[field] = schemaFieldToCoFieldDef(
-              zodSchemaToCoSchemaOrKeepPrimitive(fieldType)
-            );
-          }
-          if (def.catchall) {
-            this[coField.items] = schemaFieldToCoFieldDef(
-              zodSchemaToCoSchemaOrKeepPrimitive(def.catchall)
-            );
-          }
-        }
-      };
-      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 coValueClass = class ZCoList extends CoList {
-        constructor(options) {
-          super(options);
-          this[coField.items] = schemaFieldToCoFieldDef(
-            zodSchemaToCoSchemaOrKeepPrimitive(def.element)
+function hydrateCoreCoValueSchema(schema) {
+  if (isCoValueSchema(schema)) {
+    return schema;
+  }
+  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) {
+        super(options);
+        for (const [fieldName, fieldType] of Object.entries(def.shape)) {
+          this[fieldName] = schemaFieldToCoFieldDef(
+            fieldType
           );
         }
-      };
-      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) {
-          const coValueClass = CoFeed.Of(
-            schemaFieldToCoFieldDef(
-              zodSchemaToCoSchemaOrKeepPrimitive(
-                schema.element
-              )
-            )
+        if (def.catchall) {
+          this[coField.items] = schemaFieldToCoFieldDef(
+            def.catchall
           );
-          const coValueSchema = enrichCoFeedSchema(schema, coValueClass);
-          return coValueSchema;
-        } else if (schema.builtin === "FileStream") {
-          const coValueClass = FileStream;
-          const coValueSchema = enrichFileStreamSchema(schema, coValueClass);
-          return coValueSchema;
-        } else if (schema.builtin === "CoPlainText") {
-          const coValueClass = CoPlainText;
-          const coValueSchema = enrichPlainTextSchema(schema, coValueClass);
-          return coValueSchema;
-        } else if (schema.builtin === "CoRichText") {
-          const coValueClass = CoRichText;
-          const coValueSchema = enrichRichTextSchema(schema, coValueClass);
-          return coValueSchema;
-        } 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, void 0, 2)}`
-      );
-    }
-  } else if (schema instanceof z.core.$ZodDiscriminatedUnion) {
-    if (isUnionOfCoMapsDeeply(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"
-      );
-    }
+    };
+    const coValueSchema = ClassToExtend === Account ? enrichAccountSchema(schema, coValueClass) : enrichCoMapSchema(schema, coValueClass);
+    return coValueSchema;
+  } else if (schema.builtin === "CoList") {
+    const element = schema.element;
+    const coValueClass = class ZCoList extends CoList {
+      constructor(options) {
+        super(options);
+        this[coField.items] = schemaFieldToCoFieldDef(
+          element
+        );
+      }
+    };
+    const coValueSchema = new CoListSchema(element, coValueClass);
+    return coValueSchema;
+  } else if (schema.builtin === "CoFeed") {
+    const coValueClass = CoFeed.Of(
+      schemaFieldToCoFieldDef(schema.element)
+    );
+    const coValueSchema = new CoFeedSchema(schema.element, coValueClass);
+    return coValueSchema;
+  } else if (schema.builtin === "FileStream") {
+    const coValueClass = FileStream;
+    return new FileStreamSchema(coValueClass);
+  } else if (schema.builtin === "CoPlainText") {
+    const coValueClass = CoPlainText;
+    return new PlainTextSchema(coValueClass);
+  } else if (schema.builtin === "CoRichText") {
+    const coValueClass = CoRichText;
+    return new RichTextSchema(coValueClass);
+  } else if (schema.builtin === "CoDiscriminatedUnion") {
+    const coValueClass = SchemaUnion.Of(schemaUnionDiscriminatorFor(schema));
+    const coValueSchema = new CoDiscriminatedUnionSchema(schema, coValueClass);
+    return coValueSchema;
   } else {
-    return null;
-  }
-}
-function zodSchemaToCoSchema(schema) {
-  const coSchema = tryZodSchemaToCoSchema(schema);
-  if (!coSchema) {
+    const notReachable = schema;
     throw new Error(
-      `Unsupported zod type: ${schema._zod?.def?.type || JSON.stringify(schema)}`
+      `Unsupported zod CoValue type for top-level schema: ${JSON.stringify(notReachable, void 0, 2)}`
     );
   }
-  return coSchema;
 }
-function anySchemaToCoSchema(schema) {
+function coValueClassFromCoValueClassOrSchema(schema) {
   if (isCoValueClass(schema)) {
     return schema;
   } else if (isCoValueSchema(schema)) {
     return schema.getCoValueClass();
-  } else if ("def" in schema) {
-    const coSchema = tryZodSchemaToCoSchema(
-      schema
-    );
-    if (!coSchema) {
-      throw new Error(
-        `Unsupported zod type: ${schema.def?.type || JSON.stringify(schema)}`
-      );
-    }
-    return coSchema.getCoValueClass();
   }
   throw new Error(`Unsupported schema: ${JSON.stringify(schema)}`);
 }
-function zodSchemaToCoSchemaOrKeepPrimitive(schema) {
-  const coSchema = tryZodSchemaToCoSchema(schema);
-  if (!coSchema) {
-    return 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()]),
   placeholderDataURL: z.string().optional()
 }).catchall(coFileStreamDefiner());
-var ImageDefinition = ImageDefinitionBase.withHelpers((Self) => ({
+var ImageDefinition = Object.assign({}, ImageDefinitionBase, {
   highestResAvailable(imageDef, options) {
     const resolutions = Object.keys(imageDef).filter(
       (key) => key.match(/^\d+x\d+$/)
@@ -4442,7 +4484,7 @@ var ImageDefinition = ImageDefinitionBase.withHelpers((Self) => ({
       stream: imageDef[highestAvailableResolution]
     };
   }
-}));
+});
 
 // src/tools/implementation/ContextManager.ts
 import { cojsonInternals as cojsonInternals4 } from "cojson";
@@ -5013,46 +5055,6 @@ function subscribeToCoValue(cls, id, options, listener) {
   }
   return unsubscribe;
 }
-function createCoValueObservable(initialValue = void 0) {
-  let currentValue = initialValue;
-  let subscriberCount = 0;
-  function subscribe(cls, id, options, listener) {
-    subscriberCount++;
-    const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(cls),
-      id,
-      {
-        loadAs: options.loadAs,
-        resolve: options.resolve,
-        onUnavailable: () => {
-          currentValue = null;
-          options.onUnavailable?.();
-        },
-        onUnauthorized: () => {
-          currentValue = null;
-          options.onUnauthorized?.();
-        },
-        syncResolution: options.syncResolution
-      },
-      (value) => {
-        currentValue = value;
-        listener();
-      }
-    );
-    return () => {
-      unsubscribe();
-      subscriberCount--;
-      if (subscriberCount === 0) {
-        currentValue = void 0;
-      }
-    };
-  }
-  const observable = {
-    getCurrentValue: () => currentValue,
-    subscribe
-  };
-  return observable;
-}
 function subscribeToExistingCoValue(existing, options, listener) {
   return subscribeToCoValue(
     existing.constructor,
@@ -5073,9 +5075,9 @@ function isAccountInstance(instance) {
   return "_type" in instance && instance._type === "Account";
 }
 function parseCoValueCreateOptions(options) {
-  const Group4 = RegisteredSchemas["Group"];
+  const Group9 = RegisteredSchemas["Group"];
   if (!options) {
-    return { owner: Group4.create(), uniqueness: void 0 };
+    return { owner: Group9.create(), uniqueness: void 0 };
   }
   if ("_type" in options) {
     if (options._type === "Account" || options._type === "Group") {
@@ -5084,7 +5086,7 @@ function parseCoValueCreateOptions(options) {
   }
   const uniqueness = options.unique ? { uniqueness: options.unique } : void 0;
   return {
-    owner: options.owner ?? Group4.create(),
+    owner: options.owner ?? Group9.create(),
     uniqueness
   };
 }
@@ -5103,7 +5105,7 @@ async function exportCoValue(cls, id, options) {
     resolve,
     id,
     {
-      ref: anySchemaToCoSchema(cls),
+      ref: coValueClassFromCoValueClassOrSchema(cls),
       optional: false
     },
     options.skipRetry,
@@ -5172,7 +5174,6 @@ export {
   zodReExport_exports,
   loadCoValue,
   subscribeToCoValue,
-  createCoValueObservable,
   exportCoValue,
   importContentPieces,
   CoValueBase,
@@ -5200,10 +5201,9 @@ export {
   createJazzContextForNewAccount,
   createJazzContext,
   createAnonymousJazzContext,
-  zodSchemaToCoSchema,
-  anySchemaToCoSchema,
   coMapDefiner,
   coExport_exports,
+  coValueClassFromCoValueClassOrSchema,
   ImageDefinition,
   KvStoreContext,
   AuthSecretStorage,
@@ -5211,4 +5211,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-OSVAAVWQ.js.map
+//# sourceMappingURL=chunk-CL3ROOZM.js.map