jazz-tools 0.17.14 → 0.18.0

package/dist/react-core/index.js

@@ -12,10 +12,10 @@ import React, {
   useSyncExternalStore
 } from "react";
 import {
-  Account,
+  Account as Account13,
   InboxSender,
-  SubscriptionScope,
-  coValueClassFromCoValueClassOrSchema
+  SubscriptionScope as SubscriptionScope2,
+  coValueClassFromCoValueClassOrSchema as coValueClassFromCoValueClassOrSchema2
 } from "jazz-tools";
 
 // src/react-core/utils.ts
@@ -27,6 +27,4635 @@ function getCurrentAccountFromContextManager(contextManager) {
   return "me" in context ? context.me : context.guest;
 }
 
+// src/tools/coValues/interfaces.ts
+function isCoValueClass(value) {
+  return typeof value === "function" && value.fromRaw !== void 0;
+}
+function loadCoValueWithoutMe(cls, id, options) {
+  return loadCoValue(cls, id, {
+    ...options,
+    loadAs: options?.loadAs ?? activeAccountContext.get()
+  });
+}
+function loadCoValue(cls, id, options) {
+  return new Promise((resolve) => {
+    subscribeToCoValue(
+      cls,
+      id,
+      {
+        resolve: options.resolve,
+        loadAs: options.loadAs,
+        syncResolution: true,
+        skipRetry: options.skipRetry,
+        onUnavailable: () => {
+          resolve(null);
+        },
+        onUnauthorized: () => {
+          resolve(null);
+        }
+      },
+      (value, unsubscribe) => {
+        resolve(value);
+        unsubscribe();
+      }
+    );
+  });
+}
+async function ensureCoValueLoaded(existing, options) {
+  const response = await loadCoValue(
+    existing.constructor,
+    existing.$jazz.id,
+    {
+      loadAs: existing.$jazz.loadedAs,
+      resolve: options?.resolve
+    }
+  );
+  if (!response) {
+    throw new Error("Failed to deeply load CoValue " + existing.$jazz.id);
+  }
+  return response;
+}
+function parseSubscribeRestArgs(args) {
+  if (args.length === 2) {
+    if (typeof args[0] === "object" && args[0] && typeof args[1] === "function") {
+      return {
+        options: {
+          resolve: args[0].resolve,
+          loadAs: args[0].loadAs,
+          onUnauthorized: args[0].onUnauthorized,
+          onUnavailable: args[0].onUnavailable
+        },
+        listener: args[1]
+      };
+    } else {
+      throw new Error("Invalid arguments");
+    }
+  } else {
+    if (typeof args[0] === "function") {
+      return { options: {}, listener: args[0] };
+    } else {
+      throw new Error("Invalid arguments");
+    }
+  }
+}
+function subscribeToCoValueWithoutMe(cls, id, options, listener) {
+  return subscribeToCoValue(
+    cls,
+    id,
+    {
+      ...options,
+      loadAs: options.loadAs ?? activeAccountContext.get()
+    },
+    listener
+  );
+}
+function subscribeToCoValue(cls, id, options, listener) {
+  const loadAs = options.loadAs ?? activeAccountContext.get();
+  const node = "node" in loadAs ? loadAs.node : loadAs.$jazz.localNode;
+  const resolve = options.resolve ?? true;
+  let unsubscribed = false;
+  const rootNode = new SubscriptionScope(
+    node,
+    resolve,
+    id,
+    {
+      ref: cls,
+      optional: false
+    },
+    options.skipRetry
+  );
+  const handleUpdate = (value) => {
+    if (unsubscribed) return;
+    if (value.type === "unavailable") {
+      options.onUnavailable?.();
+      console.error(value.toString());
+    } else if (value.type === "unauthorized") {
+      options.onUnauthorized?.();
+      console.error(value.toString());
+    } else if (value.type === "loaded") {
+      listener(value.value, unsubscribe);
+    }
+  };
+  let shouldDefer = !options.syncResolution;
+  rootNode.setListener((value) => {
+    if (shouldDefer) {
+      shouldDefer = false;
+      Promise.resolve().then(() => {
+        handleUpdate(value);
+      });
+    } else {
+      handleUpdate(value);
+    }
+  });
+  function unsubscribe() {
+    unsubscribed = true;
+    rootNode.destroy();
+  }
+  return unsubscribe;
+}
+function subscribeToExistingCoValue(existing, options, listener) {
+  return subscribeToCoValue(
+    existing.constructor,
+    existing.$jazz.id,
+    {
+      loadAs: existing.$jazz.loadedAs,
+      resolve: options?.resolve,
+      onUnavailable: options?.onUnavailable,
+      onUnauthorized: options?.onUnauthorized
+    },
+    listener
+  );
+}
+function isAccountInstance(instance) {
+  if (typeof instance !== "object" || instance === null) {
+    return false;
+  }
+  return TypeSym in instance && instance[TypeSym] === "Account";
+}
+function parseCoValueCreateOptions(options) {
+  const Group16 = RegisteredSchemas["Group"];
+  if (!options) {
+    return { owner: Group16.create(), uniqueness: void 0 };
+  }
+  if (TypeSym in options) {
+    if (options[TypeSym] === "Account") {
+      return { owner: accountOrGroupToGroup(options), uniqueness: void 0 };
+    } else if (options[TypeSym] === "Group") {
+      return { owner: options, uniqueness: void 0 };
+    }
+  }
+  const uniqueness = options.unique ? { uniqueness: options.unique } : void 0;
+  const opts = {
+    owner: options.owner ? accountOrGroupToGroup(options.owner) : Group16.create(),
+    uniqueness
+  };
+  return opts;
+}
+function accountOrGroupToGroup(accountOrGroup) {
+  if (accountOrGroup[TypeSym] === "Group") {
+    return accountOrGroup;
+  }
+  return RegisteredSchemas["Group"].fromRaw(accountOrGroup.$jazz.raw);
+}
+function parseGroupCreateOptions(options) {
+  if (!options) {
+    return { owner: activeAccountContext.get() };
+  }
+  return TypeSym in options && isAccountInstance(options) ? { owner: options } : { owner: options.owner ?? activeAccountContext.get() };
+}
+
+// src/tools/coValues/CoValueBase.ts
+import { ControlledAccount } from "cojson";
+var CoValueBase = class {
+  /** @category Internals */
+  static fromRaw(raw) {
+    return new this({ fromRaw: raw });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  toJSON() {
+    return {
+      id: this.$jazz.id,
+      type: this[TypeSym],
+      error: "unknown CoValue class"
+    };
+  }
+  [inspect2]() {
+    return this.toJSON();
+  }
+};
+var CoValueJazzApi = class {
+  constructor(coValue) {
+    this.coValue = coValue;
+    Object.defineProperty(this, "_instanceID", {
+      value: `instance-${Math.random().toString(36).slice(2)}`,
+      enumerable: false
+    });
+  }
+  /** @internal */
+  get localNode() {
+    return this.raw.core.node;
+  }
+  /** @private */
+  get loadedAs() {
+    const agent = this.localNode.getCurrentAgent();
+    if (agent instanceof ControlledAccount) {
+      return coValuesCache.get(
+        agent.account,
+        () => coValueClassFromCoValueClassOrSchema(
+          RegisteredSchemas["Account"]
+        ).fromRaw(agent.account)
+      );
+    }
+    return new AnonymousJazzAgent2(this.localNode);
+  }
+};
+
+// src/tools/implementation/inspect.ts
+var inspect2 = Symbol.for("nodejs.util.inspect.custom");
+
+// src/tools/implementation/symbols.ts
+var SchemaInit = "$SchemaInit$";
+var ItemsSym = "$items$";
+var TypeSym = "$type$";
+
+// src/tools/coValues/registeredSchemas.ts
+var RegisteredSchemas = {};
+
+// src/tools/coValues/coMap.ts
+import {
+  cojsonInternals
+} from "cojson";
+var _CoMap = class _CoMap extends CoValueBase {
+  /** @internal */
+  constructor(options) {
+    super();
+    const proxy = new Proxy(this, CoMapProxyHandler);
+    if (options) {
+      if ("fromRaw" in options) {
+        Object.defineProperties(this, {
+          $jazz: {
+            value: new CoMapJazzApi(proxy, () => options.fromRaw),
+            enumerable: false
+          }
+        });
+      } else {
+        throw new Error("Invalid CoMap constructor arguments");
+      }
+    }
+    return proxy;
+  }
+  /**
+   * Create a new CoMap with the given initial values and owner.
+   *
+   * The owner (a Group or Account) determines access rights to the CoMap.
+   *
+   * The CoMap will immediately be persisted and synced to connected peers.
+   *
+   * @example
+   * ```ts
+   * const person = Person.create({
+   *   name: "Alice",
+   *   age: 42,
+   *   pet: cat,
+   * }, { owner: friendGroup });
+   * ```
+   *
+   * @category Creation
+   *
+   * @deprecated Use `co.map(...).create`.
+   **/
+  static create(init, options) {
+    const instance = new this();
+    return _CoMap._createCoMap(instance, init, options);
+  }
+  /**
+   * Return a JSON representation of the `CoMap`
+   * @category Content
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  toJSON(_key, processedValues) {
+    const result = {};
+    for (const key of this.$jazz.raw.keys()) {
+      const tKey = key;
+      const descriptor = this.$jazz.getDescriptor(tKey);
+      if (!descriptor) {
+        continue;
+      }
+      if (descriptor == "json" || "encoded" in descriptor) {
+        result[key] = this.$jazz.raw.get(key);
+      } else if (isRefEncoded(descriptor)) {
+        const id = this.$jazz.raw.get(key);
+        if (processedValues?.includes(id) || id === this.$jazz.id) {
+          result[key] = { _circular: id };
+          continue;
+        }
+        const ref2 = this[tKey];
+        if (ref2 && typeof ref2 === "object" && "toJSON" in ref2 && typeof ref2.toJSON === "function") {
+          const jsonedRef = ref2.toJSON(tKey, [
+            ...processedValues || [],
+            this.$jazz.id
+          ]);
+          result[key] = jsonedRef;
+        }
+      } else {
+        result[key] = void 0;
+      }
+    }
+    return result;
+  }
+  [inspect2]() {
+    return this.toJSON();
+  }
+  /**
+   * @internal
+   */
+  static _createCoMap(instance, init, options) {
+    const { owner, uniqueness } = parseCoValueCreateOptions(options);
+    Object.defineProperties(instance, {
+      $jazz: {
+        value: new CoMapJazzApi(instance, () => raw),
+        enumerable: false
+      }
+    });
+    const raw = _CoMap.rawFromInit(instance, init, owner, uniqueness);
+    return instance;
+  }
+  /**
+   * Create a new `RawCoMap` from an initialization object
+   * @internal
+   */
+  static rawFromInit(instance, init, owner, uniqueness) {
+    const rawOwner = owner.$jazz.raw;
+    const rawInit = {};
+    if (init)
+      for (const key of Object.keys(init)) {
+        const initValue = init[key];
+        const descriptor = instance.$jazz.getDescriptor(key);
+        if (!descriptor) {
+          continue;
+        }
+        if (descriptor === "json") {
+          rawInit[key] = initValue;
+        } else if (isRefEncoded(descriptor)) {
+          if (initValue != null) {
+            let refId = initValue.$jazz?.id;
+            if (!refId) {
+              const coValue = instantiateRefEncodedWithInit(
+                descriptor,
+                initValue,
+                owner
+              );
+              refId = coValue.$jazz.id;
+            }
+            rawInit[key] = refId;
+          }
+        } else if ("encoded" in descriptor) {
+          rawInit[key] = descriptor.encoded.encode(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            initValue
+          );
+        }
+      }
+    return rawOwner.createMap(rawInit, null, "private", uniqueness);
+  }
+  /**
+   * Declare a Record-like CoMap schema, by extending `CoMap.Record(...)` and passing the value schema using `co`. Keys are always `string`.
+   *
+   * @example
+   * ```ts
+   * import { coField, CoMap } from "jazz-tools";
+   *
+   * class ColorToFruitMap extends CoMap.Record(
+   *  coField.ref(Fruit)
+   * ) {}
+   *
+   * // assume we have map: ColorToFruitMap
+   * // and strawberry: Fruit
+   * map["red"] = strawberry;
+   * ```
+   *
+   * @category Declaration
+   */
+  static Record(value) {
+    var _a2, _b;
+    class RecordLikeCoMap extends (_b = _CoMap, _a2 = ItemsSym, _b) {
+      constructor() {
+        super(...arguments);
+        this[_a2] = value;
+      }
+    }
+    return RecordLikeCoMap;
+  }
+  /**
+   * Load a `CoMap` with a given ID, as a given account.
+   *
+   * `depth` specifies which (if any) fields that reference other CoValues to load as well before resolving.
+   * The `DeeplyLoaded` return type guarantees that corresponding referenced CoValues are loaded to the specified depth.
+   *
+   * You can pass `[]` or `{}` for shallowly loading only this CoMap, or `{ fieldA: depthA, fieldB: depthB }` for recursively loading referenced CoValues.
+   *
+   * Check out the `load` methods on `CoMap`/`CoList`/`CoFeed`/`Group`/`Account` to see which depth structures are valid to nest.
+   *
+   * @example
+   * ```ts
+   * const person = await Person.load(
+   *   "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
+   *   { pet: {} }
+   * );
+   * ```
+   *
+   * @category Subscription & Loading
+   *
+   * @deprecated Use `co.map(...).load` instead.
+   */
+  static load(id, options) {
+    return loadCoValueWithoutMe(this, id, options);
+  }
+  static subscribe(id, ...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToCoValueWithoutMe(this, id, options, listener);
+  }
+  /** @deprecated Use `CoMap.upsertUnique` and `CoMap.loadUnique` instead. */
+  static findUnique(unique, ownerID, as) {
+    return _CoMap._findUnique(unique, ownerID, as);
+  }
+  /** @internal */
+  static _findUnique(unique, ownerID, as) {
+    as ||= activeAccountContext.get();
+    const header = {
+      type: "comap",
+      ruleset: {
+        type: "ownedByGroup",
+        group: ownerID
+      },
+      meta: null,
+      uniqueness: unique
+    };
+    const crypto = as[TypeSym] === "Anonymous" ? as.node.crypto : as.$jazz.localNode.crypto;
+    return cojsonInternals.idforHeader(header, crypto);
+  }
+  /**
+   * Given some data, updates an existing CoMap or initialises a new one if none exists.
+   *
+   * Note: This method respects resolve options, and thus can return `null` if the references cannot be resolved.
+   *
+   * @example
+   * ```ts
+   * const activeEvent = await Event.upsertUnique(
+   *   sourceData.identifier,
+   *   workspace.id,
+   *   {
+   *     title: sourceData.title,
+   *     identifier: sourceData.identifier,
+   *     external_id: sourceData._id,
+   *   },
+   *   workspace
+   * );
+   * ```
+   *
+   * @param options The options for creating or loading the CoMap. This includes the intended state of the CoMap, its unique identifier, its owner, and the references to resolve.
+   * @returns Either an existing & modified CoMap, or a new initialised CoMap if none exists.
+   * @category Subscription & Loading
+   *
+   * @deprecated Use `co.map(...).upsertUnique` instead.
+   */
+  static async upsertUnique(options) {
+    const mapId = _CoMap._findUnique(
+      options.unique,
+      options.owner.$jazz.id,
+      options.owner.$jazz.loadedAs
+    );
+    let map = await loadCoValueWithoutMe(this, mapId, {
+      ...options,
+      loadAs: options.owner.$jazz.loadedAs,
+      skipRetry: true
+    });
+    if (!map) {
+      const instance = new this();
+      map = _CoMap._createCoMap(instance, options.value, {
+        owner: options.owner,
+        unique: options.unique
+      });
+    } else {
+      map.$jazz.applyDiff(
+        options.value
+      );
+    }
+    return await loadCoValueWithoutMe(this, mapId, {
+      ...options,
+      loadAs: options.owner.$jazz.loadedAs,
+      skipRetry: true
+    });
+  }
+  /**
+   * Loads a CoMap by its unique identifier and owner's ID.
+   * @param unique The unique identifier of the CoMap to load.
+   * @param ownerID The ID of the owner of the CoMap.
+   * @param options Additional options for loading the CoMap.
+   * @returns The loaded CoMap, or null if unavailable.
+   *
+   * @deprecated Use `co.map(...).loadUnique` instead.
+   */
+  static loadUnique(unique, ownerID, options) {
+    return loadCoValueWithoutMe(
+      this,
+      _CoMap._findUnique(unique, ownerID, options?.loadAs),
+      { ...options, skipRetry: true }
+    );
+  }
+};
+_CoMap.prototype[TypeSym] = "CoMap";
+var CoMap = _CoMap;
+var CoMapJazzApi = class extends CoValueJazzApi {
+  constructor(coMap, getRaw) {
+    super(coMap);
+    this.coMap = coMap;
+    this.getRaw = getRaw;
+  }
+  /**
+   * The ID of this `CoMap`
+   * @category Content
+   */
+  get id() {
+    return this.raw.id;
+  }
+  get owner() {
+    return getCoValueOwner(this.coMap);
+  }
+  /**
+   * Set a value on the CoMap
+   *
+   * @param key The key to set
+   * @param value The value to set
+   *
+   * @category Content
+   */
+  set(key, value) {
+    const descriptor = this.getDescriptor(key);
+    if (!descriptor) {
+      throw Error(`Cannot set unknown key ${key}`);
+    }
+    let refId = value?.$jazz?.id;
+    if (descriptor === "json") {
+      this.raw.set(key, value);
+    } else if ("encoded" in descriptor) {
+      this.raw.set(key, descriptor.encoded.encode(value));
+    } else if (isRefEncoded(descriptor)) {
+      if (value === void 0) {
+        if (!descriptor.optional) {
+          throw Error(`Cannot set required reference ${key} to undefined`);
+        }
+        this.raw.set(key, null);
+      } else {
+        if (!refId) {
+          const coValue = instantiateRefEncodedWithInit(
+            descriptor,
+            value,
+            this.owner
+          );
+          refId = coValue.$jazz.id;
+        }
+        this.raw.set(key, refId);
+      }
+    }
+  }
+  /**
+   * Delete a value from a CoMap.
+   *
+   * For record-like CoMaps (created with `co.record`), any string key can be deleted.
+   * For struct-like CoMaps (created with `co.map`), only optional properties can be deleted.
+   *
+   * @param key The key to delete
+   *
+   * @category Content
+   */
+  delete(key) {
+    this.raw.delete(key);
+  }
+  /**
+   * Modify the `CoMap` to match another map.
+   *
+   * The new values are assigned to the CoMap, overwriting existing values
+   * when the property already exists.
+   *
+   * @param newValues - The new values to apply to the CoMap. For collaborative values,
+   * both CoValues and JSON values are supported.
+   * @returns The modified CoMap.
+   *
+   * @category Content
+   */
+  applyDiff(newValues) {
+    for (const key in newValues) {
+      if (Object.prototype.hasOwnProperty.call(newValues, key)) {
+        const tKey = key;
+        const descriptor = this.getDescriptor(key);
+        if (!descriptor) continue;
+        const newValue = newValues[tKey];
+        const currentValue = this.coMap[tKey];
+        if (descriptor === "json" || "encoded" in descriptor) {
+          if (currentValue !== newValue) {
+            this.set(tKey, newValue);
+          }
+        } else if (isRefEncoded(descriptor)) {
+          const currentId = currentValue?.$jazz.id;
+          let newId = newValue?.$jazz?.id;
+          if (currentId !== newId) {
+            this.set(tKey, newValue);
+          }
+        }
+      }
+    }
+    return this.coMap;
+  }
+  /**
+   * Given an already loaded `CoMap`, ensure that the specified fields are loaded to the specified depth.
+   *
+   * Works like `CoMap.load()`, but you don't need to pass the ID or the account to load as again.
+   *
+   * @category Subscription & Loading
+   */
+  ensureLoaded(options) {
+    return ensureCoValueLoaded(this.coMap, options);
+  }
+  subscribe(...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToExistingCoValue(this.coMap, options, listener);
+  }
+  /**
+   * Wait for the `CoMap` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  async waitForSync(options) {
+    await this.raw.core.waitForSync(options);
+  }
+  /**
+   * Get the descriptor for a given key
+   * @internal
+   */
+  getDescriptor(key) {
+    return this.schema?.[key] || this.schema?.[ItemsSym];
+  }
+  /**
+   * If property `prop` is a `coField.ref(...)`, you can use `coMap.$jazz.refs.prop` to access
+   * the `Ref` instead of the potentially loaded/null value.
+   *
+   * This allows you to always get the ID or load the value manually.
+   *
+   * @example
+   * ```ts
+   * person.$jazz.refs.pet.id; // => ID<Animal>
+   * person.$jazz.refs.pet.value;
+   * // => Animal | null
+   * const pet = await person.$jazz.refs.pet.load();
+   * ```
+   *
+   * @category Content
+   **/
+  get refs() {
+    return makeRefs(
+      this.coMap,
+      (key) => this.raw.get(key),
+      () => {
+        const keys = this.raw.keys().filter((key) => {
+          const descriptor = this.getDescriptor(key);
+          return descriptor && descriptor !== "json" && isRefEncoded(descriptor);
+        });
+        return keys;
+      },
+      this.loadedAs,
+      (key) => this.getDescriptor(key)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    );
+  }
+  /**
+   * Get the edits made to the CoMap.
+   *
+   * @category Collaboration
+   */
+  getEdits() {
+    const map = this.coMap;
+    return new Proxy(
+      {},
+      {
+        get(_target, key) {
+          const rawEdit = map.$jazz.raw.lastEditAt(key);
+          if (!rawEdit) return void 0;
+          const descriptor = map.$jazz.getDescriptor(key);
+          if (!descriptor) return void 0;
+          return {
+            ...getEditFromRaw(map, rawEdit, descriptor, key),
+            get all() {
+              return [...map.$jazz.raw.editsAt(key)].map(
+                (rawEdit2) => getEditFromRaw(map, rawEdit2, descriptor, key)
+              );
+            }
+          };
+        },
+        ownKeys(_target) {
+          return map.$jazz.raw.keys();
+        },
+        getOwnPropertyDescriptor(target, key) {
+          return {
+            value: Reflect.get(target, key),
+            writable: false,
+            enumerable: true,
+            configurable: true
+          };
+        }
+      }
+    );
+  }
+  /** @internal */
+  get raw() {
+    return this.getRaw();
+  }
+  /**
+   * The timestamp of the creation time of the CoMap
+   *
+   * @category Content
+   */
+  get createdAt() {
+    return this.raw.earliestTxMadeAt ?? Number.MAX_SAFE_INTEGER;
+  }
+  /**
+   * The timestamp of the last updated time of the CoMap
+   *
+   * @category Content
+   */
+  get lastUpdatedAt() {
+    return this.raw.latestTxMadeAt;
+  }
+  /** @internal */
+  get schema() {
+    return this.coMap.constructor._schema;
+  }
+};
+var CoMapProxyHandler = {
+  get(target, key, receiver) {
+    if (key === "_schema") {
+      return Reflect.get(target, key);
+    } else if (key in target) {
+      return Reflect.get(target, key, receiver);
+    } else {
+      if (typeof key !== "string") {
+        return void 0;
+      }
+      const descriptor = target.$jazz.getDescriptor(key);
+      if (!descriptor) {
+        return void 0;
+      }
+      const raw = target.$jazz.raw.get(key);
+      if (descriptor === "json") {
+        return raw;
+      } else if ("encoded" in descriptor) {
+        return raw === void 0 ? void 0 : descriptor.encoded.decode(raw);
+      } else if (isRefEncoded(descriptor)) {
+        return raw === void 0 || raw === null ? void 0 : accessChildByKey(target, raw, key);
+      }
+    }
+  },
+  set(target, key, value, receiver) {
+    if (typeof key === "string" && typeof value === "object" && value !== null && SchemaInit in value) {
+      target.constructor._schema ||= {};
+      target.constructor._schema[key] = value[SchemaInit];
+      return true;
+    }
+    const descriptor = target.$jazz.getDescriptor(key);
+    if (!descriptor) return false;
+    if (typeof key === "string") {
+      throw Error("Cannot update a CoMap directly. Use `$jazz.set` instead.");
+    } else {
+      return Reflect.set(target, key, value, receiver);
+    }
+  },
+  defineProperty(target, key, attributes) {
+    if ("value" in attributes && typeof attributes.value === "object" && SchemaInit in attributes.value) {
+      target.constructor._schema ||= {};
+      target.constructor._schema[key] = attributes.value[SchemaInit];
+      return true;
+    } else {
+      return Reflect.defineProperty(target, key, attributes);
+    }
+  },
+  ownKeys(target) {
+    const keys = Reflect.ownKeys(target).filter((k) => k !== ItemsSym);
+    for (const key of target.$jazz.raw.keys()) {
+      if (!keys.includes(key)) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  },
+  getOwnPropertyDescriptor(target, key) {
+    if (key in target) {
+      return Reflect.getOwnPropertyDescriptor(target, key);
+    } else {
+      const descriptor = target.$jazz.getDescriptor(key);
+      if (descriptor || key in target.$jazz.raw.latest) {
+        return {
+          enumerable: true,
+          configurable: true,
+          writable: true
+        };
+      }
+    }
+  },
+  has(target, key) {
+    const descriptor = target.$jazz?.getDescriptor(key);
+    if (target.$jazz?.raw && typeof key === "string" && descriptor) {
+      return target.$jazz.raw.get(key) !== void 0;
+    } else {
+      return Reflect.has(target, key);
+    }
+  },
+  deleteProperty(target, key) {
+    const descriptor = target.$jazz.getDescriptor(key);
+    if (typeof key === "string" && descriptor) {
+      throw Error(
+        "Cannot delete a CoMap property directly. Use `$jazz.delete` instead."
+      );
+    } else {
+      return Reflect.deleteProperty(target, key);
+    }
+  }
+};
+RegisteredSchemas["CoMap"] = CoMap;
+function getEditFromRaw(target, rawEdit, descriptor, key) {
+  return {
+    value: descriptor === "json" ? rawEdit.value : "encoded" in descriptor ? rawEdit.value === null || rawEdit.value === void 0 ? rawEdit.value : descriptor.encoded.decode(rawEdit.value) : accessChildById(target, rawEdit.value, descriptor),
+    ref: descriptor !== "json" && isRefEncoded(descriptor) ? new Ref(
+      rawEdit.value,
+      target.$jazz.loadedAs,
+      descriptor,
+      target
+    ) : void 0,
+    get by() {
+      return rawEdit.by && accessChildById(target, rawEdit.by, {
+        ref: Account,
+        optional: false
+      });
+    },
+    madeAt: rawEdit.at,
+    key
+  };
+}
+
+// src/tools/coValues/coList.ts
+import { cojsonInternals as cojsonInternals2 } from "cojson";
+import { calcPatch } from "fast-myers-diff";
+var _CoList = class _CoList extends Array {
+  /**
+   * Declare a `CoList` by subclassing `CoList.Of(...)` and passing the item schema using `co`.
+   *
+   * @example
+   * ```ts
+   * class ColorList extends CoList.Of(
+   *   coField.string
+   * ) {}
+   * class AnimalList extends CoList.Of(
+   *   coField.ref(Animal)
+   * ) {}
+   * ```
+   *
+   * @category Declaration
+   */
+  static Of(item) {
+    var _a2, _b;
+    return class CoListOf extends (_b = _CoList, _a2 = coField.items, _b) {
+      constructor() {
+        super(...arguments);
+        this[_a2] = item;
+      }
+    };
+  }
+  /**
+   * @ignore
+   * @deprecated Use UPPERCASE `CoList.Of` instead! */
+  static of(..._args) {
+    throw new Error("Can't use Array.of with CoLists");
+  }
+  static get [(ItemsSym, Symbol.species)]() {
+    return Array;
+  }
+  constructor(options) {
+    super();
+    const proxy = new Proxy(this, CoListProxyHandler);
+    if (options && "fromRaw" in options) {
+      Object.defineProperties(this, {
+        $jazz: {
+          value: new CoListJazzApi(proxy, () => options.fromRaw),
+          enumerable: false
+        }
+      });
+    }
+    return proxy;
+  }
+  /**
+   * Create a new CoList with the given initial values and owner.
+   *
+   * The owner (a Group or Account) determines access rights to the CoMap.
+   *
+   * The CoList will immediately be persisted and synced to connected peers.
+   *
+   * @example
+   * ```ts
+   * const colours = ColorList.create(
+   *   ["red", "green", "blue"],
+   *   { owner: me }
+   * );
+   * const animals = AnimalList.create(
+   *   [cat, dog, fish],
+   *   { owner: me }
+   * );
+   * ```
+   *
+   * @category Creation
+   * @deprecated Use `co.list(...).create` instead.
+   **/
+  static create(items, options) {
+    const { owner, uniqueness } = parseCoValueCreateOptions(options);
+    const instance = new this();
+    Object.defineProperties(instance, {
+      $jazz: {
+        value: new CoListJazzApi(instance, () => raw),
+        enumerable: false
+      }
+    });
+    const raw = owner.$jazz.raw.createList(
+      toRawItems(items, instance.$jazz.schema[ItemsSym], owner),
+      null,
+      "private",
+      uniqueness
+    );
+    return instance;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  toJSON(_key, seenAbove) {
+    const itemDescriptor = this.$jazz.schema[ItemsSym];
+    if (itemDescriptor === "json") {
+      return this.$jazz.raw.asArray();
+    } else if ("encoded" in itemDescriptor) {
+      return this.$jazz.raw.asArray().map((e) => itemDescriptor.encoded.encode(e));
+    } else if (isRefEncoded(itemDescriptor)) {
+      return this.map(
+        (item, idx) => seenAbove?.includes(item?.$jazz.id) ? { _circular: item.$jazz.id } : item?.toJSON(idx + "", [
+          ...seenAbove || [],
+          this.$jazz.id
+        ])
+      );
+    } else {
+      return [];
+    }
+  }
+  [inspect2]() {
+    return this.toJSON();
+  }
+  /** @category Internals */
+  static fromRaw(raw) {
+    return new this({ fromRaw: raw });
+  }
+  /** @internal */
+  static schema(def) {
+    this._schema ||= {};
+    Object.assign(this._schema, def);
+  }
+  /**
+   * Load a `CoList` with a given ID, as a given account.
+   *
+   * `depth` specifies if item CoValue references should be loaded as well before resolving.
+   * The `DeeplyLoaded` return type guarantees that corresponding referenced CoValues are loaded to the specified depth.
+   *
+   * You can pass `[]` or for shallowly loading only this CoList, or `[itemDepth]` for recursively loading referenced CoValues.
+   *
+   * Check out the `load` methods on `CoMap`/`CoList`/`CoFeed`/`Group`/`Account` to see which depth structures are valid to nest.
+   *
+   * @example
+   * ```ts
+   * const animalsWithVets =
+   *   await ListOfAnimals.load(
+   *     "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
+   *     me,
+   *     [{ vet: {} }]
+   *   );
+   * ```
+   *
+   * @category Subscription & Loading
+   * @deprecated Use `co.list(...).load` instead.
+   */
+  static load(id, options) {
+    return loadCoValueWithoutMe(this, id, options);
+  }
+  static subscribe(id, ...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToCoValueWithoutMe(this, id, options, listener);
+  }
+  /** @deprecated Use `CoList.upsertUnique` and `CoList.loadUnique` instead. */
+  static findUnique(unique, ownerID, as) {
+    return _CoList._findUnique(unique, ownerID, as);
+  }
+  /** @internal */
+  static _findUnique(unique, ownerID, as) {
+    as ||= activeAccountContext.get();
+    const header = {
+      type: "colist",
+      ruleset: {
+        type: "ownedByGroup",
+        group: ownerID
+      },
+      meta: null,
+      uniqueness: unique
+    };
+    const crypto = as[TypeSym] === "Anonymous" ? as.node.crypto : as.$jazz.localNode.crypto;
+    return cojsonInternals2.idforHeader(header, crypto);
+  }
+  /**
+   * Given some data, updates an existing CoList or initialises a new one if none exists.
+   *
+   * Note: This method respects resolve options, and thus can return `null` if the references cannot be resolved.
+   *
+   * @example
+   * ```ts
+   * const activeItems = await ItemList.upsertUnique(
+   *   {
+   *     value: [item1, item2, item3],
+   *     unique: sourceData.identifier,
+   *     owner: workspace,
+   *   }
+   * );
+   * ```
+   *
+   * @param options The options for creating or loading the CoList. This includes the intended state of the CoList, its unique identifier, its owner, and the references to resolve.
+   * @returns Either an existing & modified CoList, or a new initialised CoList if none exists.
+   * @category Subscription & Loading
+   */
+  static async upsertUnique(options) {
+    const listId = _CoList._findUnique(
+      options.unique,
+      options.owner.$jazz.id,
+      options.owner.$jazz.loadedAs
+    );
+    let list = await loadCoValueWithoutMe(this, listId, {
+      ...options,
+      loadAs: options.owner.$jazz.loadedAs,
+      skipRetry: true
+    });
+    if (!list) {
+      list = this.create(options.value, {
+        owner: options.owner,
+        unique: options.unique
+      });
+    } else {
+      list.$jazz.applyDiff(options.value);
+    }
+    return await loadCoValueWithoutMe(this, listId, {
+      ...options,
+      loadAs: options.owner.$jazz.loadedAs,
+      skipRetry: true
+    });
+  }
+  /**
+   * Loads a CoList by its unique identifier and owner's ID.
+   * @param unique The unique identifier of the CoList to load.
+   * @param ownerID The ID of the owner of the CoList.
+   * @param options Additional options for loading the CoList.
+   * @returns The loaded CoList, or null if unavailable.
+   */
+  static loadUnique(unique, ownerID, options) {
+    return loadCoValueWithoutMe(
+      this,
+      _CoList._findUnique(unique, ownerID, options?.loadAs),
+      { ...options, skipRetry: true }
+    );
+  }
+  // Override mutation methods defined on Array, as CoLists aren't meant to be mutated directly
+  /**
+   * @deprecated Use `.$jazz.push` instead.
+   */
+  push(...items) {
+    throw new Error(
+      "Cannot mutate a CoList directly. Use `.$jazz.push` instead."
+    );
+  }
+  /**
+   * @deprecated Use `.$jazz.unshift` instead.
+   */
+  unshift(...items) {
+    throw new Error(
+      "Cannot mutate a CoList directly. Use `.$jazz.unshift` instead."
+    );
+  }
+  /**
+   * @deprecated Use `.$jazz.pop` instead.
+   */
+  // @ts-expect-error
+  pop(value) {
+    throw new Error(
+      "Cannot mutate a CoList directly. Use `.$jazz.pop` instead."
+    );
+  }
+  /**
+   * @deprecated Use `.$jazz.shift` instead.
+   */
+  // @ts-expect-error
+  shift(value) {
+    throw new Error(
+      "Cannot mutate a CoList directly. Use `.$jazz.shift` instead."
+    );
+  }
+  /**
+   * @deprecated Use `.$jazz.splice` instead.
+   */
+  splice(start, deleteCount, ...items) {
+    throw new Error(
+      "Cannot mutate a CoList directly. Use `.$jazz.splice` instead."
+    );
+  }
+  /**
+   * @deprecated Use `.$jazz.set` instead.
+   */
+  copyWithin(target, start, end) {
+    throw new Error(
+      "Cannot mutate a CoList directly. Use `.$jazz.set` instead."
+    );
+  }
+  /**
+   * @deprecated Use `.$jazz.set` instead.
+   */
+  fill(value, start, end) {
+    throw new Error(
+      "Cannot mutate a CoList directly. Use `.$jazz.set` instead."
+    );
+  }
+  /**
+   * @deprecated Use `.toReversed` if you want a reversed copy, or `.$jazz.set` to mutate the CoList.
+   */
+  // @ts-expect-error
+  reverse(value) {
+    throw new Error(
+      "Cannot mutate a CoList directly. Use `.toReversed` if you want a reversed copy, or `.$jazz.set` to mutate the CoList."
+    );
+  }
+  /**
+   * @deprecated Use `.toSorted()` if you want a sorted copy, or `.$jazz.set` to mutate the CoList.
+   */
+  sort(compareFn) {
+    throw new Error(
+      "Cannot mutate a CoList directly. Use `.toSorted` if you want a sorted copy, or `.$jazz.set` to mutate the CoList."
+    );
+  }
+};
+_CoList.prototype[TypeSym] = "CoList";
+var CoList = _CoList;
+var CoListJazzApi = class extends CoValueJazzApi {
+  constructor(coList, getRaw) {
+    super(coList);
+    this.coList = coList;
+    this.getRaw = getRaw;
+  }
+  /**
+   * The ID of this `CoList`
+   * @category Content
+   */
+  get id() {
+    return this.raw.id;
+  }
+  /** @category Collaboration */
+  get owner() {
+    return getCoValueOwner(this.coList);
+  }
+  set(index, value) {
+    const itemDescriptor = this.schema[ItemsSym];
+    const rawValue = toRawItems([value], itemDescriptor, this.owner)[0];
+    if (rawValue === null && !itemDescriptor.optional) {
+      throw new Error(`Cannot set required reference ${index} to undefined`);
+    }
+    this.raw.replace(index, rawValue);
+  }
+  /**
+   * Appends new elements to the end of an array, and returns the new length of the array.
+   * @param items New elements to add to the array.
+   *
+   * @category Content
+   */
+  push(...items) {
+    this.raw.appendItems(
+      toRawItems(items, this.schema[ItemsSym], this.owner),
+      void 0,
+      "private"
+    );
+    return this.raw.entries().length;
+  }
+  /**
+   * Inserts new elements at the start of an array, and returns the new length of the array.
+   * @param items Elements to insert at the start of the array.
+   *
+   * @category Content
+   */
+  unshift(...items) {
+    for (const item of toRawItems(
+      items,
+      this.schema[ItemsSym],
+      this.owner
+    )) {
+      this.raw.prepend(item);
+    }
+    return this.raw.entries().length;
+  }
+  /**
+   * Removes the last element from an array and returns it.
+   * If the array is empty, undefined is returned and the array is not modified.
+   *
+   * @category Content
+   */
+  pop() {
+    const last = this.coList[this.coList.length - 1];
+    this.raw.delete(this.coList.length - 1);
+    return last;
+  }
+  /**
+   * Removes the first element from an array and returns it.
+   * If the array is empty, undefined is returned and the array is not modified.
+   *
+   * @category Content
+   */
+  shift() {
+    const first = this.coList[0];
+    this.raw.delete(0);
+    return first;
+  }
+  /**
+   * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
+   * @param start The zero-based location in the array from which to start removing elements.
+   * @param deleteCount The number of elements to remove.
+   * @param items Elements to insert into the array in place of the deleted elements.
+   * @returns An array containing the elements that were deleted.
+   *
+   * @category Content
+   */
+  splice(start, deleteCount, ...items) {
+    const deleted = this.coList.slice(start, start + deleteCount);
+    for (let idxToDelete = start + deleteCount - 1; idxToDelete >= start; idxToDelete--) {
+      this.raw.delete(idxToDelete);
+    }
+    const rawItems = toRawItems(
+      items,
+      this.schema[ItemsSym],
+      this.owner
+    );
+    if (rawItems.length === 0) {
+      return deleted;
+    }
+    if (rawItems.length === 1) {
+      const item = rawItems[0];
+      if (item === void 0) return deleted;
+      if (start === 0) {
+        this.raw.prepend(item);
+      } else {
+        this.raw.append(item, Math.max(start - 1, 0));
+      }
+      return deleted;
+    }
+    if (start === 0) {
+      for (let i = rawItems.length - 1; i >= 0; i--) {
+        const item = rawItems[i];
+        if (item === void 0) continue;
+        this.raw.prepend(item);
+      }
+    } else {
+      let appendAfter = Math.max(start - 1, 0);
+      for (const item of rawItems) {
+        if (item === void 0) continue;
+        this.raw.append(item, appendAfter);
+        appendAfter++;
+      }
+    }
+    return deleted;
+  }
+  remove(...args) {
+    const predicate = args[0] instanceof Function ? args[0] : void 0;
+    let indices = [];
+    if (predicate) {
+      for (let i = 0; i < this.coList.length; i++) {
+        if (predicate(this.coList[i], i, this.coList)) {
+          indices.push(i);
+        }
+      }
+    } else {
+      indices = args.filter((index) => index >= 0 && index < this.coList.length).sort((a, b) => a - b);
+    }
+    const deletedItems = indices.map((index) => this.coList[index]);
+    for (const index of indices.reverse()) {
+      this.raw.delete(index);
+    }
+    return deletedItems;
+  }
+  /**
+   * Retains only the elements matching the predicate from the array.
+   * @param predicate The predicate to match the elements to retain.
+   * @returns The removed elements.
+   *
+   * @category Content
+   */
+  retain(predicate) {
+    return this.remove((...args) => !predicate(...args));
+  }
+  /**
+   * Modify the `CoList` to match another list, where the changes are managed internally.
+   *
+   * Changes are detected using `Object.is` for non-collaborative values and `$jazz.id` for collaborative values.
+   *
+   * @param result - The resolved list of items. For collaborative values, both CoValues and JSON values are supported.
+   * @returns The modified CoList.
+   *
+   * @category Content
+   */
+  applyDiff(result) {
+    const current = this.raw.asArray();
+    const comparator = isRefEncoded(this.schema[ItemsSym]) ? (aIdx, bIdx) => {
+      const oldCoValueId = current[aIdx]?.$jazz?.id;
+      const newCoValueId = result[bIdx]?.$jazz?.id;
+      const isSame = !!oldCoValueId && !!newCoValueId && oldCoValueId === newCoValueId;
+      return isSame;
+    } : void 0;
+    const patches = [...calcPatch(current, result, comparator)];
+    for (const [from, to, insert] of patches.reverse()) {
+      this.splice(from, to - from, ...insert);
+    }
+    return this.coList;
+  }
+  /**
+   * Given an already loaded `CoList`, ensure that items are loaded to the specified depth.
+   *
+   * Works like `CoList.load()`, but you don't need to pass the ID or the account to load as again.
+   *
+   * @category Subscription & Loading
+   */
+  ensureLoaded(options) {
+    return ensureCoValueLoaded(this.coList, options);
+  }
+  subscribe(...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToExistingCoValue(this.coList, options, listener);
+  }
+  /**
+   * Wait for the `CoList` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  async waitForSync(options) {
+    await this.raw.core.waitForSync(options);
+  }
+  /**
+   * Get the descriptor for the items in the `CoList`
+   * @internal
+   */
+  getItemsDescriptor() {
+    return this.schema[ItemsSym];
+  }
+  /**
+   * If a `CoList`'s items are a `coField.ref(...)`, you can use `coList.$jazz.refs[i]` to access
+   * the `Ref` instead of the potentially loaded/null value.
+   *
+   * This allows you to always get the ID or load the value manually.
+   *
+   * @example
+   * ```ts
+   * animals.$jazz.refs[0].id; // => ID<Animal>
+   * animals.$jazz.refs[0].value;
+   * // => Animal | null
+   * const animal = await animals.$jazz.refs[0].load();
+   * ```
+   *
+   * @category Content
+   **/
+  get refs() {
+    return makeRefs(
+      this.coList,
+      (idx) => this.raw.get(idx),
+      () => Array.from({ length: this.raw.entries().length }, (_, idx) => idx),
+      this.loadedAs,
+      (_idx) => this.schema[ItemsSym]
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    );
+  }
+  /**
+   * Get the edits made to the CoList.
+   *
+   * @category Collaboration
+   */
+  getEdits() {
+    throw new Error("Not implemented");
+  }
+  /** @internal */
+  get raw() {
+    return this.getRaw();
+  }
+  /** @internal */
+  get schema() {
+    return this.coList.constructor._schema;
+  }
+};
+function toRawItems(items, itemDescriptor, owner) {
+  let rawItems = [];
+  if (itemDescriptor === "json") {
+    rawItems = items;
+  } else if ("encoded" in itemDescriptor) {
+    rawItems = items?.map((e) => itemDescriptor.encoded.encode(e));
+  } else if (isRefEncoded(itemDescriptor)) {
+    rawItems = items?.map((value) => {
+      if (value == null) {
+        return null;
+      }
+      let refId = value.$jazz?.id;
+      if (!refId) {
+        const coValue = instantiateRefEncodedWithInit(
+          itemDescriptor,
+          value,
+          owner
+        );
+        refId = coValue.$jazz.id;
+      }
+      return refId;
+    });
+  } else {
+    throw new Error("Invalid element descriptor");
+  }
+  return rawItems;
+}
+var CoListProxyHandler = {
+  get(target, key, receiver) {
+    if (typeof key === "string" && !isNaN(+key)) {
+      const itemDescriptor = target.$jazz.schema[ItemsSym];
+      const rawValue = target.$jazz.raw.get(Number(key));
+      if (itemDescriptor === "json") {
+        return rawValue;
+      } else if ("encoded" in itemDescriptor) {
+        return rawValue === void 0 ? void 0 : itemDescriptor.encoded.decode(rawValue);
+      } else if (isRefEncoded(itemDescriptor)) {
+        return rawValue === void 0 || rawValue === null ? void 0 : accessChildByKey(target, rawValue, key);
+      }
+    } else if (key === "length") {
+      return target.$jazz.raw.entries().length;
+    } else {
+      return Reflect.get(target, key, receiver);
+    }
+  },
+  set(target, key, value, receiver) {
+    if (key === ItemsSym && typeof value === "object" && SchemaInit in value) {
+      target.constructor._schema ||= {};
+      target.constructor._schema[ItemsSym] = value[SchemaInit];
+      return true;
+    }
+    if (typeof key === "string" && !isNaN(+key)) {
+      throw Error("Cannot update a CoList directly. Use `$jazz.set` instead.");
+    } else {
+      return Reflect.set(target, key, value, receiver);
+    }
+  },
+  defineProperty(target, key, descriptor) {
+    if (descriptor.value && key === ItemsSym && typeof descriptor.value === "object" && SchemaInit in descriptor.value) {
+      target.constructor._schema ||= {};
+      target.constructor._schema[ItemsSym] = descriptor.value[SchemaInit];
+      return true;
+    } else {
+      return Reflect.defineProperty(target, key, descriptor);
+    }
+  },
+  has(target, key) {
+    if (typeof key === "string" && !isNaN(+key)) {
+      return Number(key) < target.$jazz.raw.entries().length;
+    } else {
+      return Reflect.has(target, key);
+    }
+  }
+};
+
+// src/tools/coValues/coFeed.ts
+import { cojsonInternals as cojsonInternals3 } from "cojson";
+var _CoFeed = class _CoFeed extends CoValueBase {
+  /**
+   * Declare a `CoFeed` by subclassing `CoFeed.Of(...)` and passing the item schema using a `co` primitive or a `coField.ref`.
+   *
+   * @example
+   * ```ts
+   * class ColorFeed extends CoFeed.Of(coField.string) {}
+   * class AnimalFeed extends CoFeed.Of(coField.ref(Animal)) {}
+   * ```
+   *
+   * @category Declaration
+   */
+  static Of(item) {
+    var _a2, _b;
+    const cls = class CoFeedOf extends (_b = _CoFeed, _a2 = coField.items, _b) {
+      constructor() {
+        super(...arguments);
+        this[_a2] = item;
+      }
+    };
+    cls._schema ||= {};
+    cls._schema[ItemsSym] = item[SchemaInit];
+    return cls;
+  }
+  /**
+   * The current account's view of this `CoFeed`
+   * @category Content
+   */
+  get byMe() {
+    if (this.$jazz.loadedAs[TypeSym] === "Account") {
+      return this.perAccount[this.$jazz.loadedAs.$jazz.id];
+    } else {
+      return void 0;
+    }
+  }
+  /**
+   * The per-account view of this `CoFeed`
+   *
+   * @example
+   * ```ts
+   * // Access entries directly by account ID
+   * const aliceEntries = feed[aliceAccount.id];
+   * console.log(aliceEntries.value); // Latest value from Alice
+   *
+   * // Iterate through all accounts' entries
+   * for (const [accountId, entries] of Object.entries(feed)) {
+   *   console.log(`Latest entry from ${accountId}:`, entries.value);
+   *
+   *   // Access all entries from this account
+   *   for (const entry of entries.all) {
+   *     console.log(`Entry made at ${entry.madeAt}:`, entry.value);
+   *   }
+   * }
+   * ```
+   *
+   * @category Content
+   */
+  get perAccount() {
+    return new Proxy({}, CoStreamPerAccountProxyHandler(this));
+  }
+  /**
+   * The per-session view of this `CoFeed`
+   * @category Content
+   */
+  get perSession() {
+    return new Proxy(
+      {},
+      CoStreamPerSessionProxyHandler(this, this)
+    );
+  }
+  /**
+   * The current session's view of this `CoFeed`
+   *
+   * This is a shortcut for `this.perSession` where the session ID is the current session ID.
+   *
+   * @category Content
+   */
+  get inCurrentSession() {
+    if (this.$jazz.loadedAs[TypeSym] === "Account") {
+      return this.perSession[this.$jazz.loadedAs.$jazz.sessionID];
+    } else {
+      return void 0;
+    }
+  }
+  /** @internal */
+  constructor(options) {
+    super();
+    Object.defineProperties(this, {
+      $jazz: {
+        value: new CoFeedJazzApi(this, options.fromRaw),
+        enumerable: false
+      }
+    });
+    return this;
+  }
+  /**
+   * Create a new `CoFeed`
+   * @category Creation
+   * @deprecated Use `co.feed(...).create` instead.
+   */
+  static create(init, options) {
+    const { owner } = parseCoValueCreateOptions(options);
+    const raw = owner.$jazz.raw.createStream();
+    const instance = new this({ fromRaw: raw });
+    if (init) {
+      instance.$jazz.push(...init);
+    }
+    return instance;
+  }
+  /**
+   * Get a JSON representation of the `CoFeed`
+   * @category
+   */
+  toJSON() {
+    const itemDescriptor = this.$jazz.schema[ItemsSym];
+    const mapper = itemDescriptor === "json" ? (v) => v : "encoded" in itemDescriptor ? itemDescriptor.encoded.encode : (v) => v && v.$jazz.id;
+    return {
+      ...Object.fromEntries(
+        Object.entries(this).map(([account, entry]) => [
+          account,
+          mapper(entry.value)
+        ])
+      ),
+      in: Object.fromEntries(
+        Object.entries(this.perSession).map(([session, entry]) => [
+          session,
+          mapper(entry.value)
+        ])
+      )
+    };
+  }
+  /** @internal */
+  [(ItemsSym, inspect2)]() {
+    return this.toJSON();
+  }
+  /** @internal */
+  static schema(def) {
+    this._schema ||= {};
+    Object.assign(this._schema, def);
+  }
+  /**
+   * Load a `CoFeed`
+   * @category Subscription & Loading
+   * @deprecated Use `co.feed(...).load` instead.
+   */
+  static load(id, options) {
+    return loadCoValueWithoutMe(this, id, options);
+  }
+  static subscribe(id, ...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToCoValueWithoutMe(this, id, options, listener);
+  }
+};
+_CoFeed.prototype[TypeSym] = "CoStream";
+var CoFeed = _CoFeed;
+var CoFeedJazzApi = class extends CoValueJazzApi {
+  constructor(coFeed, raw) {
+    super(coFeed);
+    this.coFeed = coFeed;
+    this.raw = raw;
+  }
+  /**
+   * The ID of this `CoFeed`
+   * @category Content
+   */
+  get id() {
+    return this.raw.id;
+  }
+  get owner() {
+    return getCoValueOwner(this.coFeed);
+  }
+  /**
+   * Push items to this `CoFeed`
+   *
+   * Items are appended to the current session's log. Each session (tab, device, app instance)
+   * maintains its own append-only log, which is then aggregated into the per-account view.
+   *
+   * @example
+   * ```ts
+   * // Adds items to current session's log
+   * feed.$jazz.push("item1", "item2");
+   *
+   * // View items from current session
+   * console.log(feed.inCurrentSession);
+   *
+   * // View aggregated items from all sessions for current account
+   * console.log(feed.byMe);
+   * ```
+   *
+   * @category Content
+   */
+  push(...items) {
+    for (const item of items) {
+      this.pushItem(item);
+    }
+  }
+  pushItem(item) {
+    const itemDescriptor = this.schema[ItemsSym];
+    if (itemDescriptor === "json") {
+      this.raw.push(item);
+    } else if ("encoded" in itemDescriptor) {
+      this.raw.push(itemDescriptor.encoded.encode(item));
+    } else if (isRefEncoded(itemDescriptor)) {
+      let refId = item.$jazz?.id;
+      if (!refId) {
+        const coValue = instantiateRefEncodedWithInit(
+          itemDescriptor,
+          item,
+          this.owner
+        );
+        refId = coValue.$jazz.id;
+      }
+      this.raw.push(refId);
+    }
+  }
+  /**
+   * Ensure a `CoFeed` is loaded to the specified depth
+   *
+   * @returns A new instance of the same CoFeed that's loaded to the specified depth
+   * @category Subscription & Loading
+   */
+  ensureLoaded(options) {
+    return ensureCoValueLoaded(this.coFeed, options);
+  }
+  subscribe(...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToExistingCoValue(this.coFeed, options, listener);
+  }
+  /**
+   * Wait for the `CoFeed` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForSync(options) {
+    return this.raw.core.waitForSync(options);
+  }
+  /**
+   * Get the descriptor for the items in the `CoFeed`
+   * @internal
+   */
+  getItemsDescriptor() {
+    return this.schema[ItemsSym];
+  }
+  /** @internal */
+  get schema() {
+    return this.coFeed.constructor._schema;
+  }
+};
+function entryFromRawEntry(accessFrom, rawEntry, loadedAs, accountID, itemField) {
+  return {
+    get value() {
+      if (itemField === "json") {
+        return rawEntry.value;
+      } else if ("encoded" in itemField) {
+        return itemField.encoded.decode(rawEntry.value);
+      } else if (isRefEncoded(itemField)) {
+        return accessChildById(
+          accessFrom,
+          rawEntry.value,
+          itemField
+        );
+      } else {
+        throw new Error("Invalid item field schema");
+      }
+    },
+    get ref() {
+      if (itemField !== "json" && isRefEncoded(itemField)) {
+        const rawId = rawEntry.value;
+        return new Ref(
+          rawId,
+          loadedAs,
+          itemField,
+          accessFrom
+        );
+      } else {
+        return void 0;
+      }
+    },
+    get by() {
+      return accountID && accessChildById(accessFrom, accountID, {
+        ref: Account,
+        optional: false
+      });
+    },
+    madeAt: rawEntry.at,
+    tx: rawEntry.tx
+  };
+}
+var CoStreamPerAccountProxyHandler = (innerTarget) => ({
+  get(_target, key, receiver) {
+    if (typeof key === "string" && key.startsWith("co_")) {
+      const rawEntry = innerTarget.$jazz.raw.lastItemBy(key);
+      if (!rawEntry) return;
+      const entry = entryFromRawEntry(
+        receiver,
+        rawEntry,
+        innerTarget.$jazz.loadedAs,
+        key,
+        innerTarget.$jazz.schema[ItemsSym]
+      );
+      Object.defineProperty(entry, "all", {
+        get: () => {
+          const allRawEntries = innerTarget.$jazz.raw.itemsBy(
+            key
+          );
+          return function* () {
+            while (true) {
+              const rawEntry2 = allRawEntries.next();
+              if (rawEntry2.done) return;
+              yield entryFromRawEntry(
+                receiver,
+                rawEntry2.value,
+                innerTarget.$jazz.loadedAs,
+                key,
+                innerTarget.$jazz.schema[ItemsSym]
+              );
+            }
+          }();
+        }
+      });
+      return entry;
+    } else {
+      return Reflect.get(innerTarget, key, receiver);
+    }
+  },
+  ownKeys(_target) {
+    return Array.from(innerTarget.$jazz.raw.accounts());
+  },
+  getOwnPropertyDescriptor(_target, key) {
+    if (typeof key === "string" && key.startsWith("co_")) {
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false
+      };
+    } else {
+      return Reflect.getOwnPropertyDescriptor(innerTarget, key);
+    }
+  }
+});
+var CoStreamPerSessionProxyHandler = (innerTarget, accessFrom) => ({
+  get(_target, key, receiver) {
+    if (typeof key === "string" && key.includes("session")) {
+      const sessionID = key;
+      const rawEntry = innerTarget.$jazz.raw.lastItemIn(sessionID);
+      if (!rawEntry) return;
+      const by = cojsonInternals3.accountOrAgentIDfromSessionID(sessionID);
+      const entry = entryFromRawEntry(
+        accessFrom,
+        rawEntry,
+        innerTarget.$jazz.loadedAs,
+        cojsonInternals3.isAccountID(by) ? by : void 0,
+        innerTarget.$jazz.schema[ItemsSym]
+      );
+      Object.defineProperty(entry, "all", {
+        get: () => {
+          const allRawEntries = innerTarget.$jazz.raw.itemsIn(sessionID);
+          return function* () {
+            while (true) {
+              const rawEntry2 = allRawEntries.next();
+              if (rawEntry2.done) return;
+              yield entryFromRawEntry(
+                accessFrom,
+                rawEntry2.value,
+                innerTarget.$jazz.loadedAs,
+                cojsonInternals3.isAccountID(by) ? by : void 0,
+                innerTarget.$jazz.schema[ItemsSym]
+              );
+            }
+          }();
+        }
+      });
+      return entry;
+    } else {
+      return Reflect.get(innerTarget, key, receiver);
+    }
+  },
+  ownKeys() {
+    return innerTarget.$jazz.raw.sessions();
+  },
+  getOwnPropertyDescriptor(target, key) {
+    if (typeof key === "string" && key.startsWith("co_")) {
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false
+      };
+    } else {
+      return Reflect.getOwnPropertyDescriptor(target, key);
+    }
+  }
+});
+var FileStream = class extends CoValueBase {
+  constructor(options) {
+    super();
+    let raw;
+    if ("fromRaw" in options) {
+      raw = options.fromRaw;
+    } else {
+      const rawOwner = options.owner.$jazz.raw;
+      raw = rawOwner.createBinaryStream();
+    }
+    Object.defineProperties(this, {
+      [TypeSym]: { value: "BinaryCoStream", enumerable: false },
+      $jazz: {
+        value: new FileStreamJazzApi(this, raw),
+        enumerable: false
+      }
+    });
+  }
+  /**
+   * Create a new empty `FileStream` instance.
+   *
+   * @param options - Configuration options for the new FileStream
+   * @param options.owner - The Account or Group that will own this FileStream and control access rights
+   *
+   * @example
+   * ```typescript
+   * // Create owned by an account
+   * const stream = FileStream.create({ owner: myAccount });
+   *
+   * // Create owned by a group
+   * const stream = FileStream.create({ owner: teamGroup });
+   *
+   * // Create with implicit owner
+   * const stream = FileStream.create(myAccount);
+   * ```
+   *
+   * @remarks
+   * For uploading an existing file or blob, use {@link FileStream.createFromBlob} instead.
+   *
+   * @category Creation
+   * @deprecated Use `co.fileStream(...).create` instead.
+   */
+  static create(options) {
+    return new this(parseCoValueCreateOptions(options));
+  }
+  getMetadata() {
+    return this.$jazz.raw.getBinaryStreamInfo();
+  }
+  getChunks(options) {
+    return this.$jazz.raw.getBinaryChunks(options?.allowUnfinished);
+  }
+  isBinaryStreamEnded() {
+    return this.$jazz.raw.isBinaryStreamEnded();
+  }
+  start(options) {
+    this.$jazz.raw.startBinaryStream(options);
+  }
+  push(data) {
+    this.$jazz.raw.pushBinaryStreamChunk(data);
+  }
+  end() {
+    this.$jazz.raw.endBinaryStream();
+  }
+  toBlob(options) {
+    const chunks = this.getChunks({
+      allowUnfinished: options?.allowUnfinished
+    });
+    if (!chunks) {
+      return void 0;
+    }
+    return new Blob(chunks.chunks, { type: chunks.mimeType });
+  }
+  /**
+   * Load a `FileStream` as a `Blob`
+   *
+   * @category Content
+   * @deprecated Use `co.fileStream(...).loadAsBlob` instead.
+   */
+  static async loadAsBlob(id, options) {
+    let stream = await this.load(id, options);
+    return stream?.toBlob({
+      allowUnfinished: options?.allowUnfinished
+    });
+  }
+  static async loadAsBase64(id, options) {
+    const stream = await this.load(id, options);
+    return stream?.asBase64(options);
+  }
+  asBase64(options) {
+    const chunks = this.getChunks(options);
+    if (!chunks) return void 0;
+    const output = [];
+    for (const chunk of chunks.chunks) {
+      for (const byte of chunk) {
+        output.push(String.fromCharCode(byte));
+      }
+    }
+    const base642 = btoa(output.join(""));
+    if (options?.dataURL) {
+      return `data:${chunks.mimeType};base64,${base642}`;
+    }
+    return base642;
+  }
+  /**
+   * Create a `FileStream` from a `Blob` or `File`
+   *
+   * @example
+   * ```ts
+   * import { coField, FileStream } from "jazz-tools";
+   *
+   * const fileStream = await FileStream.createFromBlob(file, {owner: group})
+   * ```
+   * @category Content
+   * @deprecated Use `co.fileStream(...).createFromBlob` instead.
+   */
+  static async createFromBlob(blob, options) {
+    const arrayBuffer = await blob.arrayBuffer();
+    return this.createFromArrayBuffer(
+      arrayBuffer,
+      blob.type,
+      blob instanceof File ? blob.name : void 0,
+      options
+    );
+  }
+  /**
+   * Create a `FileStream` from a `Blob` or `File`
+   *
+   * @example
+   * ```ts
+   * import { coField, FileStream } from "jazz-tools";
+   *
+   * const fileStream = await FileStream.createFromBlob(file, {owner: group})
+   * ```
+   * @category Content
+   * @deprecated Use `co.fileStream(...).createFromArrayBuffer` instead.
+   */
+  static async createFromArrayBuffer(arrayBuffer, mimeType, fileName, options) {
+    const stream = this.create(options);
+    const onProgress = options && "onProgress" in options ? options.onProgress : void 0;
+    const start = Date.now();
+    const data = new Uint8Array(arrayBuffer);
+    stream.start({
+      mimeType,
+      totalSizeBytes: arrayBuffer.byteLength,
+      fileName
+    });
+    const chunkSize = cojsonInternals3.TRANSACTION_CONFIG.MAX_RECOMMENDED_TX_SIZE;
+    let lastProgressUpdate = Date.now();
+    for (let idx = 0; idx < data.length; idx += chunkSize) {
+      stream.push(data.slice(idx, idx + chunkSize));
+      if (Date.now() - lastProgressUpdate > 100) {
+        onProgress?.(idx / data.length);
+        lastProgressUpdate = Date.now();
+      }
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+    stream.end();
+    const end = Date.now();
+    console.debug(
+      "Finished creating binary stream in",
+      (end - start) / 1e3,
+      "s - Throughput in MB/s",
+      1e3 * (arrayBuffer.byteLength / (end - start)) / (1024 * 1024)
+    );
+    onProgress?.(1);
+    return stream;
+  }
+  /**
+   * Get a JSON representation of the `FileStream`
+   * @category Content
+   */
+  toJSON() {
+    return {
+      ...this.getChunks()
+    };
+  }
+  /** @internal */
+  [inspect2]() {
+    return this.toJSON();
+  }
+  /**
+   * Load a `FileStream`
+   * @category Subscription & Loading
+   * @deprecated Use `co.fileStream(...).load` instead.
+   */
+  static async load(id, options) {
+    const stream = await loadCoValueWithoutMe(this, id, options);
+    if (!options?.allowUnfinished && !stream?.isBinaryStreamEnded()) {
+      return new Promise((resolve) => {
+        subscribeToCoValueWithoutMe(
+          this,
+          id,
+          options || {},
+          (value, unsubscribe) => {
+            if (value.isBinaryStreamEnded()) {
+              unsubscribe();
+              resolve(value);
+            }
+          }
+        );
+      });
+    }
+    return stream;
+  }
+  static subscribe(id, ...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToCoValueWithoutMe(this, id, options, listener);
+  }
+};
+var FileStreamJazzApi = class extends CoValueJazzApi {
+  constructor(fileStream, raw) {
+    super(fileStream);
+    this.fileStream = fileStream;
+    this.raw = raw;
+  }
+  /**
+   * The ID of this `FileStream`
+   * @category Content
+   */
+  get id() {
+    return this.raw.id;
+  }
+  get owner() {
+    return getCoValueOwner(this.fileStream);
+  }
+  /**
+   * An instance method to subscribe to an existing `FileStream`
+   * @category Subscription & Loading
+   */
+  subscribe(listener) {
+    return subscribeToExistingCoValue(this.fileStream, {}, listener);
+  }
+  /**
+   * Wait for the `FileStream` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForSync(options) {
+    return this.raw.core.waitForSync(options);
+  }
+};
+
+// src/tools/coValues/account.ts
+import {
+  ControlledAccount as RawControlledAccount,
+  LocalNode as LocalNode2,
+  cojsonInternals as cojsonInternals4
+} from "cojson";
+var Account = class extends CoValueBase {
+  constructor(options) {
+    super();
+    if (!("fromRaw" in options)) {
+      throw new Error("Can only construct account from raw or with .create()");
+    }
+    const proxy = new Proxy(
+      this,
+      AccountAndGroupProxyHandler
+    );
+    Object.defineProperties(this, {
+      [TypeSym]: { value: "Account", enumerable: false },
+      $jazz: {
+        value: new AccountJazzApi(proxy, options.fromRaw),
+        enumerable: false
+      }
+    });
+    return proxy;
+  }
+  /**
+   * Whether this account is the currently active account.
+   */
+  get isMe() {
+    return activeAccountContext.get().$jazz.id === this.$jazz.id;
+  }
+  /**
+   * Accept an invite to a `CoValue` or `Group`.
+   *
+   * @param valueID The ID of the `CoValue` or `Group` to accept the invite to.
+   * @param inviteSecret The secret of the invite to accept.
+   * @param coValueClass The class of the `CoValue` or `Group` to accept the invite to.
+   * @returns The loaded `CoValue` or `Group`.
+   */
+  async acceptInvite(valueID, inviteSecret, coValueClass) {
+    if (!this.$jazz.isLocalNodeOwner) {
+      throw new Error("Only a controlled account can accept invites");
+    }
+    await this.$jazz.localNode.acceptInvite(
+      valueID,
+      inviteSecret
+    );
+    return loadCoValue(
+      coValueClassFromCoValueClassOrSchema(coValueClass),
+      valueID,
+      {
+        loadAs: this
+      }
+    );
+  }
+  getRoleOf(member) {
+    if (member === "me") {
+      return this.isMe ? "admin" : void 0;
+    }
+    if (member === this.$jazz.id) {
+      return "admin";
+    }
+    return void 0;
+  }
+  canRead(value) {
+    const valueOwner = value.$jazz.owner;
+    if (!valueOwner) {
+      return true;
+    }
+    const role = valueOwner.getRoleOf(this.$jazz.id);
+    return role === "admin" || role === "writer" || role === "reader" || role === "writeOnly";
+  }
+  canWrite(value) {
+    const valueOwner = value.$jazz.owner;
+    if (!valueOwner) {
+      if (value[TypeSym] === "Group") {
+        const roleInGroup = value.getRoleOf(this.$jazz.id);
+        return roleInGroup === "admin" || roleInGroup === "writer";
+      }
+      if (value[TypeSym] === "Account") {
+        return value.$jazz.id === this.$jazz.id;
+      }
+      return false;
+    }
+    const role = valueOwner.getRoleOf(this.$jazz.id);
+    return role === "admin" || role === "writer" || role === "writeOnly";
+  }
+  canAdmin(value) {
+    const valueOwner = value.$jazz.owner;
+    if (!valueOwner) {
+      if (value[TypeSym] === "Group") {
+        const roleInGroup = value.getRoleOf(this.$jazz.id);
+        return roleInGroup === "admin";
+      }
+      if (value[TypeSym] === "Account") {
+        return value.$jazz.id === this.$jazz.id;
+      }
+      return false;
+    }
+    return valueOwner.getRoleOf(this.$jazz.id) === "admin";
+  }
+  /** @private */
+  static async create(options) {
+    const { node } = await LocalNode2.withNewlyCreatedAccount({
+      ...options,
+      migration: async (rawAccount, _node, creationProps) => {
+        const account = new this({
+          fromRaw: rawAccount
+        });
+        await account.applyMigration?.(creationProps);
+      }
+    });
+    return this.fromNode(node);
+  }
+  static getMe() {
+    return activeAccountContext.get();
+  }
+  /**
+   * @deprecated Use `co.account(...).createAs` instead.
+   */
+  static async createAs(as, options) {
+    const connectedPeers = cojsonInternals4.connectedPeers(
+      "creatingAccount",
+      "createdAccount",
+      { peer1role: "server", peer2role: "client" }
+    );
+    as.$jazz.localNode.syncManager.addPeer(connectedPeers[1]);
+    const account = await this.create({
+      creationProps: options.creationProps,
+      crypto: as.$jazz.localNode.crypto,
+      peersToLoadFrom: [connectedPeers[0]]
+    });
+    await account.$jazz.waitForAllCoValuesSync();
+    return account;
+  }
+  static fromNode(node) {
+    return new this({
+      fromRaw: node.expectCurrentAccount("jazz-tools/Account.fromNode")
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  toJSON() {
+    return {};
+  }
+  [inspect2]() {
+    return this.toJSON();
+  }
+  async applyMigration(creationProps) {
+    await this.migrate(creationProps);
+    if (this.profile === void 0 && creationProps) {
+      const profileGroup = RegisteredSchemas["Group"].create({ owner: this });
+      this.$jazz.set(
+        "profile",
+        Profile.create({ name: creationProps.name }, profileGroup)
+      );
+      profileGroup.addMember("everyone", "reader");
+    }
+    const profile = this.$jazz.localNode.expectCoValueLoaded(this.$jazz.raw.get("profile")).getCurrentContent();
+    if (!profile.get("inbox")) {
+      const inboxRoot = createInboxRoot(this);
+      profile.set("inbox", inboxRoot.id);
+      profile.set("inboxInvite", inboxRoot.inviteLink);
+    }
+  }
+  // Placeholder method for subclasses to override
+  migrate(creationProps) {
+    creationProps;
+  }
+  /**
+   * Load an `Account`
+   * @category Subscription & Loading
+   * @deprecated Use `co.account(...).load` instead.
+   */
+  static load(id, options) {
+    return loadCoValueWithoutMe(this, id, options);
+  }
+  static subscribe(id, ...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToCoValueWithoutMe(this, id, options, listener);
+  }
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+Account._schema = {
+  profile: {
+    ref: () => Profile,
+    optional: false
+  },
+  root: {
+    ref: () => RegisteredSchemas["CoMap"],
+    optional: true
+  }
+};
+var AccountJazzApi = class extends CoValueJazzApi {
+  constructor(account, raw) {
+    super(account);
+    this.account = account;
+    this.raw = raw;
+    this.isLocalNodeOwner = this.raw.id === this.localNode.getCurrentAgent().id;
+    if (this.isLocalNodeOwner) {
+      this.sessionID = this.localNode.currentSessionID;
+    }
+  }
+  /**
+   * The ID of this `Account`
+   * @category Content
+   */
+  get id() {
+    return this.raw.id;
+  }
+  /**
+   * Accounts have no owner. They can be accessed by everyone.
+   */
+  get owner() {
+    return void 0;
+  }
+  /**
+   * Set the value of a key in the account.
+   *
+   * @param key The key to set.
+   * @param value The value to set.
+   *
+   * @category Content
+   */
+  set(key, value) {
+    if (value) {
+      let refId = value.$jazz?.id;
+      if (!refId) {
+        const descriptor = this.schema[key];
+        const coValue = instantiateRefEncodedWithInit(
+          descriptor,
+          value,
+          accountOrGroupToGroup(this.account)
+        );
+        refId = coValue.$jazz.id;
+      }
+      this.raw.set(key, refId, "trusting");
+    }
+  }
+  /**
+   * Get the descriptor for a given key
+   * @internal
+   */
+  getDescriptor(key) {
+    if (key === "profile") {
+      return this.schema.profile;
+    } else if (key === "root") {
+      return this.schema.root;
+    }
+    return void 0;
+  }
+  /**
+   * If property `prop` is a `coField.ref(...)`, you can use `account.$jazz.refs.prop` to access
+   * the `Ref` instead of the potentially loaded/null value.
+   *
+   * This allows you to always get the ID or load the value manually.
+   *
+   * @category Content
+   */
+  get refs() {
+    const profileID = this.raw.get("profile");
+    const rootID = this.raw.get("root");
+    return {
+      profile: profileID ? new Ref(
+        profileID,
+        this.loadedAs,
+        this.schema.profile,
+        this.account
+      ) : void 0,
+      root: rootID ? new Ref(
+        rootID,
+        this.loadedAs,
+        this.schema.root,
+        this.account
+      ) : void 0
+    };
+  }
+  /** @category Subscription & Loading */
+  ensureLoaded(options) {
+    return ensureCoValueLoaded(this.account, options);
+  }
+  subscribe(...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToExistingCoValue(this.account, options, listener);
+  }
+  /**
+   * Wait for the `Account` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForSync(options) {
+    return this.raw.core.waitForSync(options);
+  }
+  /**
+   * Wait for all the available `CoValues` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForAllCoValuesSync(options) {
+    return this.localNode.syncManager.waitForAllCoValuesSync(options?.timeout);
+  }
+  /** @internal */
+  get schema() {
+    return this.account.constructor._schema;
+  }
+  get loadedAs() {
+    if (this.isLocalNodeOwner) return this.account;
+    const agent = this.localNode.getCurrentAgent();
+    if (agent instanceof RawControlledAccount) {
+      return coValuesCache.get(
+        agent.account,
+        () => Account.fromRaw(agent.account)
+      );
+    }
+    return new AnonymousJazzAgent2(this.localNode);
+  }
+};
+var AccountAndGroupProxyHandler = {
+  get(target, key, receiver) {
+    if (key === "profile" || key === "root") {
+      const id = target.$jazz.raw.get(key);
+      if (id) {
+        return accessChildByKey(target, id, key);
+      } else {
+        return void 0;
+      }
+    } else {
+      return Reflect.get(target, key, receiver);
+    }
+  },
+  set(target, key, value, receiver) {
+    if (target instanceof Account && (key === "profile" || key === "root") && typeof value === "object" && SchemaInit in value) {
+      target.constructor._schema ||= {};
+      target.constructor._schema[key] = value[SchemaInit];
+      return true;
+    } else if (target instanceof Account && (key === "profile" || key === "root")) {
+      if (value) {
+        target.$jazz.set(key, value);
+      }
+      return true;
+    } else {
+      return Reflect.set(target, key, value, receiver);
+    }
+  },
+  defineProperty(target, key, descriptor) {
+    if ((key === "profile" || key === "root") && typeof descriptor.value === "object" && SchemaInit in descriptor.value) {
+      target.constructor._schema ||= {};
+      target.constructor._schema[key] = descriptor.value[SchemaInit];
+      return true;
+    } else {
+      return Reflect.defineProperty(target, key, descriptor);
+    }
+  }
+};
+function isControlledAccount(account) {
+  return account.$jazz.isLocalNodeOwner;
+}
+RegisteredSchemas["Account"] = Account;
+
+// src/tools/coValues/group.ts
+var _Group = class _Group extends CoValueBase {
+  /** @deprecated Don't use constructor directly, use .create */
+  constructor(options) {
+    super();
+    let raw;
+    if (options && "fromRaw" in options) {
+      raw = options.fromRaw;
+    } else {
+      const initOwner = options.owner;
+      if (!initOwner) throw new Error("No owner provided");
+      if (initOwner[TypeSym] === "Account" && isControlledAccount(initOwner)) {
+        const rawOwner = initOwner.$jazz.raw;
+        raw = rawOwner.core.node.createGroup();
+      } else {
+        throw new Error("Can only construct group as a controlled account");
+      }
+    }
+    const proxy = new Proxy(
+      this,
+      AccountAndGroupProxyHandler
+    );
+    Object.defineProperties(this, {
+      $jazz: {
+        value: new GroupJazzApi(proxy, raw),
+        enumerable: false
+      }
+    });
+    return proxy;
+  }
+  static create(options) {
+    return new this(parseGroupCreateOptions(options));
+  }
+  myRole() {
+    return this.$jazz.raw.myRole();
+  }
+  addMember(member, role) {
+    if (member !== "everyone" && member[TypeSym] === "Group") {
+      if (role === "writeOnly")
+        throw new Error("Cannot add group as member with write-only role");
+      this.$jazz.raw.extend(member.$jazz.raw, role);
+    } else if (role !== void 0 && role !== "inherit") {
+      this.$jazz.raw.addMember(
+        member === "everyone" ? member : member.$jazz.raw,
+        role
+      );
+    }
+  }
+  removeMember(member) {
+    if (member !== "everyone" && member[TypeSym] === "Group") {
+      this.$jazz.raw.revokeExtend(member.$jazz.raw);
+    } else {
+      return this.$jazz.raw.removeMember(
+        member === "everyone" ? member : member.$jazz.raw
+      );
+    }
+  }
+  getMembersFromKeys(accountIDs) {
+    const members = [];
+    const refEncodedAccountSchema = {
+      ref: () => Account,
+      optional: false
+    };
+    for (const accountID of accountIDs) {
+      if (!isAccountID(accountID)) continue;
+      const role = this.$jazz.raw.roleOf(accountID);
+      if (role === "admin" || role === "writer" || role === "reader" || role === "writeOnly") {
+        const ref2 = new Ref(
+          accountID,
+          this.$jazz.loadedAs,
+          refEncodedAccountSchema,
+          this
+        );
+        const group = this;
+        members.push({
+          id: accountID,
+          role,
+          ref: ref2,
+          get account() {
+            return accessChildById(group, accountID, refEncodedAccountSchema);
+          }
+        });
+      }
+    }
+    return members;
+  }
+  /**
+   * Returns all members of the group, including inherited members from parent
+   * groups.
+   *
+   * If you need only the direct members of the group, use
+   * {@link getDirectMembers} instead.
+   *
+   * @returns The members of the group.
+   */
+  get members() {
+    return this.getMembersFromKeys(this.$jazz.raw.getAllMemberKeysSet());
+  }
+  /**
+   * Returns the direct members of the group.
+   *
+   * If you need all members of the group, including inherited members from
+   * parent groups, use {@link Group.members|members} instead.
+   * @returns The direct members of the group.
+   */
+  getDirectMembers() {
+    return this.getMembersFromKeys(this.$jazz.raw.getMemberKeys());
+  }
+  getRoleOf(member) {
+    const accountId = member === "me" ? activeAccountContext.get().$jazz.id : member === "everyone" ? member : member;
+    return this.$jazz.raw.roleOf(accountId);
+  }
+  /**
+   * Make the group public, so that everyone can read it.
+   * Alias for `addMember("everyone", role)`.
+   *
+   * @param role - Optional: the role to grant to everyone. Defaults to "reader".
+   * @returns The group itself.
+   */
+  makePublic(role = "reader") {
+    this.addMember("everyone", role);
+    return this;
+  }
+  getParentGroups() {
+    return this.$jazz.raw.getParentGroups().map((group) => _Group.fromRaw(group));
+  }
+  /** @category Identity & Permissions
+   * Gives members of a parent group membership in this group.
+   * @deprecated Use `addMember` instead.
+   * @param parent The group that will gain access to this group.
+   * @param roleMapping The role all members of the parent group should have in this group.
+   * @returns This group.
+   */
+  extend(parent, roleMapping) {
+    this.$jazz.raw.extend(parent.$jazz.raw, roleMapping);
+    return this;
+  }
+  /** @category Identity & Permissions
+   * Revokes membership from members a parent group.
+   * @deprecated Use `removeMember` instead.
+   * @param parent The group that will lose access to this group.
+   * @returns This group.
+   */
+  async revokeExtend(parent) {
+    await this.$jazz.raw.revokeExtend(parent.$jazz.raw);
+    return this;
+  }
+  /** @category Subscription & Loading */
+  static load(id, options) {
+    return loadCoValueWithoutMe(this, id, options);
+  }
+  static subscribe(id, ...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToCoValueWithoutMe(this, id, options, listener);
+  }
+};
+_Group.prototype[TypeSym] = "Group";
+var Group6 = _Group;
+var GroupJazzApi = class extends CoValueJazzApi {
+  constructor(group, raw) {
+    super(group);
+    this.group = group;
+    this.raw = raw;
+  }
+  /**
+   * The ID of this `Group`
+   * @category Content
+   */
+  get id() {
+    return this.raw.id;
+  }
+  /**
+   * Groups have no owner. They can be accessed by everyone.
+   */
+  get owner() {
+    return void 0;
+  }
+  /** @category Subscription & Loading */
+  ensureLoaded(options) {
+    return ensureCoValueLoaded(this.group, options);
+  }
+  subscribe(...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToExistingCoValue(this.group, options, listener);
+  }
+  /**
+   * Wait for the `Group` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForSync(options) {
+    return this.raw.core.waitForSync(options);
+  }
+};
+RegisteredSchemas["Group"] = Group6;
+function isAccountID(id) {
+  return id.startsWith("co_");
+}
+function getCoValueOwner(coValue) {
+  const group = accessChildById(coValue, coValue.$jazz.raw.group.id, {
+    ref: RegisteredSchemas["Group"],
+    optional: false
+  });
+  if (!group) {
+    throw new Error("CoValue has no owner");
+  }
+  return group;
+}
+
+// src/tools/coValues/profile.ts
+var Profile = class extends CoMap {
+  constructor() {
+    super(...arguments);
+    this.name = coField.string;
+    this.inbox = coField.optional.string;
+    this.inboxInvite = coField.optional.string;
+  }
+  /**
+   * Creates a new profile with the given initial values and owner.
+   *
+   * The owner (a Group) determines access rights to the Profile.
+   *
+   * @category Creation
+   * @deprecated Use `co.profile(...).create` instead.
+   */
+  static create(init, options) {
+    const owner = options !== void 0 && "owner" in options ? options.owner : options;
+    if (owner?.[TypeSym] === "Account") {
+      throw new Error("Profiles should be owned by a group");
+    }
+    return super.create(init, options);
+  }
+};
+
+// src/tools/coValues/inbox.ts
+import { RawAccount as RawAccount2 } from "cojson";
+function createInboxRoot(account) {
+  if (!account.$jazz.isLocalNodeOwner) {
+    throw new Error("Account is not controlled");
+  }
+  const rawAccount = account.$jazz.raw;
+  const group = rawAccount.core.node.createGroup();
+  const messagesFeed = group.createStream();
+  const inboxRoot = rawAccount.createMap();
+  const processedFeed = rawAccount.createStream();
+  const failedFeed = rawAccount.createStream();
+  const inviteLink = `${messagesFeed.id}/${group.createInvite("writeOnly")}`;
+  inboxRoot.set("messages", messagesFeed.id);
+  inboxRoot.set("processed", processedFeed.id);
+  inboxRoot.set("failed", failedFeed.id);
+  return {
+    id: inboxRoot.id,
+    inviteLink
+  };
+}
+
+// src/tools/coValues/coPlainText.ts
+import { stringifyOpID } from "cojson";
+import { calcPatch as calcPatch2 } from "fast-myers-diff";
+var CoPlainText = class extends String {
+  /** @internal */
+  constructor(options) {
+    if (!options) {
+      super("");
+      return;
+    }
+    if ("fromRaw" in options) {
+      super(options.fromRaw.toString());
+      const raw = options.fromRaw;
+      Object.defineProperties(this, {
+        [TypeSym]: { value: "CoPlainText", enumerable: false },
+        $jazz: {
+          value: new CoTextJazzApi(this, raw),
+          enumerable: false
+        }
+      });
+      return;
+    }
+    if ("text" in options && "owner" in options) {
+      super(options.text);
+      const raw = options.owner.$jazz.raw.createPlainText(options.text);
+      Object.defineProperties(this, {
+        [TypeSym]: { value: "CoPlainText", enumerable: false },
+        $jazz: {
+          value: new CoTextJazzApi(this, raw),
+          enumerable: false
+        }
+      });
+      return;
+    }
+    throw new Error("Invalid constructor arguments");
+  }
+  /**
+   * Create a new `CoPlainText` with the given text and owner.
+   *
+   * The owner (a Group or Account) determines access rights to the CoPlainText.
+   *
+   * The CoPlainText will immediately be persisted and synced to connected peers.
+   *
+   * @example
+   * ```ts
+   * const text = CoPlainText.create("Hello, world!", { owner: me });
+   * ```
+   *
+   * @category Creation
+   * @deprecated Use `co.plainText(...).create` instead.
+   */
+  static create(text, options) {
+    const { owner } = parseCoValueCreateOptions(options);
+    return new this({ text, owner });
+  }
+  get length() {
+    return this.$jazz.raw.toString().length;
+  }
+  toString() {
+    return this.$jazz.raw.toString();
+  }
+  valueOf() {
+    return this.$jazz.raw.toString();
+  }
+  toJSON() {
+    return this.$jazz.raw.toString();
+  }
+  [inspect2]() {
+    return this.toJSON();
+  }
+  insertBefore(idx, text) {
+    this.$jazz.raw.insertBefore(idx, text);
+  }
+  insertAfter(idx, text) {
+    this.$jazz.raw.insertAfter(idx, text);
+  }
+  deleteRange(range) {
+    this.$jazz.raw.deleteRange(range);
+  }
+  posBefore(idx) {
+    return this.$jazz.raw.mapping.opIDbeforeIdx[idx];
+  }
+  posAfter(idx) {
+    return this.$jazz.raw.mapping.opIDafterIdx[idx];
+  }
+  idxBefore(pos) {
+    return this.$jazz.raw.mapping.idxBeforeOpID[stringifyOpID(pos)];
+  }
+  idxAfter(pos) {
+    return this.$jazz.raw.mapping.idxAfterOpID[stringifyOpID(pos)];
+  }
+  /** @category Internals */
+  static fromRaw(raw) {
+    return new this({ fromRaw: raw });
+  }
+  /**
+   * Load a `CoPlainText` with a given ID, as a given account.
+   *
+   * @category Subscription & Loading
+   * @deprecated Use `co.plainText(...).load` instead.
+   */
+  static load(id, options) {
+    return loadCoValueWithoutMe(this, id, options);
+  }
+  static subscribe(id, ...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToCoValueWithoutMe(this, id, options, listener);
+  }
+  /**
+   * Allow CoPlainText to behave like a primitive string in most contexts (e.g.,
+   * string concatenation, template literals, React rendering, etc.) by implementing
+   * Symbol.toPrimitive. This eliminates the need to call .toString() explicitly.
+   *
+   * The 'hint' parameter indicates the preferred type of conversion:
+   * - 'string': prefer string conversion
+   * - 'number': prefer number conversion (attempt to parse the text as a number)
+   * - 'default': usually treat as string
+   */
+  [Symbol.toPrimitive](hint) {
+    if (hint === "number") {
+      return Number(this.$jazz.raw.toString());
+    }
+    return this.$jazz.raw.toString();
+  }
+};
+var CoTextJazzApi = class extends CoValueJazzApi {
+  constructor(coText, raw) {
+    super(coText);
+    this.coText = coText;
+    this.raw = raw;
+  }
+  get id() {
+    return this.raw.id;
+  }
+  get owner() {
+    return getCoValueOwner(this.coText);
+  }
+  /**
+   * Apply text, modifying the text in place. Calculates the diff and applies it to the CoValue.
+   *
+   * @category Mutation
+   */
+  applyDiff(other) {
+    const current = this.raw.toString();
+    const currentGraphemes = this.raw.toGraphemes(current);
+    const otherGraphemes = this.raw.toGraphemes(other);
+    const patches = [...calcPatch2(currentGraphemes, otherGraphemes)];
+    for (const [from, to, insert] of patches.reverse()) {
+      if (to > from) {
+        this.coText.deleteRange({ from, to });
+      }
+      if (insert.length > 0) {
+        this.coText.insertBefore(from, this.raw.fromGraphemes(insert));
+      }
+    }
+  }
+  /**
+   * Given an already loaded `CoPlainText`, subscribe to updates to the `CoPlainText` and ensure that the specified fields are loaded to the specified depth.
+   *
+   * Works like `CoPlainText.subscribe()`, but you don't need to pass the ID or the account to load as again.
+   *
+   * Returns an unsubscribe function that you should call when you no longer need updates.
+   *
+   * @category Subscription & Loading
+   **/
+  subscribe(listener) {
+    return subscribeToExistingCoValue(this.coText, {}, listener);
+  }
+};
+
+// src/tools/coValues/coRichText.ts
+var CoRichText = class extends CoPlainText {
+};
+
+// src/tools/coValues/schemaUnion.ts
+var SchemaUnion = class _SchemaUnion extends CoValueBase {
+  /**
+   * Create a new union type from a discriminator function.
+   *
+   * The discriminator function receives the raw data and should return the appropriate concrete class to use for that data.
+   *
+   * When loading a SchemaUnion, the correct subclass will be instantiated based on the discriminator.
+   *
+   * @param discriminator - Function that determines which concrete type to use
+   * @returns A new class that can create/load instances of the union type
+   *
+   * @example
+   * ```ts
+   * const WidgetUnion = SchemaUnion.Of<BaseWidget>((raw) => {
+   *   switch (raw.get("type")) {
+   *     case "button": return ButtonWidget;
+   *     case "slider": return SliderWidget;
+   *     default: throw new Error("Unknown widget type");
+   *   }
+   * });
+   *
+   * const widget = await loadCoValue(WidgetUnion, id, me, {});
+   *
+   * // You can narrow the returned instance to a subclass by using `instanceof`
+   * if (widget instanceof ButtonWidget) {
+   *   console.log(widget.label);
+   * } else if (widget instanceof SliderWidget) {
+   *   console.log(widget.min, widget.max);
+   * }
+   * ```
+   *
+   * @category Declaration
+   **/
+  static Of(discriminator) {
+    return class SchemaUnionClass extends _SchemaUnion {
+      static create(init, owner) {
+        const ResolvedClass = discriminator(new Map(Object.entries(init)));
+        return ResolvedClass.create(init, owner);
+      }
+      static fromRaw(raw) {
+        const ResolvedClass = discriminator(
+          raw
+        );
+        return ResolvedClass.fromRaw(raw);
+      }
+    };
+  }
+  static create(init, owner) {
+    throw new Error("Not implemented");
+  }
+  /**
+   * Create an instance from raw data. This is called internally and should not be used directly.
+   * Use {@link SchemaUnion.Of} to create a union type instead.
+   *
+   * @internal
+   */
+  static fromRaw(raw) {
+    throw new Error("Not implemented");
+  }
+  /**
+   * Load a `SchemaUnion` with a given ID, as a given account.
+   *
+   * Note: The `resolve` option is not supported for `SchemaUnion`s due to https://github.com/garden-co/jazz/issues/2639
+   *
+   * @category Subscription & Loading
+   */
+  static load(id, options) {
+    return loadCoValueWithoutMe(this, id, options);
+  }
+  static subscribe(id, ...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToCoValueWithoutMe(this, id, options, listener);
+  }
+};
+
+// src/tools/implementation/anonymousJazzAgent.ts
+var _a;
+_a = TypeSym;
+var AnonymousJazzAgent2 = class {
+  constructor(node) {
+    this.node = node;
+    this[_a] = "Anonymous";
+  }
+};
+
+// src/tools/implementation/activeAccountContext.ts
+var ActiveAccountContext = class {
+  constructor() {
+    this.activeAccount = null;
+    this.guestMode = false;
+  }
+  set(account) {
+    this.activeAccount = account;
+    this.guestMode = false;
+  }
+  setGuestMode() {
+    this.activeAccount = null;
+    this.guestMode = true;
+  }
+  maybeGet() {
+    return this.activeAccount;
+  }
+  get() {
+    if (!this.activeAccount) {
+      if (this.guestMode) {
+        throw new Error(
+          "Something that expects a full active account was called in guest mode."
+        );
+      }
+      throw new Error("No active account");
+    }
+    return this.activeAccount;
+  }
+};
+var activeAccountContext = new ActiveAccountContext();
+
+// src/tools/implementation/refs.ts
+var Ref = class {
+  constructor(id, controlledAccount, schema, parent) {
+    this.id = id;
+    this.controlledAccount = controlledAccount;
+    this.schema = schema;
+    this.parent = parent;
+    if (!isRefEncoded(schema)) {
+      throw new Error("Ref must be constructed with a ref schema");
+    }
+  }
+  async load() {
+    const subscriptionScope = getSubscriptionScope(this.parent);
+    subscriptionScope.subscribeToId(this.id, this.schema);
+    const node = subscriptionScope.childNodes.get(this.id);
+    if (!node) {
+      return null;
+    }
+    const value = node.value;
+    if (value?.type === "loaded") {
+      return value.value;
+    } else {
+      return new Promise((resolve) => {
+        const unsubscribe = node.subscribe((value2) => {
+          if (value2?.type === "loaded") {
+            unsubscribe();
+            resolve(value2.value);
+          } else if (value2?.type === "unavailable") {
+            unsubscribe();
+            resolve(null);
+          } else if (value2?.type === "unauthorized") {
+            unsubscribe();
+            resolve(null);
+          }
+        });
+      });
+    }
+  }
+  get value() {
+    return accessChildById(this.parent, this.id, this.schema);
+  }
+};
+function makeRefs(parent, getIdForKey, getKeysWithIds, controlledAccount, refSchemaForKey) {
+  const refs = {};
+  return new Proxy(refs, {
+    get(_target, key) {
+      if (key === Symbol.iterator) {
+        return function* () {
+          for (const key2 of getKeysWithIds()) {
+            yield new Ref(
+              getIdForKey(key2),
+              controlledAccount,
+              refSchemaForKey(key2),
+              parent
+            );
+          }
+        };
+      }
+      if (typeof key === "symbol") return void 0;
+      if (key === "length") {
+        return getKeysWithIds().length;
+      }
+      const id = getIdForKey(key);
+      if (!id) return void 0;
+      return new Ref(
+        id,
+        controlledAccount,
+        refSchemaForKey(key),
+        parent
+      );
+    },
+    ownKeys() {
+      return getKeysWithIds().map((key) => key.toString());
+    },
+    getOwnPropertyDescriptor(target, key) {
+      const id = getIdForKey(key);
+      if (id) {
+        return {
+          enumerable: true,
+          configurable: true,
+          writable: true
+        };
+      } else {
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      }
+    }
+  });
+}
+
+// src/tools/implementation/schema.ts
+var Encoders = {
+  Date: {
+    encode: (value) => value.toISOString(),
+    decode: (value) => new Date(value)
+  },
+  OptionalDate: {
+    encode: (value) => value?.toISOString() || null,
+    decode: (value) => value === null ? void 0 : new Date(value)
+  }
+};
+var optional = {
+  ref: optionalRef,
+  json() {
+    return { [SchemaInit]: "json" };
+  },
+  encoded(arg) {
+    return { [SchemaInit]: { encoded: arg } };
+  },
+  string: {
+    [SchemaInit]: "json"
+  },
+  number: {
+    [SchemaInit]: "json"
+  },
+  boolean: {
+    [SchemaInit]: "json"
+  },
+  null: {
+    [SchemaInit]: "json"
+  },
+  Date: {
+    [SchemaInit]: { encoded: Encoders.OptionalDate }
+  },
+  literal(..._lit) {
+    return { [SchemaInit]: "json" };
+  }
+};
+var coField = {
+  string: {
+    [SchemaInit]: "json"
+  },
+  number: {
+    [SchemaInit]: "json"
+  },
+  boolean: {
+    [SchemaInit]: "json"
+  },
+  null: {
+    [SchemaInit]: "json"
+  },
+  Date: {
+    [SchemaInit]: { encoded: Encoders.Date }
+  },
+  literal(..._lit) {
+    return { [SchemaInit]: "json" };
+  },
+  json() {
+    return { [SchemaInit]: "json" };
+  },
+  encoded(arg) {
+    return { [SchemaInit]: { encoded: arg } };
+  },
+  ref,
+  items: ItemsSym,
+  optional
+};
+function optionalRef(arg) {
+  return ref(arg, { optional: true });
+}
+function ref(arg, options) {
+  return {
+    [SchemaInit]: {
+      ref: arg,
+      optional: options?.optional || false
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  };
+}
+function isRefEncoded(schema) {
+  return typeof schema === "object" && "ref" in schema && "optional" in schema && typeof schema.ref === "function";
+}
+function instantiateRefEncodedFromRaw(schema, raw) {
+  return isCoValueClass(schema.ref) ? schema.ref.fromRaw(raw) : schema.ref(
+    raw
+  ).fromRaw(raw);
+}
+function instantiateRefEncodedWithInit(schema, init, parentOwner) {
+  if (!isCoValueClass(schema.ref)) {
+    throw Error(
+      `Cannot automatically create CoValue from value: ${JSON.stringify(init)}. Use the CoValue schema's create() method instead.`
+    );
+  }
+  const node = parentOwner.$jazz.localNode;
+  const rawGroup = node.createGroup();
+  const owner = new Group6({ fromRaw: rawGroup });
+  owner.addMember(parentOwner);
+  return schema.ref.create(init, owner);
+}
+
+// src/tools/lib/migration.ts
+function applyCoValueMigrations(instance) {
+  const node = instance.$jazz.raw.core.node;
+  const migratedCoValues = node._migratedCoValues ??= /* @__PURE__ */ new Set();
+  if ("migrate" in instance && typeof instance.migrate === "function" && instance[TypeSym] !== "Account" && !migratedCoValues.has(instance.$jazz.id)) {
+    migratedCoValues.add(instance.$jazz.id);
+    const result = instance.migrate?.(instance);
+    if (result && "then" in result) {
+      throw new Error("Migration function cannot be async");
+    }
+  }
+}
+
+// src/tools/subscribe/CoValueCoreSubscription.ts
+var CoValueCoreSubscription = class {
+  constructor(node, id, listener, skipRetry) {
+    this.node = node;
+    this.id = id;
+    this.listener = listener;
+    this.skipRetry = skipRetry;
+    this._unsubscribe = () => {
+    };
+    this.unsubscribed = false;
+    const entry = this.node.getCoValue(this.id);
+    if (entry?.isAvailable()) {
+      this.subscribe(entry.getCurrentContent());
+    } else {
+      this.node.loadCoValueCore(this.id, void 0, skipRetry).then((value) => {
+        if (this.unsubscribed) return;
+        if (value.isAvailable()) {
+          this.subscribe(value.getCurrentContent());
+        } else {
+          this.subscribeToState();
+          this.listener("unavailable");
+        }
+      }).catch((error) => {
+        console.error("Unexpected error loading CoValue: ", error);
+        this.listener("unavailable");
+      });
+    }
+  }
+  subscribeToState() {
+    const entry = this.node.getCoValue(this.id);
+    const handleStateChange = (core2, unsubFromStateChange2) => {
+      if (this.unsubscribed) {
+        unsubFromStateChange2();
+        return;
+      }
+      if (core2.isAvailable()) {
+        this.subscribe(core2.getCurrentContent());
+        unsubFromStateChange2();
+      }
+    };
+    const unsubFromStateChange = entry.subscribe(handleStateChange);
+    this._unsubscribe = () => {
+      unsubFromStateChange();
+    };
+  }
+  subscribe(value) {
+    if (this.unsubscribed) return;
+    this._unsubscribe = value.subscribe((value2) => {
+      this.listener(value2);
+    });
+    this.listener(value);
+  }
+  unsubscribe() {
+    if (this.unsubscribed) return;
+    this.unsubscribed = true;
+    this._unsubscribe();
+  }
+};
+
+// src/tools/subscribe/JazzError.ts
+var JazzError = class _JazzError {
+  constructor(id, type, issues) {
+    this.id = id;
+    this.type = type;
+    this.issues = issues;
+  }
+  toString() {
+    return this.issues.map((issue) => {
+      let message = `${issue.message}`;
+      if (this.id) {
+        message += ` from ${this.id}`;
+      }
+      if (issue.path.length > 0) {
+        message += ` on path ${issue.path.join(".")}`;
+      }
+      return message;
+    }).join("\n");
+  }
+  prependPath(item) {
+    if (this.issues.length === 0) {
+      return this;
+    }
+    const issues = this.issues.map((issue) => {
+      return {
+        ...issue,
+        path: [item].concat(issue.path)
+      };
+    });
+    return new _JazzError(this.id, this.type, issues);
+  }
+};
+
+// src/tools/subscribe/utils.ts
+import { RawAccount as RawAccount3 } from "cojson";
+
+// src/tools/lib/cache.ts
+var weakMap = /* @__PURE__ */ new WeakMap();
+var coValuesCache = {
+  get: (raw, compute) => {
+    const cached = weakMap.get(raw);
+    if (cached) {
+      return cached;
+    }
+    const computed = compute();
+    weakMap.set(raw, computed);
+    return computed;
+  }
+};
+
+// src/tools/subscribe/utils.ts
+function myRoleForRawValue(raw) {
+  const rawOwner = raw.group;
+  const owner = coValuesCache.get(
+    rawOwner,
+    () => rawOwner instanceof RawAccount3 ? RegisteredSchemas["Account"].fromRaw(rawOwner) : RegisteredSchemas["Group"].fromRaw(rawOwner)
+  );
+  return accountOrGroupToGroup(owner).myRole();
+}
+function createCoValue(ref2, raw, subscriptionScope) {
+  const freshValueInstance = instantiateRefEncodedFromRaw(ref2, raw);
+  Object.defineProperty(freshValueInstance.$jazz, "_subscriptionScope", {
+    value: subscriptionScope,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  return {
+    type: "loaded",
+    value: freshValueInstance,
+    id: subscriptionScope.id
+  };
+}
+
+// src/tools/subscribe/SubscriptionScope.ts
+var SubscriptionScope = class _SubscriptionScope {
+  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();
+    this.validationErrors = /* @__PURE__ */ new Map();
+    this.dirty = false;
+    this.idsSubscribed = /* @__PURE__ */ new Set();
+    this.autoloaded = /* @__PURE__ */ new Set();
+    this.autoloadedKeys = /* @__PURE__ */ new Set();
+    this.skipInvalidKeys = /* @__PURE__ */ new Set();
+    this.totalValidTransactions = 0;
+    this.migrated = false;
+    this.migrating = false;
+    this.silenceUpdates = false;
+    this.handleChildUpdate = (id, value, key) => {
+      if (value.type === "unloaded") {
+        return;
+      }
+      this.childValues.set(id, value);
+      if (value.type === "unavailable" || value.type === "unauthorized") {
+        this.childErrors.set(id, value.prependPath(key ?? id));
+        this.errorFromChildren = this.computeChildErrors();
+      } else if (this.errorFromChildren && this.childErrors.has(id)) {
+        this.childErrors.delete(id);
+        this.errorFromChildren = this.computeChildErrors();
+      }
+      if (this.shouldSendUpdates()) {
+        if (this.value.type === "loaded") {
+          this.updateValue(
+            createCoValue(this.schema, this.value.value.$jazz.raw, this)
+          );
+        }
+      }
+      this.triggerUpdate();
+    };
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.resolve = resolve;
+    this.value = { type: "unloaded", id };
+    let lastUpdate;
+    this.subscription = new CoValueCoreSubscription(
+      node,
+      id,
+      (value) => {
+        lastUpdate = value;
+        if (skipRetry && value === "unavailable") {
+          this.handleUpdate(value);
+          this.destroy();
+          return;
+        }
+        if (!this.migrated && value !== "unavailable") {
+          if (this.migrating) {
+            return;
+          }
+          this.migrating = true;
+          applyCoValueMigrations(
+            instantiateRefEncodedFromRaw(this.schema, value)
+          );
+          this.migrated = true;
+          this.handleUpdate(lastUpdate);
+          return;
+        }
+        this.handleUpdate(value);
+      },
+      skipRetry
+    );
+  }
+  updateValue(value) {
+    this.value = value;
+    this.dirty = true;
+  }
+  handleUpdate(update) {
+    if (update === "unavailable") {
+      if (this.value.type === "unloaded") {
+        this.updateValue(
+          new JazzError(this.id, "unavailable", [
+            {
+              code: "unavailable",
+              message: "The value is unavailable",
+              params: {
+                id: this.id
+              },
+              path: []
+            }
+          ])
+        );
+      }
+      this.triggerUpdate();
+      return;
+    }
+    const ruleset = update.core.verified.header.ruleset;
+    const hasAccess = ruleset.type !== "ownedByGroup" || myRoleForRawValue(update) !== void 0;
+    if (!hasAccess) {
+      if (this.value.type !== "unauthorized") {
+        this.updateValue(
+          new JazzError(this.id, "unauthorized", [
+            {
+              code: "unauthorized",
+              message: `The current user (${this.node.getCurrentAgent().id}) is not authorized to access this value`,
+              params: {
+                id: this.id
+              },
+              path: []
+            }
+          ])
+        );
+        this.triggerUpdate();
+      }
+      return;
+    }
+    this.silenceUpdates = true;
+    if (this.value.type !== "loaded") {
+      this.updateValue(createCoValue(this.schema, update, this));
+      this.loadChildren();
+    } else {
+      const hasChanged = update.totalValidTransactions !== this.totalValidTransactions || // Checking the identity of the raw value makes us cover the cases where the group
+      // has been updated and the coValues that don't update the totalValidTransactions value (e.g. FileStream)
+      this.value.value.$jazz.raw !== update;
+      if (this.loadChildren()) {
+        this.updateValue(createCoValue(this.schema, update, this));
+      } else if (hasChanged) {
+        this.updateValue(createCoValue(this.schema, update, this));
+      }
+    }
+    this.totalValidTransactions = update.totalValidTransactions;
+    this.silenceUpdates = false;
+    this.triggerUpdate();
+  }
+  computeChildErrors() {
+    let issues = [];
+    let errorType = "unavailable";
+    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;
+      }
+      if (this.skipInvalidKeys.has(key)) {
+        continue;
+      }
+      errorType = value.type;
+      if (value.issues) {
+        issues.push(...value.issues);
+      }
+    }
+    for (const [key, value] of this.validationErrors.entries()) {
+      if (this.skipInvalidKeys.has(key)) {
+        continue;
+      }
+      errorType = value.type;
+      if (value.issues) {
+        issues.push(...value.issues);
+      }
+    }
+    if (issues.length) {
+      return new JazzError(this.id, errorType, issues);
+    }
+    return void 0;
+  }
+  shouldSendUpdates() {
+    if (this.value.type === "unloaded") return false;
+    if (this.value.type !== "loaded") return true;
+    if (this.isStreaming() && !this.isFileStream()) {
+      return false;
+    }
+    for (const value of this.childValues.values()) {
+      if (value.type === "unloaded" && !this.autoloaded.has(value.id)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  getCurrentValue() {
+    if (this.value.type === "unauthorized" || this.value.type === "unavailable") {
+      console.error(this.value.toString());
+      return null;
+    }
+    if (!this.shouldSendUpdates()) {
+      return void 0;
+    }
+    if (this.errorFromChildren) {
+      console.error(this.errorFromChildren.toString());
+      return null;
+    }
+    if (this.value.type === "loaded") {
+      return this.value.value;
+    }
+    return void 0;
+  }
+  isStreaming() {
+    if (this.value.type !== "loaded") {
+      return false;
+    }
+    return this.value.value.$jazz.raw.core.verified.isStreaming();
+  }
+  isFileStream() {
+    if (this.value.type !== "loaded") {
+      return false;
+    }
+    return this.value.value.$jazz.raw.core.verified.header.meta?.type === "binary";
+  }
+  triggerUpdate() {
+    if (!this.shouldSendUpdates()) return;
+    if (!this.dirty) return;
+    if (this.subscribers.size === 0) return;
+    if (this.silenceUpdates) return;
+    const error = this.errorFromChildren;
+    const value = this.value;
+    if (error) {
+      this.subscribers.forEach((listener) => listener(error));
+    } else if (value.type !== "unloaded") {
+      this.subscribers.forEach((listener) => listener(value));
+    }
+    this.dirty = false;
+  }
+  subscribe(listener) {
+    this.subscribers.add(listener);
+    return () => {
+      this.subscribers.delete(listener);
+    };
+  }
+  setListener(listener) {
+    this.subscribers.add(listener);
+    this.triggerUpdate();
+  }
+  subscribeToKey(key) {
+    if (this.resolve === true || !this.resolve) {
+      this.resolve = {};
+    }
+    if (!this.resolve.$each && !(key in this.resolve)) {
+      const resolve = this.resolve;
+      resolve[key] = true;
+      this.autoloadedKeys.add(key);
+    }
+    if (this.value.type !== "loaded") {
+      return;
+    }
+    const value = this.value.value;
+    this.silenceUpdates = true;
+    if (value[TypeSym] === "CoMap" || value[TypeSym] === "Account") {
+      const map = value;
+      this.loadCoMapKey(map, key, true);
+    } else if (value[TypeSym] === "CoList") {
+      const list = value;
+      this.loadCoListKey(list, key, true);
+    }
+    this.silenceUpdates = false;
+  }
+  subscribeToId(id, descriptor) {
+    if (this.idsSubscribed.has(id) || this.childValues.has(id)) {
+      return;
+    }
+    this.idsSubscribed.add(id);
+    this.autoloaded.add(id);
+    this.silenceUpdates = true;
+    this.childValues.set(id, { type: "unloaded", id });
+    const child = new _SubscriptionScope(
+      this.node,
+      true,
+      id,
+      descriptor,
+      this.skipRetry,
+      this.bestEffortResolution
+    );
+    this.childNodes.set(id, child);
+    child.setListener((value) => this.handleChildUpdate(id, value));
+    this.silenceUpdates = false;
+  }
+  loadChildren() {
+    const { resolve } = this;
+    if (this.value.type !== "loaded") {
+      return false;
+    }
+    const value = this.value.value;
+    const depth = typeof resolve !== "object" || resolve === null ? {} : resolve;
+    let hasChanged = false;
+    const idsToLoad = new Set(this.idsSubscribed);
+    const coValueType = value[TypeSym];
+    if (Object.keys(depth).length > 0) {
+      if (coValueType === "CoMap" || coValueType === "Account" || coValueType === "Group") {
+        const map = value;
+        const keys = "$each" in depth ? map.$jazz.raw.keys() : Object.keys(depth);
+        for (const key of keys) {
+          const id = this.loadCoMapKey(map, key, depth[key] ?? depth.$each);
+          if (id) {
+            idsToLoad.add(id);
+          }
+        }
+      } else if (value[TypeSym] === "CoList") {
+        const list = value;
+        const descriptor = list.$jazz.getItemsDescriptor();
+        if (descriptor && isRefEncoded(descriptor)) {
+          list.$jazz.raw.processNewTransactions();
+          const entries = list.$jazz.raw.entries();
+          const keys = "$each" in depth ? Object.keys(entries) : Object.keys(depth);
+          for (const key of keys) {
+            const id = this.loadCoListKey(list, key, depth[key] ?? depth.$each);
+            if (id) {
+              idsToLoad.add(id);
+            }
+          }
+        }
+      } else if (value[TypeSym] === "CoStream") {
+        const stream = value;
+        const descriptor = stream.$jazz.getItemsDescriptor();
+        if (descriptor && isRefEncoded(descriptor)) {
+          for (const session of stream.$jazz.raw.sessions()) {
+            const values = stream.$jazz.raw.items[session] ?? [];
+            for (const [i, item] of values.entries()) {
+              const key = `${session}/${i}`;
+              if (!depth.$each && !depth[key]) {
+                continue;
+              }
+              const id = item.value;
+              if (id) {
+                idsToLoad.add(id);
+                this.loadChildNode(id, depth[key] ?? depth.$each, descriptor);
+                this.validationErrors.delete(key);
+              } else if (!descriptor.optional) {
+                this.validationErrors.set(
+                  key,
+                  new JazzError(void 0, "unavailable", [
+                    {
+                      code: "validationError",
+                      message: `The ref on position ${key} requested on ${stream.constructor.name} is missing`,
+                      params: {},
+                      path: [key]
+                    }
+                  ])
+                );
+              }
+            }
+          }
+        }
+      }
+    }
+    this.errorFromChildren = this.computeChildErrors();
+    for (const id of this.childNodes.keys()) {
+      if (!idsToLoad.has(id)) {
+        hasChanged = true;
+        const childNode = this.childNodes.get(id);
+        if (childNode) {
+          childNode.destroy();
+        }
+        this.childNodes.delete(id);
+        this.childValues.delete(id);
+      }
+    }
+    return hasChanged;
+  }
+  loadCoMapKey(map, key, depth) {
+    if (key === "$onError") {
+      return void 0;
+    }
+    const id = map.$jazz.raw.get(key);
+    const descriptor = map.$jazz.getDescriptor(key);
+    if (!descriptor) {
+      this.childErrors.set(
+        key,
+        new JazzError(void 0, "unavailable", [
+          {
+            code: "validationError",
+            message: `The ref ${key} requested on ${map.constructor.name} is not defined in the schema`,
+            params: {},
+            path: [key]
+          }
+        ])
+      );
+      return void 0;
+    }
+    if (isRefEncoded(descriptor)) {
+      if (id) {
+        this.loadChildNode(id, depth, descriptor, key);
+        this.validationErrors.delete(key);
+        return id;
+      } else if (!descriptor.optional) {
+        this.validationErrors.set(
+          key,
+          new JazzError(void 0, "unavailable", [
+            {
+              code: "validationError",
+              message: `The ref ${key} requested on ${map.constructor.name} is missing`,
+              params: {},
+              path: [key]
+            }
+          ])
+        );
+      }
+    }
+    return void 0;
+  }
+  loadCoListKey(list, key, depth) {
+    const descriptor = list.$jazz.getItemsDescriptor();
+    if (!descriptor || !isRefEncoded(descriptor)) {
+      return void 0;
+    }
+    const entries = list.$jazz.raw.entries();
+    const entry = entries[Number(key)];
+    if (!entry) {
+      return void 0;
+    }
+    const id = entry.value;
+    if (id) {
+      this.loadChildNode(id, depth, descriptor, key);
+      this.validationErrors.delete(key);
+      return id;
+    } else if (!descriptor.optional) {
+      this.validationErrors.set(
+        key,
+        new JazzError(void 0, "unavailable", [
+          {
+            code: "validationError",
+            message: `The ref on position ${key} requested on ${list.constructor.name} is missing`,
+            params: {},
+            path: [key]
+          }
+        ])
+      );
+    }
+    return void 0;
+  }
+  loadChildNode(id, query, descriptor, key) {
+    if (this.childValues.has(id)) {
+      return;
+    }
+    if (key && this.autoloadedKeys.has(key)) {
+      this.autoloaded.add(id);
+    }
+    const skipInvalid = typeof query === "object" && query.$onError === null;
+    if (skipInvalid) {
+      if (key) {
+        this.skipInvalidKeys.add(key);
+      }
+      this.skipInvalidKeys.add(id);
+    }
+    const resolve = typeof query === "object" && query !== null ? { ...query } : query;
+    this.childValues.set(id, { type: "unloaded", id });
+    const child = new _SubscriptionScope(
+      this.node,
+      resolve,
+      id,
+      descriptor,
+      this.skipRetry,
+      this.bestEffortResolution
+    );
+    this.childNodes.set(id, child);
+    child.setListener((value) => this.handleChildUpdate(id, value, key));
+  }
+  destroy() {
+    this.subscription.unsubscribe();
+    this.subscribers.clear();
+    this.childNodes.forEach((child) => child.destroy());
+  }
+};
+
+// src/tools/subscribe/index.ts
+function getSubscriptionScope(value) {
+  const subscriptionScope = value.$jazz._subscriptionScope;
+  if (subscriptionScope) {
+    return subscriptionScope;
+  }
+  const node = value.$jazz.raw.core.node;
+  const resolve = true;
+  const id = value.$jazz.id;
+  const newSubscriptionScope = new SubscriptionScope(node, resolve, id, {
+    ref: value.constructor,
+    optional: false
+  });
+  Object.defineProperty(value.$jazz, "_subscriptionScope", {
+    value: subscriptionScope,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  return newSubscriptionScope;
+}
+function accessChildByKey(parent, childId, key) {
+  const subscriptionScope = getSubscriptionScope(parent);
+  if (!subscriptionScope.childValues.has(childId)) {
+    subscriptionScope.subscribeToKey(key);
+  }
+  const value = subscriptionScope.childValues.get(childId);
+  if (value?.type === "loaded") {
+    return value.value;
+  } else {
+    return null;
+  }
+}
+function accessChildById(parent, childId, schema) {
+  const subscriptionScope = getSubscriptionScope(parent);
+  subscriptionScope.subscribeToId(childId, schema);
+  const value = subscriptionScope.childValues.get(childId);
+  if (value?.type === "loaded") {
+    return value.value;
+  } else {
+    return null;
+  }
+}
+
+// src/tools/implementation/createContext.ts
+import {
+  LocalNode as LocalNode3
+} from "cojson";
+
+// 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/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);
+  }
+};
+
+// 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
+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/zodReExport.ts
+import {
+  object as zodObject,
+  strictObject as zodStrictObject
+} from "zod/v4";
+import {
+  string,
+  number,
+  boolean,
+  templateLiteral,
+  json,
+  date,
+  emoji,
+  base64,
+  base64url,
+  nanoid,
+  cuid,
+  cuid2,
+  ulid,
+  ipv4,
+  ipv6,
+  email,
+  url,
+  uuid,
+  literal,
+  enum as enum2,
+  cidrv4,
+  cidrv6,
+  iso,
+  int32,
+  union,
+  discriminatedUnion,
+  int,
+  optional as optional2,
+  array,
+  tuple,
+  z
+} from "zod/v4";
+
+// src/tools/implementation/zodSchema/zodCo.ts
+var isZodV4Schema = (schema) => {
+  return typeof schema === "object" && schema !== null && "_zod" in schema;
+};
+var isValidShape = (shape) => {
+  return Object.values(removeGetters(shape)).every(
+    (schema) => isZodV4Schema(schema) || isAnyCoValueSchema(schema) || isCoValueClass(schema)
+  );
+};
+var validateCoMapShape = (shape) => {
+  if (isAnyCoValueSchema(shape)) {
+    throw new Error(
+      "co.map() expects an object as its argument, not a CoValue schema"
+    );
+  } else if (!isValidShape(shape)) {
+    throw new Error(
+      "co.map() supports only Zod v4 schemas and CoValue schemas"
+    );
+  }
+};
+var coMapDefiner = (shape) => {
+  validateCoMapShape(shape);
+  const coreSchema = createCoreCoMapSchema(shape);
+  return hydrateCoreCoValueSchema(coreSchema);
+};
+var coFileStreamDefiner = () => {
+  const coreSchema = createCoreFileStreamSchema();
+  return hydrateCoreCoValueSchema(coreSchema);
+};
+var coOptionalDefiner = (schema) => {
+  return new CoOptionalSchema(schema);
+};
+
+// 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 (isAnyCoValueSchema(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);
+    },
+    pick: (keys) => {
+      const keysSet = new Set(Object.keys(keys));
+      const pickedShape = {};
+      for (const [key, value] of Object.entries(coValueSchema.shape)) {
+        if (keysSet.has(key)) {
+          pickedShape[key] = value;
+        }
+      }
+      return coMapDefiner(pickedShape);
+    },
+    partial: () => {
+      const partialShape = {};
+      for (const [key, value] of Object.entries(coValueSchema.shape)) {
+        if (isAnyCoValueSchema(value)) {
+          partialShape[key] = coOptionalDefiner(value);
+        } else {
+          partialShape[key] = z.optional(coValueSchema.shape[key]);
+        }
+      }
+      const partialCoMapSchema = coMapDefiner(partialShape);
+      if (coValueSchema.catchAll) {
+        return partialCoMapSchema.catchall(
+          coValueSchema.catchAll
+        );
+      }
+      return partialCoMapSchema;
+    }
+  });
+  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;
+  }
+  /** @deprecated Use `CoList.upsertUnique` and `CoList.loadUnique` instead. */
+  findUnique(unique, ownerID, as) {
+    return this.coValueClass.findUnique(unique, ownerID, as);
+  }
+  upsertUnique(options) {
+    return this.coValueClass.upsertUnique(options);
+  }
+  loadUnique(unique, ownerID, options) {
+    return this.coValueClass.loadUnique(unique, ownerID, options);
+  }
+  optional() {
+    return coOptionalDefiner(this);
+  }
+};
+
+// 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);
+  }
+};
+
+// src/tools/implementation/zodSchema/schemaTypes/PlainTextSchema.ts
+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);
+  }
+  createFromArrayBuffer(...args) {
+    return this.coValueClass.createFromArrayBuffer(...args);
+  }
+  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 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
+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 = (discriminable) => {
+      for (const option of availableOptions) {
+        let match = true;
+        for (const key of Object.keys(discriminatorMap)) {
+          const discriminatorDef = option.getDefinition().shape[key];
+          const discriminatorValue = discriminable.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 !isAnyCoValueSchema(schema);
+  }
+}
+
+// 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" || 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 (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 isAnyCoValueSchema(schema) {
+  return typeof schema === "object" && schema !== null && "collaborative" in schema && schema.collaborative === true;
+}
+function isCoValueSchema(schema) {
+  return isAnyCoValueSchema(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
+var ImageDefinitionBase = coMapDefiner({
+  original: coFileStreamDefiner(),
+  originalSize: z.tuple([z.number(), z.number()]),
+  placeholderDataURL: z.string().optional(),
+  progressive: z.boolean()
+}).catchall(coFileStreamDefiner());
+
+// src/tools/implementation/ContextManager.ts
+import { cojsonInternals as cojsonInternals5 } from "cojson";
+import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
+
+// src/tools/implementation/devtoolsFormatters.ts
+globalThis.devtoolsFormatters = [
+  {
+    header: (object) => {
+      if (object[TypeSym] === "CoMap") {
+        return ["div", {}, ["span", {}, object.constructor.name]];
+      } else if (object[TypeSym] === "CoList") {
+        return [
+          "div",
+          {},
+          ["span", {}, object.constructor.name + "(" + object.length + ") "]
+        ];
+      } else if (object[TypeSym] === "Account") {
+        return [
+          "div",
+          {},
+          [
+            "span",
+            {},
+            object.constructor.name + "(" + object.$jazz.refs.profile.value?.name + (object.isMe ? " ME" : "") + ")"
+          ]
+        ];
+      } else {
+        return null;
+      }
+    },
+    hasBody: function() {
+      return true;
+    },
+    body: function(object) {
+      if (object[TypeSym] === "CoMap" || object[TypeSym] === "Account") {
+        return [
+          "div",
+          { style: "margin-left: 15px" },
+          ["div", "id: ", ["object", { object: object.id }]],
+          ...Object.entries(object).map(([k, v]) => [
+            "div",
+            { style: "white-space: nowrap;" },
+            ["span", { style: "font-weight: bold; opacity: 0.6" }, k, ": "],
+            ["object", { object: v }],
+            ...typeof object._schema[k] === "function" ? v === null ? [
+              [
+                "span",
+                { style: "opacity: 0.5" },
+                ` (pending ${object._schema[k].name} `,
+                ["object", { object: object.$jazz.refs[k] }],
+                ")"
+              ]
+            ] : [] : []
+          ])
+        ];
+      } else if (object[TypeSym] === "CoList") {
+        return [
+          "div",
+          { style: "margin-left: 15px" },
+          ["div", "id: ", ["object", { object: object.id }]],
+          ...object.map((v, i) => [
+            "div",
+            { style: "white-space: nowrap;" },
+            ["span", { style: "font-weight: bold; opacity: 0.6" }, i, ": "],
+            ["object", { object: v }],
+            ...typeof object._schema[ItemsSym] === "function" ? v === null ? [
+              [
+                "span",
+                { style: "opacity: 0.5" },
+                ` (pending ${object._schema[ItemsSym].name} `,
+                ["object", { object: object.$jazz.refs[i] }],
+                ")"
+              ]
+            ] : [] : []
+          ])
+        ];
+      }
+    }
+  }
+];
+
 // src/react-core/hooks.ts
 function useJazzContext() {
   const value = useContext(JazzContext);
@@ -68,7 +4697,7 @@ function useIsAuthenticated() {
     () => authSecretStorage.isAuthenticated
   );
 }
-function useCoValueSubscription(Schema, id, options) {
+function useCoValueSubscription(Schema4, id, options) {
   const contextManager = useJazzContextManager();
   const createSubscription = () => {
     if (!id) {
@@ -76,16 +4705,16 @@ function useCoValueSubscription(Schema, id, options) {
         subscription: null,
         contextManager,
         id,
-        Schema
+        Schema: Schema4
       };
     }
     const node = contextManager.getCurrentValue().node;
-    const subscription2 = new SubscriptionScope(
+    const subscription2 = new SubscriptionScope2(
       node,
       options?.resolve ?? true,
       id,
       {
-        ref: coValueClassFromCoValueClassOrSchema(Schema),
+        ref: coValueClassFromCoValueClassOrSchema2(Schema4),
         optional: true
       }
     );
@@ -93,12 +4722,12 @@ function useCoValueSubscription(Schema, id, options) {
       subscription: subscription2,
       contextManager,
       id,
-      Schema
+      Schema: Schema4
     };
   };
   const [subscription, setSubscription] = React.useState(createSubscription);
   React.useLayoutEffect(() => {
-    if (subscription.contextManager !== contextManager || subscription.id !== id || subscription.Schema !== Schema) {
+    if (subscription.contextManager !== contextManager || subscription.id !== id || subscription.Schema !== Schema4) {
       subscription.subscription?.destroy();
       setSubscription(createSubscription());
     }
@@ -106,11 +4735,11 @@ function useCoValueSubscription(Schema, id, options) {
       subscription.subscription?.destroy();
       setSubscription(createSubscription());
     });
-  }, [Schema, id, contextManager]);
+  }, [Schema4, id, contextManager]);
   return subscription.subscription;
 }
-function useCoState(Schema, id, options) {
-  const subscription = useCoValueSubscription(Schema, id, options);
+function useCoState(Schema4, id, options) {
+  const subscription = useCoValueSubscription(Schema4, id, options);
   const value = React.useSyncExternalStore(
     React.useCallback(
       (callback) => {
@@ -127,11 +4756,11 @@ function useCoState(Schema, id, options) {
   );
   return value;
 }
-function useAccountSubscription(Schema, options) {
+function useAccountSubscription(Schema4, options) {
   const contextManager = useJazzContextManager();
   const createSubscription = () => {
     const agent = getCurrentAccountFromContextManager(contextManager);
-    if (agent._type === "Anonymous") {
+    if (agent[TypeSym] === "Anonymous") {
       return {
         subscription: null,
         contextManager,
@@ -140,19 +4769,24 @@ function useAccountSubscription(Schema, options) {
     }
     const resolve = options?.resolve ?? true;
     const node = contextManager.getCurrentValue().node;
-    const subscription2 = new SubscriptionScope(node, resolve, agent.id, {
-      ref: coValueClassFromCoValueClassOrSchema(Schema),
-      optional: true
-    });
+    const subscription2 = new SubscriptionScope2(
+      node,
+      resolve,
+      agent.$jazz.id,
+      {
+        ref: coValueClassFromCoValueClassOrSchema2(Schema4),
+        optional: true
+      }
+    );
     return {
       subscription: subscription2,
       contextManager,
-      Schema
+      Schema: Schema4
     };
   };
   const [subscription, setSubscription] = React.useState(createSubscription);
   React.useLayoutEffect(() => {
-    if (subscription.contextManager !== contextManager || subscription.Schema !== Schema) {
+    if (subscription.contextManager !== contextManager || subscription.Schema !== Schema4) {
       subscription.subscription?.destroy();
       setSubscription(createSubscription());
     }
@@ -160,12 +4794,12 @@ function useAccountSubscription(Schema, options) {
       subscription.subscription?.destroy();
       setSubscription(createSubscription());
     });
-  }, [Schema, contextManager]);
+  }, [Schema4, contextManager]);
   return subscription.subscription;
 }
-function useAccount(AccountSchema = Account, options) {
+function useAccount(AccountSchema2 = Account13, options) {
   const contextManager = useJazzContextManager();
-  const subscription = useAccountSubscription(AccountSchema, options);
+  const subscription = useAccountSubscription(AccountSchema2, options);
   const agent = getCurrentAccountFromContextManager(contextManager);
   const value = React.useSyncExternalStore(
     React.useCallback(
@@ -297,4 +4931,5 @@ export {
   useJazzContextManager,
   usePassphraseAuth
 };
+/* istanbul ignore file -- @preserve */
 //# sourceMappingURL=index.js.map