jazz-tools 0.15.15 → 0.16.0

package/dist/{chunk-4CFNXQE7.js → chunk-MLCNE3TL.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,22 +84,45 @@ 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
+import {
+  emptyKnownState
+} from "cojson";
+
 // src/tools/coValues/CoValueBase.ts
 import { ControlledAccount, RawAccount } from "cojson";
 var CoValueBase = class {
@@ -104,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);
@@ -718,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
@@ -756,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);
@@ -1771,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) {
@@ -1921,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 {
@@ -2179,6 +2222,13 @@ var Profile = class extends CoMap {
 
 // src/tools/coValues/inbox.ts
 import { RawAccount as RawAccount4 } from "cojson";
+
+// src/tools/lib/id.ts
+function isCoValueId(id) {
+  return typeof id === "string" && id.startsWith("co_z");
+}
+
+// src/tools/coValues/inbox.ts
 function createInboxRoot(account) {
   if (!account.isLocalNodeOwner) {
     throw new Error("Account is not controlled");
@@ -2261,7 +2311,7 @@ var Inbox = class _Inbox {
                 );
               }
               return loadCoValue(
-                anySchemaToCoSchema(Schema),
+                coValueClassFromCoValueClassOrSchema(Schema),
                 message.get("payload"),
                 {
                   loadAs: account
@@ -2403,7 +2453,7 @@ async function acceptInvite(invite, account) {
   account ||= activeAccountContext.get();
   const id = invite.slice(0, invite.indexOf("/"));
   const inviteSecret = invite.slice(invite.indexOf("/") + 1);
-  if (!id?.startsWith("co_z") || !inviteSecret.startsWith("inviteSecret_")) {
+  if (!isCoValueId(id) || !inviteSecret.startsWith("inviteSecret_")) {
     throw new Error("Invalid inbox ticket");
   }
   if (!account.isLocalNodeOwner) {
@@ -2415,7 +2465,7 @@ async function acceptInvite(invite, account) {
 function getAccountIDfromSessionID(sessionID) {
   const until = sessionID.indexOf("_session");
   const accountID = sessionID.slice(0, until);
-  if (accountID.startsWith("co_z")) {
+  if (isCoValueId(accountID)) {
     return accountID;
   }
   return;
@@ -2453,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);
@@ -3007,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) {
@@ -3027,11 +3079,12 @@ function createCoValue(ref2, raw, subscriptionScope) {
 
 // src/tools/subscribe/SubscriptionScope.ts
 var SubscriptionScope = class _SubscriptionScope {
-  constructor(node, resolve, id, schema, skipRetry) {
+  constructor(node, resolve, id, schema, skipRetry = false, bestEffortResolution = false) {
     this.node = node;
     this.id = id;
     this.schema = schema;
     this.skipRetry = skipRetry;
+    this.bestEffortResolution = bestEffortResolution;
     this.childNodes = /* @__PURE__ */ new Map();
     this.childValues = /* @__PURE__ */ new Map();
     this.childErrors = /* @__PURE__ */ new Map();
@@ -3162,6 +3215,9 @@ var SubscriptionScope = class _SubscriptionScope {
     if (this.childErrors.size === 0 && this.validationErrors.size === 0) {
       return void 0;
     }
+    if (this.bestEffortResolution) {
+      return void 0;
+    }
     for (const [key, value] of this.childErrors.entries()) {
       if (this.autoloaded.has(key)) {
         continue;
@@ -3289,7 +3345,9 @@ var SubscriptionScope = class _SubscriptionScope {
       this.node,
       true,
       id,
-      descriptor
+      descriptor,
+      this.skipRetry,
+      this.bestEffortResolution
     );
     this.childNodes.set(id, child);
     child.setListener((value) => this.handleChildUpdate(id, value));
@@ -3468,7 +3526,9 @@ var SubscriptionScope = class _SubscriptionScope {
       this.node,
       resolve,
       id,
-      descriptor
+      descriptor,
+      this.skipRetry,
+      this.bestEffortResolution
     );
     this.childNodes.set(id, child);
     child.setListener((value) => this.handleChildUpdate(id, value, key));
@@ -3549,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,
@@ -3589,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,
@@ -3695,23 +3755,220 @@ function createAnonymousJazzContext({
   };
 }
 
-// src/tools/implementation/zodSchema/zodSchema.ts
-function isZodObject(schema) {
-  return schema.def?.type === "object";
-}
-function isZodArray(schema) {
-  return schema.def?.type === "array";
-}
-function isZodCustom(schema) {
-  return schema.def?.type === "custom";
-}
-function getDef(schema) {
-  return schema.def;
+// 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 enrichRichTextSchema(schema, coValueClass) {
-  return Object.assign(schema, {
+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);
     },
@@ -3721,591 +3978,176 @@ function enrichRichTextSchema(schema, coValueClass) {
     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/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);
-    if (!field) {
-      throw new Error(
-        "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(
-          "co.discriminatedUnion() of collaborative types with non-string or non-number discriminator value is not supported"
-        );
-      }
-    }
-    const availableOptions = [];
-    for (const option of schema._zod.def.options) {
-      if (option._zod.def.type === "object") {
-        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 {
-        throw new Error(
-          "Unsupported zod type in co.discriminatedUnion() of collaborative types"
-        );
-      }
-    }
-    const determineSchema = (_raw) => {
-      if (_raw instanceof RawCoList) {
-        throw new Error(
-          "co.discriminatedUnion() of collaborative types is not supported for CoLists"
-        );
-      }
-      for (const option of availableOptions) {
-        let match = true;
-        for (const key of schema._zod.disc.keys()) {
-          const discriminatorDef = option._zod.def.shape[key];
-          const discriminatorValue = _raw.get(key);
-          if (discriminatorValue && typeof discriminatorValue === "object") {
-            throw new Error("Discriminator must be a primitive value");
-          }
-          if (!discriminatorDef) {
-            if (key === discriminator) {
-              match = false;
-              break;
-            } else {
-              continue;
-            }
-          }
-          if (discriminatorDef._zod.def.type !== "literal") {
-            break;
-          }
-          const literalDef = discriminatorDef._zod.def;
-          if (!Array.from(literalDef.values).includes(discriminatorValue)) {
-            match = false;
-            break;
-          }
-        }
-        if (match) {
-          const coValueSchema = zodSchemaToCoSchema(option);
-          return coValueSchema.getCoValueClass();
-        }
-      }
-      throw new Error(
-        "co.discriminatedUnion() of collaborative types with no matching discriminator value found"
-      );
-    };
-    return determineSchema;
-  } else {
-    throw new Error(
-      "z.discriminatedUnion() of non-collaborative types is not supported"
-    );
+// 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";
   }
-}
-function isUnionOfCoMapsDeeply(schema) {
-  if (schema instanceof z.core.$ZodUnion) {
-    return schema._zod.def.options.every(isCoMapOrUnionOfCoMapsDeeply);
-  } else {
-    return false;
+  create(items, options) {
+    return this.coValueClass.create(items, options);
   }
-}
-function isCoMapOrUnionOfCoMapsDeeply(schema) {
-  if (schema instanceof z.core.$ZodObject && isAnyCoValueSchema(schema)) {
-    return true;
-  } else if (schema instanceof z.core.$ZodUnion) {
-    return schema._zod.def.options.every(isCoMapOrUnionOfCoMapsDeeply);
-  } else {
-    return false;
+  load(id, options) {
+    return this.coValueClass.load(id, options);
   }
-}
-function isUnionOfPrimitivesDeeply(schema) {
-  if (schema instanceof z.core.$ZodUnion) {
-    return schema._zod.def.options.every(isUnionOfPrimitivesDeeply);
-  } else {
-    return !isAnyCoValueSchema(schema);
+  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
+  };
 }
 
-// src/tools/implementation/zodSchema/runtimeConverters/zodFieldToCoFieldDef.ts
-function schemaFieldToCoFieldDef(schema, isOptional = false) {
-  if (isCoValueClass(schema)) {
-    if (isOptional) {
-      return coField.ref(schema, { optional: true });
-    } else {
-      return coField.ref(schema);
-    }
-  } else if (isCoValueSchema(schema)) {
-    if (isAnyCoOptionalSchema(schema)) {
-      return coField.ref(schema.getCoValueClass(), {
-        optional: true
-      });
-    }
-    if (isOptional) {
-      return coField.ref(schema.getCoValueClass(), { optional: true });
-    } else {
-      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") {
-        return coField.string;
-      } else if (schema._zod.def.type === "number") {
-        return coField.number;
-      } else if (schema._zod.def.type === "boolean") {
-        return coField.boolean;
-      } else if (schema._zod.def.type === "null") {
-        return coField.null;
-      } else if (schema._zod.def.type === "enum") {
-        return coField.string;
-      } else if (schema._zod.def.type === "readonly") {
-        return schemaFieldToCoFieldDef(
-          schema.def.innerType,
-          isOptional
-        );
-      } else if (schema._zod.def.type === "date") {
-        return coField.optional.Date;
-      } else if (schema._zod.def.type === "template_literal") {
-        return coField.string;
-      } else if (schema._zod.def.type === "lazy") {
-        return schemaFieldToCoFieldDef(
-          schema.unwrap(),
-          isOptional
-        );
-      } 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 schemaFieldToCoFieldDef(
-          schema.def.innerType,
-          isOptional
-        );
-      } else if (schema._zod.def.type === "literal") {
-        if (schema._zod.def.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)) {
-          throw new Error("z.literal() with null is not supported");
-        }
-        if (schema._zod.def.values.some((literal2) => typeof literal2 === "bigint")) {
-          throw new Error("z.literal() with bigint is not supported");
-        }
-        return coField.literal(
-          ...schema._zod.def.values
-        );
-      } else if (schema._zod.def.type === "object" || schema._zod.def.type === "array" || schema._zod.def.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") {
-        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"
-          );
-        }
-      } else {
-        throw new Error(
-          `Unsupported zod type: ${schema._zod?.def?.type || JSON.stringify(schema)}`
-        );
-      }
-    } else {
-      throw new Error(`Unsupported zod type: ${schema}`);
-    }
+// 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";
   }
-}
-
-// 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 (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)
-          );
-        }
-      };
-      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
-              )
-            )
-          );
-          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"
-      );
-    }
-  } else {
-    return null;
+  create(init, options) {
+    return this.coValueClass.create(init, options);
   }
-}
-function zodSchemaToCoSchema(schema) {
-  const coSchema = tryZodSchemaToCoSchema(schema);
-  if (!coSchema) {
-    throw new Error(
-      `Unsupported zod type: ${schema._zod?.def?.type || JSON.stringify(schema)}`
-    );
+  load(id, options) {
+    return this.coValueClass.load(id, options);
   }
-  return coSchema;
-}
-function anySchemaToCoSchema(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();
+  subscribe(...args) {
+    return this.coValueClass.subscribe(...args);
   }
-  throw new Error(`Unsupported schema: ${JSON.stringify(schema)}`);
-}
-function zodSchemaToCoSchemaOrKeepPrimitive(schema) {
-  const coSchema = tryZodSchemaToCoSchema(schema);
-  if (!coSchema) {
-    return schema;
+  getCoValueClass() {
+    return this.coValueClass;
+  }
+  optional() {
+    return coOptionalDefiner(this);
   }
-  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, {
+function createCoreCoFeedSchema(element) {
+  return {
     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/PlainTextSchema.ts
+function createCoreCoPlainTextSchema() {
+  return {
+    collaborative: true,
+    builtin: "CoPlainText"
+  };
 }
+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/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/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/AccountSchema.ts
+function createCoreAccountSchema(shape) {
+  return {
+    ...createCoreCoMapSchema(shape),
+    builtin: "Account"
+  };
+}
 function enrichAccountSchema(schema, coValueClass) {
   const enrichedSchema = Object.assign(schema, {
     create: (...args) => {
@@ -4323,9 +4165,6 @@ function enrichAccountSchema(schema, coValueClass) {
     subscribe: (...args) => {
       return coValueClass.subscribe(...args);
     },
-    withHelpers: (helpers) => {
-      return Object.assign(schema, helpers(schema));
-    },
     fromRaw: (...args) => {
       return coValueClass.fromRaw(...args);
     },
@@ -4342,49 +4181,268 @@ function enrichAccountSchema(schema, 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/unionUtils.ts
+import { RawCoList } from "cojson";
+function schemaUnionDiscriminatorFor(schema) {
+  if (isUnionOfCoMapsDeeply(schema)) {
+    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) {
+      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"
+        );
+      }
+    }
+    const availableOptions = [];
+    for (const option of options) {
+      if (option.builtin === "CoMap") {
+        availableOptions.push(option);
+      } else if (option.builtin === "CoDiscriminatedUnion") {
+        for (const subOption of option.getDefinition().options) {
+          if (!options.includes(subOption)) {
+            options.push(subOption);
+          }
+        }
+      } else {
+        throw new Error(
+          "Unsupported zod type in co.discriminatedUnion() of collaborative types"
+        );
+      }
+    }
+    const determineSchema = (_raw) => {
+      if (_raw instanceof RawCoList) {
+        throw new Error(
+          "co.discriminatedUnion() of collaborative types is not supported for CoLists"
+        );
+      }
+      for (const option of availableOptions) {
+        let match = true;
+        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");
+          }
+          if (!discriminatorDef) {
+            if (key === discriminator) {
+              match = false;
+              break;
+            } else {
+              continue;
+            }
+          }
+          if (discriminatorDef._zod.def.type !== "literal") {
+            break;
+          }
+          const literalDef = discriminatorDef._zod.def;
+          if (!Array.from(literalDef.values).includes(discriminatorValue)) {
+            match = false;
+            break;
+          }
+        }
+        if (match) {
+          const coValueSchema = hydrateCoreCoValueSchema(option);
+          return coValueSchema.getCoValueClass();
+        }
+      }
+      throw new Error(
+        "co.discriminatedUnion() of collaborative types with no matching discriminator value found"
+      );
+    };
+    return determineSchema;
+  } else {
+    throw new Error(
+      "co.discriminatedUnion() of non-collaborative types is not supported"
+    );
+  }
+}
+function isUnionOfCoMapsDeeply(schema) {
+  return schema.getDefinition().options.every(isCoMapOrUnionOfCoMapsDeeply);
+}
+function isCoMapOrUnionOfCoMapsDeeply(schema) {
+  if (schema.builtin === "CoMap") {
+    return true;
+  } else if (schema.builtin === "CoDiscriminatedUnion") {
+    return schema.getDefinition().options.every(isCoMapOrUnionOfCoMapsDeeply);
+  } else {
+    return false;
+  }
+}
+function isUnionOfPrimitivesDeeply(schema) {
+  if (schema instanceof z.core.$ZodUnion) {
+    return schema._zod.def.options.every(isUnionOfPrimitivesDeeply);
+  } else {
+    return !isAnyCoValueSchema2(schema);
+  }
 }
 
-// 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/implementation/zodSchema/runtimeConverters/schemaFieldToCoFieldDef.ts
+function schemaFieldToCoFieldDef(schema) {
+  if (isCoValueClass(schema)) {
+    return coField.ref(schema);
+  } else if (isCoValueSchema(schema)) {
+    if (schema.builtin === "CoOptional") {
+      return coField.ref(schema.getCoValueClass(), {
+        optional: true
+      });
     }
-  });
+    return coField.ref(schema.getCoValueClass());
+  } else {
+    if ("_zod" in schema) {
+      const zodSchemaDef = schema._zod.def;
+      if (zodSchemaDef.type === "optional") {
+        const inner = zodSchemaDef.innerType;
+        return schemaFieldToCoFieldDef(inner);
+      } else if (zodSchemaDef.type === "string") {
+        return coField.string;
+      } else if (zodSchemaDef.type === "number") {
+        return coField.number;
+      } else if (zodSchemaDef.type === "boolean") {
+        return coField.boolean;
+      } else if (zodSchemaDef.type === "null") {
+        return coField.null;
+      } else if (zodSchemaDef.type === "enum") {
+        return coField.string;
+      } else if (zodSchemaDef.type === "readonly") {
+        return schemaFieldToCoFieldDef(
+          schema.def.innerType
+        );
+      } else if (zodSchemaDef.type === "date") {
+        return coField.optional.Date;
+      } else if (zodSchemaDef.type === "template_literal") {
+        return coField.string;
+      } else if (zodSchemaDef.type === "lazy") {
+        return schemaFieldToCoFieldDef(
+          schema.unwrap()
+        );
+      } 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
+        );
+      } else if (zodSchemaDef.type === "literal") {
+        if (zodSchemaDef.values.some((literal2) => typeof literal2 === "undefined")) {
+          throw new Error("z.literal() with undefined is not supported");
+        }
+        if (zodSchemaDef.values.some((literal2) => literal2 === null)) {
+          throw new Error("z.literal() with null is not supported");
+        }
+        if (zodSchemaDef.values.some((literal2) => typeof literal2 === "bigint")) {
+          throw new Error("z.literal() with bigint is not supported");
+        }
+        return coField.literal(
+          ...zodSchemaDef.values
+        );
+      } else if (zodSchemaDef.type === "object" || zodSchemaDef.type === "array" || zodSchemaDef.type === "tuple") {
+        return coField.json();
+      } else if (zodSchemaDef.type === "union") {
+        if (isUnionOfPrimitivesDeeply(schema)) {
+          return coField.json();
+        } else {
+          throw new Error(
+            "z.union()/z.discriminatedUnion() of collaborative types is not supported. Use co.discriminatedUnion() instead."
+          );
+        }
+      } else {
+        throw new Error(
+          `Unsupported zod type: ${schema._zod?.def?.type || JSON.stringify(schema)}`
+        );
+      }
+    } else {
+      throw new Error(`Unsupported zod type: ${schema}`);
+    }
+  }
+}
+
+// src/tools/implementation/zodSchema/runtimeConverters/coValueSchemaTransformation.ts
+function isAnyCoValueSchema2(schema) {
+  return "collaborative" in schema && schema.collaborative === true;
+}
+function isCoValueSchema(schema) {
+  return isAnyCoValueSchema2(schema) && "getCoValueClass" in schema;
+}
+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
+          );
+        }
+        if (def.catchall) {
+          this[coField.items] = schemaFieldToCoFieldDef(
+            def.catchall
+          );
+        }
+      }
+    };
+    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 {
+    const notReachable = schema;
+    throw new Error(
+      `Unsupported zod CoValue type for top-level schema: ${JSON.stringify(notReachable, void 0, 2)}`
+    );
+  }
+}
+function coValueClassFromCoValueClassOrSchema(schema) {
+  if (isCoValueClass(schema)) {
+    return schema;
+  } else if (isCoValueSchema(schema)) {
+    return schema.getCoValueClass();
+  }
+  throw new Error(`Unsupported schema: ${JSON.stringify(schema)}`);
 }
 
 // src/tools/coValues/extensions/imageDef.ts
@@ -4392,7 +4450,7 @@ 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+$/)
@@ -4422,7 +4480,7 @@ var ImageDefinition = ImageDefinitionBase.withHelpers((Self) => ({
       stream: imageDef[highestAvailableResolution]
     };
   }
-}));
+});
 
 // src/tools/implementation/ContextManager.ts
 import { cojsonInternals as cojsonInternals4 } from "cojson";
@@ -4993,46 +5051,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,
@@ -5053,9 +5071,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") {
@@ -5064,7 +5082,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
   };
 }
@@ -5074,12 +5092,86 @@ function parseGroupCreateOptions(options) {
   }
   return "_type" in options && isAccountInstance(options) ? { owner: options } : { owner: options.owner ?? activeAccountContext.get() };
 }
+async function exportCoValue(cls, id, options) {
+  const loadAs = options.loadAs ?? activeAccountContext.get();
+  const node = "node" in loadAs ? loadAs.node : loadAs._raw.core.node;
+  const resolve = options.resolve ?? true;
+  const rootNode = new SubscriptionScope(
+    node,
+    resolve,
+    id,
+    {
+      ref: coValueClassFromCoValueClassOrSchema(cls),
+      optional: false
+    },
+    options.skipRetry,
+    options.bestEffortResolution
+  );
+  const value = await new Promise((resolve2) => {
+    rootNode.setListener((value2) => {
+      if (value2.type === "unavailable") {
+        resolve2(null);
+        console.error(value2.toString());
+      } else if (value2.type === "unauthorized") {
+        resolve2(null);
+        console.error(value2.toString());
+      } else if (value2.type === "loaded") {
+        resolve2(value2.value);
+      }
+      rootNode.destroy();
+    });
+  });
+  if (!value) {
+    return null;
+  }
+  const valuesExported = /* @__PURE__ */ new Set();
+  const contentPieces = [];
+  loadContentPiecesFromSubscription(rootNode, valuesExported, contentPieces);
+  return contentPieces;
+}
+function loadContentPiecesFromSubscription(subscription, valuesExported, contentPieces) {
+  if (valuesExported.has(subscription.id)) {
+    return;
+  }
+  valuesExported.add(subscription.id);
+  const core2 = subscription.getCurrentValue()?._raw.core;
+  if (core2) {
+    loadContentPiecesFromCoValue(core2, valuesExported, contentPieces);
+  }
+  for (const child of subscription.childNodes.values()) {
+    loadContentPiecesFromSubscription(child, valuesExported, contentPieces);
+  }
+}
+function loadContentPiecesFromCoValue(core2, valuesExported, contentPieces) {
+  for (const dependency of core2.getDependedOnCoValues()) {
+    if (valuesExported.has(dependency)) {
+      continue;
+    }
+    const depCoValue = core2.node.getCoValue(dependency);
+    if (depCoValue.isAvailable()) {
+      valuesExported.add(dependency);
+      loadContentPiecesFromCoValue(depCoValue, valuesExported, contentPieces);
+    }
+  }
+  const pieces = core2.verified.newContentSince(emptyKnownState(core2.id));
+  for (const piece of pieces ?? []) {
+    contentPieces.push(piece);
+  }
+}
+function importContentPieces(contentPieces, loadAs) {
+  const account = loadAs ?? Account.getMe();
+  const node = "node" in account ? account.node : account._raw.core.node;
+  for (const piece of contentPieces) {
+    node.syncManager.handleNewContent(piece, "import");
+  }
+}
 
 export {
   zodReExport_exports,
   loadCoValue,
   subscribeToCoValue,
-  createCoValueObservable,
+  exportCoValue,
+  importContentPieces,
   CoValueBase,
   CoMap,
   CoList,
@@ -5089,6 +5181,7 @@ export {
   isControlledAccount,
   Group,
   Profile,
+  isCoValueId,
   Inbox,
   InboxSender,
   CoPlainText,
@@ -5104,9 +5197,9 @@ export {
   createJazzContextForNewAccount,
   createJazzContext,
   createAnonymousJazzContext,
-  zodSchemaToCoSchema,
-  anySchemaToCoSchema,
+  coMapDefiner,
   coExport_exports,
+  coValueClassFromCoValueClassOrSchema,
   ImageDefinition,
   KvStoreContext,
   AuthSecretStorage,
@@ -5114,4 +5207,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-4CFNXQE7.js.map
+//# sourceMappingURL=chunk-MLCNE3TL.js.map