jazz-tools 0.9.1 → 0.9.9

package/dist/{chunk-7LENDMTN.js → chunk-VQZOWIPU.js}

@@ -1,3 +1,30 @@
+// src/implementation/activeAccountContext.ts
+var ActiveAccountContext = class {
+  constructor() {
+    this.activeAccount = null;
+    this.guestMode = false;
+  }
+  set(account) {
+    this.activeAccount = account;
+    this.guestMode = false;
+  }
+  setGuestMode() {
+    this.guestMode = true;
+  }
+  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/implementation/anonymousJazzAgent.ts
 var AnonymousJazzAgent = class {
   constructor(node) {
@@ -9,13 +36,61 @@ var AnonymousJazzAgent = class {
 // src/coValues/interfaces.ts
 import { RawAccount as RawAccount2 } from "cojson";
 
+// src/implementation/inspect.ts
+var inspect = Symbol.for("nodejs.util.inspect.custom");
+
 // src/implementation/symbols.ts
 var SchemaInit = Symbol.for("SchemaInit");
 var ItemsSym = Symbol.for("items");
 var MembersSym = Symbol.for("members");
 
-// src/implementation/inspect.ts
-var inspect = Symbol.for("nodejs.util.inspect.custom");
+// src/coValues/deepLoading.ts
+function fulfillsDepth(depth, value) {
+  if (value._type === "CoMap" || value._type === "Group" || value._type === "Account") {
+    if (Array.isArray(depth) && depth.length === 1) {
+      return Object.entries(value).every(([key, item]) => {
+        return value._refs[key] ? item && fulfillsDepth(depth[0], item) : value._schema[ItemsSym].optional;
+      });
+    } else {
+      for (const key of Object.keys(depth)) {
+        const map = value;
+        if (!map._refs[key] && map._schema[key].optional) {
+          continue;
+        }
+        if (!map[key]) {
+          return false;
+        }
+        if (!fulfillsDepth(depth[key], map[key])) {
+          return false;
+        }
+      }
+      return true;
+    }
+  } else if (value._type === "CoList") {
+    if (depth.length === 0) {
+      return true;
+    } else {
+      const itemDepth = depth[0];
+      return value.every(
+        (item, i) => value._refs[i] ? item && fulfillsDepth(itemDepth, item) : value._schema[ItemsSym].optional
+      );
+    }
+  } else if (value._type === "CoStream") {
+    if (depth.length === 0) {
+      return true;
+    } else {
+      const itemDepth = depth[0];
+      return Object.values(value.perSession).every(
+        (entry) => entry.ref ? entry.value && fulfillsDepth(itemDepth, entry.value) : value._schema[ItemsSym].optional
+      );
+    }
+  } else if (value._type === "BinaryCoStream" || value._type === "CoPlainText") {
+    return true;
+  } else {
+    console.error(value);
+    throw new Error("Unexpected value type: " + value._type);
+  }
+}
 
 // src/lib/cache.ts
 var weakMap = /* @__PURE__ */ new WeakMap();
@@ -329,54 +404,6 @@ var SubscriptionScope = class {
   }
 };
 
-// src/coValues/deepLoading.ts
-function fulfillsDepth(depth, value) {
-  if (value._type === "CoMap" || value._type === "Group" || value._type === "Account") {
-    if (Array.isArray(depth) && depth.length === 1) {
-      return Object.entries(value).every(([key, item]) => {
-        return value._refs[key] ? item && fulfillsDepth(depth[0], item) : value._schema[ItemsSym].optional;
-      });
-    } else {
-      for (const key of Object.keys(depth)) {
-        const map = value;
-        if (!map._refs[key] && map._schema[key].optional) {
-          continue;
-        }
-        if (!map[key]) {
-          return false;
-        }
-        if (!fulfillsDepth(depth[key], map[key])) {
-          return false;
-        }
-      }
-      return true;
-    }
-  } else if (value._type === "CoList") {
-    if (depth.length === 0) {
-      return true;
-    } else {
-      const itemDepth = depth[0];
-      return value.every(
-        (item, i) => value._refs[i] ? item && fulfillsDepth(itemDepth, item) : value._schema[ItemsSym].optional
-      );
-    }
-  } else if (value._type === "CoStream") {
-    if (depth.length === 0) {
-      return true;
-    } else {
-      const itemDepth = depth[0];
-      return Object.values(value.perSession).every(
-        (entry) => entry.ref ? entry.value && fulfillsDepth(itemDepth, entry.value) : value._schema[ItemsSym].optional
-      );
-    }
-  } else if (value._type === "BinaryCoStream") {
-    return true;
-  } else {
-    console.error(value);
-    throw new Error("Unexpected value type: " + value._type);
-  }
-}
-
 // src/implementation/createContext.ts
 import {
   ControlledAgent,
@@ -460,10 +487,12 @@ async function createJazzContext(options) {
               const account2 = new AccountSchema({
                 fromRaw: rawAccount
               });
+              activeAccountContext.set(account2);
               await account2.applyMigration(creationProps);
             }
           });
           const account = AccountSchema.fromNode(node);
+          activeAccountContext.set(account);
           if (authResult.saveCredentials) {
             await authResult.saveCredentials({
               accountID: node.account.id,
@@ -503,10 +532,12 @@ async function createJazzContext(options) {
             const account2 = new AccountSchema({
               fromRaw: rawAccount
             });
+            activeAccountContext.set(account2);
             await account2.applyMigration(creationProps);
           }
         });
         const account = AccountSchema.fromNode(node);
+        activeAccountContext.set(account);
         await authResult.saveCredentials({
           accountID: node.account.id,
           secret: node.account.agentSecret
@@ -542,6 +573,7 @@ async function createAnonymousJazzContext({
   for (const peer of peersToLoadFrom) {
     node.syncManager.addPeer(peer);
   }
+  activeAccountContext.setGuestMode();
   return {
     agent: new AnonymousJazzAgent(node),
     done: () => {
@@ -685,6 +717,17 @@ var CoValueBase = class {
     return casted;
   }
 };
+function loadCoValueWithoutMe(cls, id, asOrDepth, depth) {
+  if (isAccountInstance(asOrDepth) || isAnonymousAgentInstance(asOrDepth)) {
+    if (!depth) {
+      throw new Error(
+        "Depth is required when loading a CoValue as an Account or AnonymousJazzAgent"
+      );
+    }
+    return loadCoValue(cls, id, asOrDepth, depth);
+  }
+  return loadCoValue(cls, id, activeAccountContext.get(), asOrDepth);
+}
 function loadCoValue(cls, id, as, depth) {
   return new Promise((resolve) => {
     subscribeToCoValue(
@@ -710,6 +753,30 @@ function ensureCoValueLoaded(existing, depth) {
     depth
   );
 }
+function subscribeToCoValueWithoutMe(cls, id, asOrDepth, depthOrListener, listener) {
+  if (isAccountInstance(asOrDepth) || isAnonymousAgentInstance(asOrDepth)) {
+    if (typeof depthOrListener !== "function") {
+      return subscribeToCoValue(
+        cls,
+        id,
+        asOrDepth,
+        depthOrListener,
+        listener
+      );
+    }
+    throw new Error("Invalid arguments");
+  }
+  if (typeof depthOrListener !== "function") {
+    throw new Error("Invalid arguments");
+  }
+  return subscribeToCoValue(
+    cls,
+    id,
+    activeAccountContext.get(),
+    asOrDepth,
+    depthOrListener
+  );
+}
 function subscribeToCoValue(cls, id, as, depth, listener, onUnavailable, syncResolution) {
   const ref2 = new Ref(id, as, { ref: cls, optional: false });
   let unsubscribed = false;
@@ -787,12 +854,40 @@ function subscribeToExistingCoValue(existing, depth, listener) {
     listener
   );
 }
+function isAccountInstance(instance) {
+  if (typeof instance !== "object" || instance === null) {
+    return false;
+  }
+  return "_type" in instance && instance._type === "Account";
+}
+function isAnonymousAgentInstance(instance) {
+  if (typeof instance !== "object" || instance === null) {
+    return false;
+  }
+  return "_type" in instance && instance._type === "Anonymous";
+}
 function parseCoValueCreateOptions(options) {
-  return "_type" in options && (options._type === "Account" || options._type === "Group") ? { owner: options, uniqueness: void 0 } : {
-    owner: options.owner,
-    uniqueness: options.unique ? { uniqueness: options.unique } : void 0
+  const Group2 = RegisteredSchemas["Group"];
+  if (!options) {
+    return { owner: Group2.create(), uniqueness: void 0 };
+  }
+  if ("_type" in options) {
+    if (options._type === "Account" || options._type === "Group") {
+      return { owner: options, uniqueness: void 0 };
+    }
+  }
+  const uniqueness = options.unique ? { uniqueness: options.unique } : void 0;
+  return {
+    owner: options.owner ?? Group2.create(),
+    uniqueness
   };
 }
+function parseGroupCreateOptions(options) {
+  if (!options) {
+    return { owner: activeAccountContext.get() };
+  }
+  return "_type" in options && isAccountInstance(options) ? { owner: options } : { owner: options.owner ?? activeAccountContext.get() };
+}
 
 // src/coValues/inbox.ts
 import {
@@ -978,6 +1073,7 @@ var InboxSender = class _InboxSender {
     });
   }
   static async load(inboxOwnerID, currentAccount) {
+    currentAccount ||= activeAccountContext.get();
     const node = currentAccount._raw.core.node;
     const inboxOwnerRaw = await node.load(
       inboxOwnerID
@@ -1002,6 +1098,7 @@ var InboxSender = class _InboxSender {
   }
 };
 async function acceptInvite(invite, account) {
+  account ||= activeAccountContext.get();
   const id = invite.slice(0, invite.indexOf("/"));
   const inviteSecret = invite.slice(invite.indexOf("/") + 1);
   if (!id?.startsWith("co_z") || !inviteSecret.startsWith("inviteSecret_")) {
@@ -1252,62 +1349,20 @@ var _CoMap = class _CoMap extends CoValueBase {
     }
     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",
-   *   me,
-   *   { pet: {} }
-   * );
-   * ```
-   *
-   * @category Subscription & Loading
-   */
-  static load(id, as, depth) {
-    return loadCoValue(this, id, as, depth);
+  static load(id, asOrDepth, depth) {
+    return loadCoValueWithoutMe(this, id, asOrDepth, depth);
   }
-  /**
-   * Load and subscribe to a `CoMap` with a given ID, as a given account.
-   *
-   * Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.
-   *
-   * `depth` specifies which (if any) fields that reference other CoValues to load as well before calling `listener` for the first time.
-   * 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.
-   *
-   * Returns an unsubscribe function that you should call when you no longer need updates.
-   *
-   * Also see the `useCoState` hook to reactively subscribe to a CoValue in a React component.
-   *
-   * @example
-   * ```ts
-   * const unsub = Person.subscribe(
-   *   "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
-   *   me,
-   *   { pet: {} },
-   *   (person) => console.log(person)
-   * );
-   * ```
-   *
-   * @category Subscription & Loading
-   */
-  static subscribe(id, as, depth, listener) {
-    return subscribeToCoValue(this, id, as, depth, listener);
+  static subscribe(id, asOrDepth, depthOrListener, listener) {
+    return subscribeToCoValueWithoutMe(
+      this,
+      id,
+      asOrDepth,
+      depthOrListener,
+      listener
+    );
   }
   static findUnique(unique, ownerID, as) {
+    as ||= activeAccountContext.get();
     const header = {
       type: "comap",
       ruleset: {
@@ -1584,6 +1639,9 @@ var _Account = class _Account extends CoValueBase {
     });
     return this.fromNode(node);
   }
+  static getMe() {
+    return activeAccountContext.get();
+  }
   static async createAs(as, options) {
     const connectedPeers = cojsonInternals2.connectedPeers(
       "creatingAccount",
@@ -1634,13 +1692,17 @@ var _Account = class _Account extends CoValueBase {
   migrate(creationProps) {
     creationProps;
   }
-  /** @category Subscription & Loading */
-  static load(id, as, depth) {
-    return loadCoValue(this, id, as, depth);
+  static load(id, asOrDepth, depth) {
+    return loadCoValueWithoutMe(this, id, asOrDepth, depth);
   }
-  /** @category Subscription & Loading */
-  static subscribe(id, as, depth, listener) {
-    return subscribeToCoValue(this, id, as, depth, listener);
+  static subscribe(id, asOrDepth, depthOrListener, listener) {
+    return subscribeToCoValueWithoutMe(
+      this,
+      id,
+      asOrDepth,
+      depthOrListener,
+      listener
+    );
   }
   /** @category Subscription & Loading */
   ensureLoaded(depth) {
@@ -1735,186 +1797,57 @@ function isControlledAccount(account) {
 }
 RegisteredSchemas["Account"] = Account;
 
-// src/coValues/group.ts
-var _Group = class _Group extends CoValueBase {
+// src/coValues/coFeed.ts
+import { MAX_RECOMMENDED_TX_SIZE, 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 `co.ref`.
+   *
+   * @example
+   * ```ts
+   * class ColorFeed extends CoFeed.Of(co.string) {}
+   * class AnimalFeed extends CoFeed.Of(co.ref(Animal)) {}
+   * ```
+   *
+   * @category Declaration
+   */
+  static Of(item) {
+    var _a2, _b2;
+    return class CoFeedOf extends (_b2 = _CoFeed, _a2 = co.items, _b2) {
+      constructor() {
+        super(...arguments);
+        this[_a2] = item;
+      }
+    };
+  }
+  /** @internal */
   get _schema() {
     return this.constructor._schema;
   }
-  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
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ),
-      root: rootID && new Ref(
-        rootID,
-        this._loadedAs,
-        this._schema.root
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      )
-    };
-  }
-  /** @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._type === "Account" && isControlledAccount(initOwner)) {
-        const rawOwner = initOwner._raw;
-        raw = rawOwner.createGroup();
-      } else {
-        throw new Error("Can only construct group as a controlled account");
-      }
-    }
-    Object.defineProperties(this, {
-      id: {
-        value: raw.id,
-        enumerable: false
-      },
-      _raw: { value: raw, enumerable: false }
-    });
-    return new Proxy(this, AccountAndGroupProxyHandler);
-  }
-  static create(options) {
-    return new this(parseCoValueCreateOptions(options));
-  }
-  myRole() {
-    return this._raw.myRole();
-  }
-  addMember(member, role) {
-    this._raw.addMember(member === "everyone" ? member : member._raw, role);
-    return this;
-  }
-  removeMember(member) {
-    this._raw.removeMember(member === "everyone" ? member : member._raw);
-    return this;
-  }
-  get members() {
-    return this._raw.keys().filter((key) => {
-      return key === "everyone" || key.startsWith("co_");
-    }).map((id) => {
-      const role = this._raw.get(id);
-      const accountID = id === "everyone" ? void 0 : id;
-      const ref2 = accountID && new Ref(
-        accountID,
-        this._loadedAs,
-        this._schema[MembersSym]
-      );
-      const accessRef = () => ref2?.accessFrom(this, "members." + id);
-      return {
-        id,
-        role,
-        ref: ref2,
-        get account() {
-          return accessRef();
-        }
-      };
-    });
-  }
-  extend(parent) {
-    this._raw.extend(parent._raw);
-    return this;
-  }
-  /** @category Subscription & Loading */
-  static load(id, as, depth) {
-    return loadCoValue(this, id, as, depth);
-  }
-  /** @category Subscription & Loading */
-  static subscribe(id, as, depth, listener) {
-    return subscribeToCoValue(this, id, as, depth, listener);
-  }
-  /** @category Subscription & Loading */
-  ensureLoaded(depth) {
-    return ensureCoValueLoaded(this, depth);
-  }
-  /** @category Subscription & Loading */
-  subscribe(depth, listener) {
-    return subscribeToExistingCoValue(this, depth, listener);
-  }
-  /**
-   * Wait for the `Group` to be uploaded to the other peers.
-   *
-   * @category Subscription & Loading
-   */
-  waitForSync(options) {
-    return this._raw.core.waitForSync(options);
-  }
-};
-_Group.prototype._type = "Group";
-_Group._schema = {
-  profile: "json",
-  root: "json",
-  [MembersSym]: {
-    ref: () => RegisteredSchemas["Account"],
-    optional: false
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-};
-Object.defineProperty(_Group.prototype, "_schema", {
-  get: () => _Group._schema
-});
-var Group = _Group;
-RegisteredSchemas["Group"] = Group;
-
-// src/coValues/coFeed.ts
-import { MAX_RECOMMENDED_TX_SIZE, 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 `co.ref`.
-   *
-   * @example
-   * ```ts
-   * class ColorFeed extends CoFeed.Of(co.string) {}
-   * class AnimalFeed extends CoFeed.Of(co.ref(Animal)) {}
-   * ```
-   *
-   * @category Declaration
-   */
-  static Of(item) {
-    var _a2, _b2;
-    return class CoFeedOf extends (_b2 = _CoFeed, _a2 = co.items, _b2) {
-      constructor() {
-        super(...arguments);
-        this[_a2] = item;
-      }
-    };
-  }
-  /** @internal */
-  get _schema() {
-    return this.constructor._schema;
-  }
-  /**
-   * The current account's view of this `CoFeed`
-   * @category Content
-   */
-  get byMe() {
-    if (this._loadedAs._type === "Account") {
-      return this[this._loadedAs.id];
-    } else {
-      return void 0;
-    }
-  }
-  /**
-   * 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._loadedAs._type === "Account") {
-      return this.perSession[this._loadedAs.sessionID];
-    } else {
-      return void 0;
-    }
+  /**
+   * The current account's view of this `CoFeed`
+   * @category Content
+   */
+  get byMe() {
+    if (this._loadedAs._type === "Account") {
+      return this[this._loadedAs.id];
+    } else {
+      return void 0;
+    }
+  }
+  /**
+   * 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._loadedAs._type === "Account") {
+      return this.perSession[this._loadedAs.sessionID];
+    } else {
+      return void 0;
+    }
   }
   constructor(options) {
     super();
@@ -2017,19 +1950,17 @@ var _CoFeed = class _CoFeed extends CoValueBase {
     this._schema ||= {};
     Object.assign(this._schema, def);
   }
-  /**
-   * Load a `CoFeed`
-   * @category Subscription & Loading
-   */
-  static load(id, as, depth) {
-    return loadCoValue(this, id, as, depth);
+  static load(id, asOrDepth, depth) {
+    return loadCoValueWithoutMe(this, id, asOrDepth, depth);
   }
-  /**
-   * Subscribe to a `CoFeed`, when you have an ID but don't have a `CoFeed` instance yet
-   * @category Subscription & Loading
-   */
-  static subscribe(id, as, depth, listener) {
-    return subscribeToCoValue(this, id, as, depth, listener);
+  static subscribe(id, asOrDepth, depthOrListener, listener) {
+    return subscribeToCoValueWithoutMe(
+      this,
+      id,
+      asOrDepth,
+      depthOrListener,
+      listener
+    );
   }
   /**
    * Ensure a `CoFeed` is loaded to the specified depth
@@ -2274,12 +2205,9 @@ var FileStream = class extends CoValueBase {
     }
     return new Blob(chunks.chunks, { type: chunks.mimeType });
   }
-  /**
-   * Load a `FileStream` as a `Blob`
-   *
-   * @category Content
-   */
-  static async loadAsBlob(id, as, options) {
+  static async loadAsBlob(id, asOrOptions, optionsOrUndefined) {
+    const as = isAccountInstance(asOrOptions) ? asOrOptions : activeAccountContext.get();
+    const options = isAccountInstance(asOrOptions) ? optionsOrUndefined : asOrOptions;
     let stream = await this.load(id, as, []);
     if (!options?.allowUnfinished && !stream?.isBinaryStreamEnded()) {
       stream = await new Promise((resolve) => {
@@ -2308,7 +2236,7 @@ var FileStream = class extends CoValueBase {
    */
   static async createFromBlob(blob, options) {
     const stream = this.create(options);
-    const onProgress = "onProgress" in options ? options.onProgress : void 0;
+    const onProgress = options && "onProgress" in options ? options.onProgress : void 0;
     const start = Date.now();
     const data = new Uint8Array(await blob.arrayBuffer());
     stream.start({
@@ -2352,19 +2280,17 @@ var FileStream = class extends CoValueBase {
   [inspect]() {
     return this.toJSON();
   }
-  /**
-   * Load a `FileStream`
-   * @category Subscription & Loading
-   */
-  static load(id, as, depth) {
-    return loadCoValue(this, id, as, depth);
+  static load(id, asOrDepth, depth) {
+    return loadCoValueWithoutMe(this, id, asOrDepth, depth);
   }
-  /**
-   * Subscribe to a `FileStream`, when you have an ID but don't have a `FileStream` instance yet
-   * @category Subscription & Loading
-   */
-  static subscribe(id, as, depth, listener) {
-    return subscribeToCoValue(this, id, as, depth, listener);
+  static subscribe(id, asOrDepth, depthOrListener, listener) {
+    return subscribeToCoValueWithoutMe(
+      this,
+      id,
+      asOrDepth,
+      depthOrListener,
+      listener
+    );
   }
   ensureLoaded(depth) {
     return ensureCoValueLoaded(this, depth);
@@ -2588,61 +2514,17 @@ var _CoList = class _CoList extends Array {
     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
-   */
-  static load(id, as, depth) {
-    return loadCoValue(this, id, as, depth);
+  static load(id, asOrDepth, depth) {
+    return loadCoValueWithoutMe(this, id, asOrDepth, depth);
   }
-  /**
-   * Load and subscribe to a `CoList` with a given ID, as a given account.
-   *
-   * Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.
-   *
-   * `depth` specifies if item CoValue references should be loaded as well before calling `listener` for the first time.
-   * 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.
-   *
-   * Returns an unsubscribe function that you should call when you no longer need updates.
-   *
-   * Also see the `useCoState` hook to reactively subscribe to a CoValue in a React component.
-   *
-   * @example
-   * ```ts
-   * const unsub = ListOfAnimals.subscribe(
-   *   "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
-   *   me,
-   *   { vet: {} },
-   *   (animalsWithVets) => console.log(animalsWithVets)
-   * );
-   * ```
-   *
-   * @category Subscription & Loading
-   */
-  static subscribe(id, as, depth, listener) {
-    return subscribeToCoValue(this, id, as, depth, listener);
+  static subscribe(id, asOrDepth, depthOrListener, listener) {
+    return subscribeToCoValueWithoutMe(
+      this,
+      id,
+      asOrDepth,
+      depthOrListener,
+      listener
+    );
   }
   /**
    * Given an already loaded `CoList`, ensure that items are loaded to the specified depth.
@@ -2754,6 +2636,659 @@ var CoListProxyHandler = {
   }
 };
 
+// src/coValues/group.ts
+var _Group = class _Group extends CoValueBase {
+  get _schema() {
+    return this.constructor._schema;
+  }
+  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
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ),
+      root: rootID && new Ref(
+        rootID,
+        this._loadedAs,
+        this._schema.root
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      )
+    };
+  }
+  /** @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._type === "Account" && isControlledAccount(initOwner)) {
+        const rawOwner = initOwner._raw;
+        raw = rawOwner.createGroup();
+      } else {
+        throw new Error("Can only construct group as a controlled account");
+      }
+    }
+    Object.defineProperties(this, {
+      id: {
+        value: raw.id,
+        enumerable: false
+      },
+      _raw: { value: raw, enumerable: false }
+    });
+    return new Proxy(this, AccountAndGroupProxyHandler);
+  }
+  static create(options) {
+    return new this(parseGroupCreateOptions(options));
+  }
+  myRole() {
+    return this._raw.myRole();
+  }
+  addMember(member, role) {
+    this._raw.addMember(member === "everyone" ? member : member._raw, role);
+    return this;
+  }
+  removeMember(member) {
+    this._raw.removeMember(member === "everyone" ? member : member._raw);
+    return this;
+  }
+  get members() {
+    return this._raw.keys().filter((key) => {
+      return key === "everyone" || key.startsWith("co_");
+    }).map((id) => {
+      const role = this._raw.get(id);
+      const accountID = id === "everyone" ? void 0 : id;
+      const ref2 = accountID && new Ref(
+        accountID,
+        this._loadedAs,
+        this._schema[MembersSym]
+      );
+      const accessRef = () => ref2?.accessFrom(this, "members." + id);
+      return {
+        id,
+        role,
+        ref: ref2,
+        get account() {
+          return accessRef();
+        }
+      };
+    });
+  }
+  extend(parent) {
+    this._raw.extend(parent._raw);
+    return this;
+  }
+  static load(id, asOrDepth, depth) {
+    return loadCoValueWithoutMe(this, id, asOrDepth, depth);
+  }
+  static subscribe(id, asOrDepth, depthOrListener, listener) {
+    return subscribeToCoValueWithoutMe(
+      this,
+      id,
+      asOrDepth,
+      depthOrListener,
+      listener
+    );
+  }
+  /** @category Subscription & Loading */
+  ensureLoaded(depth) {
+    return ensureCoValueLoaded(this, depth);
+  }
+  /** @category Subscription & Loading */
+  subscribe(depth, listener) {
+    return subscribeToExistingCoValue(this, depth, listener);
+  }
+  /**
+   * Wait for the `Group` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForSync(options) {
+    return this._raw.core.waitForSync(options);
+  }
+};
+_Group.prototype._type = "Group";
+_Group._schema = {
+  profile: "json",
+  root: "json",
+  [MembersSym]: {
+    ref: () => RegisteredSchemas["Account"],
+    optional: false
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+};
+Object.defineProperty(_Group.prototype, "_schema", {
+  get: () => _Group._schema
+});
+var Group = _Group;
+RegisteredSchemas["Group"] = Group;
+
+// src/coValues/coPlainText.ts
+import {
+  RawAccount as RawAccount6,
+  stringifyOpID
+} from "cojson";
+var CoPlainText = class extends String {
+  get _owner() {
+    return this._raw.group instanceof RawAccount6 ? Account.fromRaw(this._raw.group) : Group.fromRaw(this._raw.group);
+  }
+  get _loadedAs() {
+    return Account.fromNode(this._raw.core.node);
+  }
+  constructor(options) {
+    super();
+    let raw;
+    if ("fromRaw" in options) {
+      raw = options.fromRaw;
+    } else {
+      raw = options.owner._raw.createPlainText(options.text);
+    }
+    Object.defineProperties(this, {
+      id: { value: raw.id, enumerable: false },
+      _type: { value: "CoPlainText", enumerable: false },
+      _raw: { value: raw, enumerable: false }
+    });
+  }
+  static create(text, options) {
+    return new this({ text, owner: options.owner });
+  }
+  get length() {
+    return this._raw.toString().length;
+  }
+  toString() {
+    return this._raw.toString();
+  }
+  valueOf() {
+    return this._raw.toString();
+  }
+  toJSON() {
+    return this._raw.toString();
+  }
+  [inspect]() {
+    return this.toJSON();
+  }
+  insertAfter(idx, text) {
+    this._raw.insertAfter(idx, text);
+  }
+  deleteRange(range) {
+    this._raw.deleteRange(range);
+  }
+  posBefore(idx) {
+    return this._raw.mapping.opIDbeforeIdx[idx];
+  }
+  posAfter(idx) {
+    return this._raw.mapping.opIDafterIdx[idx];
+  }
+  idxBefore(pos) {
+    return this._raw.mapping.idxBeforeOpID[stringifyOpID(pos)];
+  }
+  idxAfter(pos) {
+    return this._raw.mapping.idxAfterOpID[stringifyOpID(pos)];
+  }
+  static fromRaw(raw) {
+    return new this({ fromRaw: raw });
+  }
+  /**
+   * Load a `CoPlainText` 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 CoPlainText, or `{ fieldA: depthA, fieldB: depthB }` for recursively loading referenced CoValues.
+   *
+   * Check out the `load` methods on `CoMap`/`CoList`/`CoStream`/`Group`/`Account` to see which depth structures are valid to nest.
+   *
+   * @example
+   * ```ts
+   * const person = await Person.load(
+   *   "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
+   *   me,
+   *   { pet: {} }
+   * );
+   * ```
+   *
+   * @category Subscription & Loading
+   */
+  static load(id, as) {
+    return loadCoValue(this, id, as ?? activeAccountContext.get(), []);
+  }
+  static subscribe(id, asOrListener, listener) {
+    if (isAccountInstance(asOrListener)) {
+      return subscribeToCoValue(this, id, asOrListener, [], listener);
+    }
+    return subscribeToCoValue(
+      this,
+      id,
+      activeAccountContext.get(),
+      [],
+      listener
+    );
+  }
+  //   /**
+  //    * Effectful version of `CoMap.subscribe()` that returns a stream of updates.
+  //    *
+  //    * Needs to be run inside an `AccountCtx` context.
+  //    *
+  //    * @category Subscription & Loading
+  //    */
+  //   static subscribeEf<T extends CoPlainText>(
+  //     this: CoValueClass<T>,
+  //     id: ID<T>,
+  //   ): Stream.Stream<T, UnavailableError, AccountCtx> {
+  //     return subscribeToCoValueEf(this, id, []);
+  //   }
+  /**
+   * 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, [], listener);
+  }
+};
+
+// src/coValues/coRichText.ts
+var Mark = class extends CoMap {
+  constructor() {
+    super(...arguments);
+    this.startAfter = co.json();
+    this.startBefore = co.json();
+    this.endAfter = co.json();
+    this.endBefore = co.json();
+    this.tag = co.string;
+  }
+  /**
+   * Validates and clamps mark positions to ensure they are in the correct order
+   * @returns Normalized positions or null if invalid
+   */
+  validatePositions(textLength, idxAfter, idxBefore) {
+    if (!textLength) {
+      console.error("Cannot validate positions for empty text");
+      return null;
+    }
+    const positions = {
+      startAfter: this.startAfter ? idxBefore(this.startAfter) ?? 0 : 0,
+      startBefore: this.startBefore ? idxAfter(this.startBefore) ?? 0 : 0,
+      endAfter: this.endAfter ? idxBefore(this.endAfter) ?? textLength : textLength,
+      endBefore: this.endBefore ? idxAfter(this.endBefore) ?? textLength : textLength
+    };
+    return {
+      startAfter: Math.max(0, positions.startAfter),
+      startBefore: Math.max(positions.startAfter + 1, positions.startBefore),
+      endAfter: Math.min(textLength - 1, positions.endAfter),
+      endBefore: Math.min(textLength, positions.endBefore)
+    };
+  }
+};
+var CoRichText = class extends CoMap {
+  constructor() {
+    super(...arguments);
+    this.text = co.ref(CoPlainText);
+    this.marks = co.ref(CoList.Of(co.ref(Mark)));
+  }
+  /**
+   * Create a CoRichText from plain text.
+   */
+  static createFromPlainText(text, options) {
+    return this.create(
+      {
+        text: CoPlainText.create(text, { owner: options.owner }),
+        marks: CoList.Of(co.ref(Mark)).create([], {
+          owner: options.owner
+        })
+      },
+      { owner: options.owner }
+    );
+  }
+  /**
+   * Create a CoRichText from plain text and a mark.
+   */
+  static createFromPlainTextAndMark(text, WrapIn, extraArgs, options) {
+    const richtext = this.createFromPlainText(text, options);
+    richtext.insertMark(0, text.length, WrapIn, extraArgs);
+    return richtext;
+  }
+  /**
+   * Insert text at a specific index.
+   */
+  insertAfter(idx, text) {
+    if (!this.text)
+      throw new Error("Cannot insert into a CoRichText without loaded text");
+    this.text.insertAfter(idx, text);
+  }
+  /**
+   * Delete a range of text.
+   */
+  deleteRange(range) {
+    if (!this.text)
+      throw new Error("Cannot delete from a CoRichText without loaded text");
+    this.text.deleteRange(range);
+  }
+  /**
+   * Get the position of a specific index.
+   */
+  posBefore(idx) {
+    if (!this.text)
+      throw new Error(
+        "Cannot get posBefore in a CoRichText without loaded text"
+      );
+    return this.text.posBefore(idx);
+  }
+  /**
+   * Get the position of a specific index.
+   */
+  posAfter(idx) {
+    if (!this.text)
+      throw new Error(
+        "Cannot get posAfter in a CoRichText without loaded text"
+      );
+    return this.text.posAfter(idx);
+  }
+  /**
+   * Get the index of a specific position.
+   */
+  idxBefore(pos) {
+    if (!this.text)
+      throw new Error(
+        "Cannot get idxBefore in a CoRichText without loaded text"
+      );
+    return this.text.idxBefore(pos);
+  }
+  /**
+   * Get the index of a specific position.
+   */
+  idxAfter(pos) {
+    if (!this.text)
+      throw new Error(
+        "Cannot get idxAfter in a CoRichText without loaded text"
+      );
+    return this.text.idxAfter(pos);
+  }
+  /**
+   * Insert a mark at a specific range.
+   */
+  insertMark(start, end, RangeClass, extraArgs, options) {
+    if (!this.text || !this.marks) {
+      throw new Error("Cannot insert a range without loaded ranges");
+    }
+    const textLength = this.length;
+    start = Math.max(start, 0);
+    end = Math.min(end, textLength);
+    const owner = options?.markOwner || this._owner;
+    if (!owner) {
+      throw new Error("No owner specified for mark");
+    }
+    const range = RangeClass.create(
+      {
+        ...extraArgs,
+        startAfter: this.posBefore(start),
+        startBefore: this.posAfter(start),
+        endAfter: this.posBefore(end),
+        endBefore: this.posAfter(end)
+      },
+      { owner }
+    );
+    this.marks.push(range);
+  }
+  /**
+   * Remove a mark at a specific range.
+   */
+  removeMark(start, end, RangeClass, options) {
+    if (!this.marks) {
+      throw new Error("Cannot remove marks without loaded marks");
+    }
+    const resolvedMarks = this.resolveMarks();
+    for (const mark of resolvedMarks) {
+      if (mark.endBefore < start || mark.startAfter > end) {
+        continue;
+      }
+      if (options.tag && mark.sourceMark.tag !== options.tag) {
+        continue;
+      }
+      const markIndex = this.marks.findIndex((m) => m === mark.sourceMark);
+      if (markIndex === -1) {
+        continue;
+      }
+      if (mark.startBefore >= start && mark.endAfter <= end) {
+        this.marks.splice(markIndex, 1);
+        continue;
+      }
+      if (mark.startBefore < start && mark.endAfter >= start && mark.endAfter <= end) {
+        const endAfterPos = this.posBefore(start);
+        const endBeforePos = this.posBefore(start);
+        if (endAfterPos && endBeforePos) {
+          mark.sourceMark.endAfter = endAfterPos;
+          mark.sourceMark.endBefore = endBeforePos;
+        }
+        continue;
+      }
+      if (mark.startBefore >= start && mark.startBefore <= end && mark.endAfter > end) {
+        const startAfterPos = this.posAfter(end);
+        const startBeforePos = this.posAfter(end);
+        if (startAfterPos && startBeforePos) {
+          mark.sourceMark.startAfter = startAfterPos;
+          mark.sourceMark.startBefore = startBeforePos;
+        }
+        continue;
+      }
+      if (mark.startBefore <= start && mark.endAfter >= end) {
+        const endAfterPos = this.posBefore(start);
+        const endBeforePos = this.posBefore(start);
+        if (endAfterPos && endBeforePos) {
+          mark.sourceMark.endAfter = endAfterPos;
+          mark.sourceMark.endBefore = endBeforePos;
+        }
+        this.insertMark(
+          end + 1,
+          mark.endBefore,
+          RangeClass,
+          {},
+          {
+            markOwner: mark.sourceMark._owner || this._owner
+          }
+        );
+        continue;
+      }
+    }
+  }
+  /**
+   * Resolve the positions of all marks.
+   */
+  resolveMarks() {
+    if (!this.text || !this.marks) {
+      throw new Error("Cannot resolve ranges without loaded text and ranges");
+    }
+    const textLength = this.length;
+    return this.marks.flatMap((mark) => {
+      if (!mark) return [];
+      const positions = mark.validatePositions(
+        textLength,
+        (pos) => this.idxAfter(pos),
+        (pos) => this.idxBefore(pos)
+      );
+      if (!positions) return [];
+      return [
+        {
+          sourceMark: mark,
+          ...positions,
+          tag: mark.tag
+        }
+      ];
+    });
+  }
+  /**
+   * Resolve and diffuse the positions of all marks.
+   */
+  resolveAndDiffuseMarks() {
+    return this.resolveMarks().flatMap((range) => [
+      ...range.startAfter < range.startBefore - 1 ? [
+        {
+          start: range.startAfter,
+          end: range.startBefore - 1,
+          side: "uncertainStart",
+          sourceMark: range.sourceMark
+        }
+      ] : [],
+      {
+        start: range.startBefore - 1,
+        end: range.endAfter + 1,
+        side: "certainMiddle",
+        sourceMark: range.sourceMark
+      },
+      ...range.endAfter + 1 < range.endBefore ? [
+        {
+          start: range.endAfter + 1,
+          end: range.endBefore,
+          side: "uncertainEnd",
+          sourceMark: range.sourceMark
+        }
+      ] : []
+    ]);
+  }
+  /**
+   * Resolve, diffuse, and focus the positions of all marks.
+   */
+  resolveAndDiffuseAndFocusMarks() {
+    return this.resolveAndDiffuseMarks().filter(
+      (range) => range.side === "certainMiddle"
+    );
+  }
+  /**
+   * Convert a CoRichText to a tree structure useful for client libraries.
+   */
+  toTree(tagPrecedence) {
+    const ranges = this.resolveAndDiffuseAndFocusMarks();
+    const text = this.text?.toString() || "";
+    let currentNodes = [
+      {
+        type: "leaf",
+        start: 0,
+        end: text.length
+      }
+    ];
+    const rangesSortedLowToHighPrecedence = ranges.sort((a, b) => {
+      const aPrecedence = tagPrecedence.indexOf(a.sourceMark.tag);
+      const bPrecedence = tagPrecedence.indexOf(b.sourceMark.tag);
+      return bPrecedence - aPrecedence;
+    });
+    for (const range of rangesSortedLowToHighPrecedence) {
+      const newNodes = currentNodes.flatMap((node) => {
+        const [before, inOrAfter] = splitNode(node, range.start);
+        const [inside, after] = inOrAfter ? splitNode(inOrAfter, range.end) : [void 0, void 0];
+        return [
+          ...before ? [before] : [],
+          ...inside ? [
+            {
+              type: "node",
+              tag: range.sourceMark.tag,
+              start: inside.start,
+              end: inside.end,
+              children: [inside]
+            }
+          ] : [],
+          ...after ? [after] : []
+        ];
+      });
+      currentNodes = newNodes;
+    }
+    return {
+      type: "node",
+      tag: "root",
+      start: 0,
+      end: text.length,
+      children: currentNodes
+    };
+  }
+  get length() {
+    return this.text?.toString().length || 0;
+  }
+  /**
+   * Convert a CoRichText to plain text.
+   */
+  toString() {
+    if (!this.text) return "";
+    return this.text.toString();
+  }
+};
+function splitNode(node, at) {
+  if (node.type === "leaf") {
+    return [
+      at > node.start ? {
+        type: "leaf",
+        start: node.start,
+        end: Math.min(at, node.end)
+      } : void 0,
+      at < node.end ? {
+        type: "leaf",
+        start: Math.max(at, node.start),
+        end: node.end
+      } : void 0
+    ];
+  } else {
+    const children = node.children;
+    return [
+      at > node.start ? {
+        type: "node",
+        tag: node.tag,
+        start: node.start,
+        end: Math.min(at, node.end),
+        children: children.map((child) => splitNode(child, at)[0]).filter((c) => !!c)
+      } : void 0,
+      at < node.end ? {
+        type: "node",
+        tag: node.tag,
+        start: Math.max(at, node.start),
+        end: node.end,
+        children: children.map((child) => splitNode(child, at)[1]).filter((c) => !!c)
+      } : void 0
+    ];
+  }
+}
+var Marks = {
+  Heading: class Heading extends Mark {
+    constructor() {
+      super(...arguments);
+      this.tag = co.literal("heading");
+      this.level = co.number;
+    }
+  },
+  Paragraph: class Paragraph extends Mark {
+    constructor() {
+      super(...arguments);
+      this.tag = co.literal("paragraph");
+    }
+  },
+  Link: class Link extends Mark {
+    constructor() {
+      super(...arguments);
+      this.tag = co.literal("link");
+      this.url = co.string;
+    }
+  },
+  Strong: class Strong extends Mark {
+    constructor() {
+      super(...arguments);
+      this.tag = co.literal("strong");
+    }
+  },
+  Em: class Italic extends Mark {
+    constructor() {
+      super(...arguments);
+      this.tag = co.literal("em");
+    }
+  }
+};
+
 // src/coValues/extensions/imageDef.ts
 var _a, _b;
 var ImageDefinition = class extends (_b = CoMap, _a = co.items, _b) {
@@ -2852,6 +3387,7 @@ var SchemaUnion = class _SchemaUnion extends CoValueBase {
 };
 
 export {
+  activeAccountContext,
   AnonymousJazzAgent,
   CoValueBase,
   loadCoValue,
@@ -2870,12 +3406,15 @@ export {
   Profile,
   Account,
   isControlledAccount,
-  Group,
   CoFeed,
   FileStream,
   CoList,
+  Group,
+  CoPlainText,
+  CoRichText,
+  Marks,
   ImageDefinition,
   SchemaUnion
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-7LENDMTN.js.map
+//# sourceMappingURL=chunk-VQZOWIPU.js.map