jazz-tools 0.17.14 → 0.18.1

package/dist/{chunk-LZOF6WP5.js → chunk-IERUTUXB.js}

@@ -119,35 +119,8 @@ function isAnyCoValueSchema(schema) {
 }
 
 // src/tools/coValues/CoValueBase.ts
-import { ControlledAccount, RawAccount } from "cojson";
+import { ControlledAccount } from "cojson";
 var CoValueBase = class {
-  get _owner() {
-    const schema = this._raw.group instanceof RawAccount ? RegisteredSchemas["Account"] : RegisteredSchemas["Group"];
-    return accessChildById(this, this._raw.group.id, {
-      ref: schema,
-      optional: false
-    });
-  }
-  /** @private */
-  get _loadedAs() {
-    const agent = this._raw.core.node.getCurrentAgent();
-    if (agent instanceof ControlledAccount) {
-      return coValuesCache.get(
-        agent.account,
-        () => coValueClassFromCoValueClassOrSchema(
-          RegisteredSchemas["Account"]
-        ).fromRaw(agent.account)
-      );
-    }
-    return new AnonymousJazzAgent(this._raw.core.node);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  constructor(..._args) {
-    Object.defineProperty(this, "_instanceID", {
-      value: `instance-${Math.random().toString(36).slice(2)}`,
-      enumerable: false
-    });
-  }
   /** @category Internals */
   static fromRaw(raw) {
     return new this({ fromRaw: raw });
@@ -155,21 +128,39 @@ var CoValueBase = class {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   toJSON() {
     return {
-      id: this.id,
-      type: this._type,
+      id: this.$jazz.id,
+      type: this[TypeSym],
       error: "unknown CoValue class"
     };
   }
   [inspect]() {
     return this.toJSON();
   }
-  /** @category Type Helpers */
-  castAs(schema) {
-    const cl = isCoValueSchema(schema) ? schema.getCoValueClass() : schema;
-    if (this.constructor === cl) {
-      return this;
+};
+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 cl.fromRaw(this._raw);
+    return new AnonymousJazzAgent(this.localNode);
   }
 };
 
@@ -179,6 +170,7 @@ var inspect = 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 = {};
@@ -188,125 +180,23 @@ import {
   cojsonInternals
 } from "cojson";
 var _CoMap = class _CoMap extends CoValueBase {
-  /** @internal */
-  get _schema() {
-    return this.constructor._schema;
-  }
-  /**
-   * The timestamp of the creation time of the CoMap
-   */
-  get _createdAt() {
-    return this._raw.earliestTxMadeAt ?? Number.MAX_SAFE_INTEGER;
-  }
-  /**
-   * The timestamp of the last updated time of the CoMap
-   */
-  get _lastUpdatedAt() {
-    return this._raw.latestTxMadeAt;
-  }
-  /**
-   * If property `prop` is a `coField.ref(...)`, you can use `coMaps._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._refs.pet.id; // => ID<Animal>
-   * person._refs.pet.value;
-   * // => Animal | null
-   * const pet = await person._refs.pet.load();
-   * ```
-   *
-   * @category Content
-   **/
-  get _refs() {
-    return makeRefs(
-      this,
-      (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
-    );
-  }
-  /** @internal */
-  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._loadedAs,
-        descriptor,
-        target
-      ) : void 0,
-      get by() {
-        return rawEdit.by && accessChildById(target, rawEdit.by, {
-          ref: Account,
-          optional: false
-        });
-      },
-      madeAt: rawEdit.at,
-      key
-    };
-  }
-  /** @category Collaboration */
-  get _edits() {
-    const map = this;
-    return new Proxy(
-      {},
-      {
-        get(_target, key) {
-          const rawEdit = map._raw.lastEditAt(key);
-          if (!rawEdit) return void 0;
-          const descriptor = map.getDescriptor(key);
-          if (!descriptor) return void 0;
-          return {
-            ...map.getEditFromRaw(map, rawEdit, descriptor, key),
-            get all() {
-              return [...map._raw.editsAt(key)].map(
-                (rawEdit2) => map.getEditFromRaw(map, rawEdit2, descriptor, key)
-              );
-            }
-          };
-        },
-        ownKeys(_target) {
-          return map._raw.keys();
-        },
-        getOwnPropertyDescriptor(target, key) {
-          return {
-            value: Reflect.get(target, key),
-            writable: false,
-            enumerable: true,
-            configurable: true
-          };
-        }
-      }
-    );
-  }
   /** @internal */
   constructor(options) {
     super();
+    const proxy = new Proxy(this, CoMapProxyHandler);
     if (options) {
       if ("fromRaw" in options) {
         Object.defineProperties(this, {
-          id: {
-            value: options.fromRaw.id,
+          $jazz: {
+            value: new CoMapJazzApi(proxy, () => options.fromRaw),
             enumerable: false
-          },
-          _raw: { value: options.fromRaw, enumerable: false }
+          }
         });
       } else {
         throw new Error("Invalid CoMap constructor arguments");
       }
     }
-    return new Proxy(this, CoMapProxyHandler);
+    return proxy;
   }
   /**
    * Create a new CoMap with the given initial values and owner.
@@ -325,10 +215,12 @@ var _CoMap = class _CoMap extends CoValueBase {
    * ```
    *
    * @category Creation
+   *
+   * @deprecated Use `co.map(...).create`.
    **/
   static create(init, options) {
     const instance = new this();
-    return instance._createCoMap(init, options);
+    return _CoMap._createCoMap(instance, init, options);
   }
   /**
    * Return a JSON representation of the `CoMap`
@@ -336,21 +228,18 @@ var _CoMap = class _CoMap extends CoValueBase {
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   toJSON(_key, processedValues) {
-    const result = {
-      id: this.id,
-      _type: this._type
-    };
-    for (const key of this._raw.keys()) {
+    const result = {};
+    for (const key of this.$jazz.raw.keys()) {
       const tKey = key;
-      const descriptor = this.getDescriptor(tKey);
+      const descriptor = this.$jazz.getDescriptor(tKey);
       if (!descriptor) {
         continue;
       }
       if (descriptor == "json" || "encoded" in descriptor) {
-        result[key] = this._raw.get(key);
+        result[key] = this.$jazz.raw.get(key);
       } else if (isRefEncoded(descriptor)) {
-        const id = this._raw.get(key);
-        if (processedValues?.includes(id) || id === this.id) {
+        const id = this.$jazz.raw.get(key);
+        if (processedValues?.includes(id) || id === this.$jazz.id) {
           result[key] = { _circular: id };
           continue;
         }
@@ -358,7 +247,7 @@ var _CoMap = class _CoMap extends CoValueBase {
         if (ref2 && typeof ref2 === "object" && "toJSON" in ref2 && typeof ref2.toJSON === "function") {
           const jsonedRef = ref2.toJSON(tKey, [
             ...processedValues || [],
-            this.id
+            this.$jazz.id
           ]);
           result[key] = jsonedRef;
         }
@@ -371,30 +260,31 @@ var _CoMap = class _CoMap extends CoValueBase {
   [inspect]() {
     return this.toJSON();
   }
-  _createCoMap(init, options) {
+  /**
+   * @internal
+   */
+  static _createCoMap(instance, init, options) {
     const { owner, uniqueness } = parseCoValueCreateOptions(options);
-    const raw = this.rawFromInit(init, owner, uniqueness);
-    Object.defineProperties(this, {
-      id: {
-        value: raw.id,
+    Object.defineProperties(instance, {
+      $jazz: {
+        value: new CoMapJazzApi(instance, () => raw),
         enumerable: false
-      },
-      _raw: { value: raw, enumerable: false }
+      }
     });
-    return this;
+    const raw = _CoMap.rawFromInit(instance, init, owner, uniqueness);
+    return instance;
   }
   /**
    * Create a new `RawCoMap` from an initialization object
    * @internal
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  rawFromInit(init, owner, uniqueness) {
-    const rawOwner = owner._raw;
+  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 = this.getDescriptor(key);
+        const descriptor = instance.$jazz.getDescriptor(key);
         if (!descriptor) {
           continue;
         }
@@ -402,14 +292,14 @@ var _CoMap = class _CoMap extends CoValueBase {
           rawInit[key] = initValue;
         } else if (isRefEncoded(descriptor)) {
           if (initValue != null) {
-            let refId = initValue.id;
+            let refId = initValue.$jazz?.id;
             if (!refId) {
               const coValue = instantiateRefEncodedWithInit(
                 descriptor,
                 initValue,
                 owner
               );
-              refId = coValue.id;
+              refId = coValue.$jazz.id;
             }
             rawInit[key] = refId;
           }
@@ -422,9 +312,6 @@ var _CoMap = class _CoMap extends CoValueBase {
       }
     return rawOwner.createMap(rawInit, null, "private", uniqueness);
   }
-  getDescriptor(key) {
-    return this._schema?.[key] || this._schema?.[ItemsSym];
-  }
   /**
    * Declare a Record-like CoMap schema, by extending `CoMap.Record(...)` and passing the value schema using `co`. Keys are always `string`.
    *
@@ -444,11 +331,11 @@ var _CoMap = class _CoMap extends CoValueBase {
    * @category Declaration
    */
   static Record(value) {
-    var _a, _b;
-    class RecordLikeCoMap extends (_b = _CoMap, _a = ItemsSym, _b) {
+    var _a2, _b;
+    class RecordLikeCoMap extends (_b = _CoMap, _a2 = ItemsSym, _b) {
       constructor() {
         super(...arguments);
-        this[_a] = value;
+        this[_a2] = value;
       }
     }
     return RecordLikeCoMap;
@@ -472,6 +359,8 @@ var _CoMap = class _CoMap extends CoValueBase {
    * ```
    *
    * @category Subscription & Loading
+   *
+   * @deprecated Use `co.map(...).load` instead.
    */
   static load(id, options) {
     return loadCoValueWithoutMe(this, id, options);
@@ -496,7 +385,7 @@ var _CoMap = class _CoMap extends CoValueBase {
       meta: null,
       uniqueness: unique
     };
-    const crypto = as._type === "Anonymous" ? as.node.crypto : as._raw.core.node.crypto;
+    const crypto = as[TypeSym] === "Anonymous" ? as.node.crypto : as.$jazz.localNode.crypto;
     return cojsonInternals.idforHeader(header, crypto);
   }
   /**
@@ -521,30 +410,34 @@ var _CoMap = class _CoMap extends CoValueBase {
    * @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.id,
-      options.owner._loadedAs
+      options.owner.$jazz.id,
+      options.owner.$jazz.loadedAs
     );
     let map = await loadCoValueWithoutMe(this, mapId, {
       ...options,
-      loadAs: options.owner._loadedAs,
+      loadAs: options.owner.$jazz.loadedAs,
       skipRetry: true
     });
     if (!map) {
       const instance = new this();
-      map = instance._createCoMap(options.value, {
+      map = _CoMap._createCoMap(instance, options.value, {
         owner: options.owner,
         unique: options.unique
       });
     } else {
-      map.applyDiff(options.value);
+      map.$jazz.applyDiff(
+        options.value
+      );
     }
     return await loadCoValueWithoutMe(this, mapId, {
       ...options,
-      loadAs: options.owner._loadedAs,
+      loadAs: options.owner.$jazz.loadedAs,
       skipRetry: true
     });
   }
@@ -554,6 +447,8 @@ var _CoMap = class _CoMap extends CoValueBase {
    * @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(
@@ -562,20 +457,100 @@ var _CoMap = class _CoMap extends CoValueBase {
       { ...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;
+  }
   /**
-   * Given an already loaded `CoMap`, ensure that the specified fields are loaded to the specified depth.
+   * The ID of this `CoMap`
+   * @category Content
+   */
+  get id() {
+    return this.raw.id;
+  }
+  get owner() {
+    return getCoValueOwner(this.coMap);
+  }
+  /**
+   * Check if a key is defined in the CoMap.
    *
-   * Works like `CoMap.load()`, but you don't need to pass the ID or the account to load as again.
+   * This check does not load the referenced value or validate permissions.
    *
-   * @category Subscription & Loading
+   * @param key The key to check
+   * @returns True if the key is defined, false otherwise
+   * @category Content
    */
-  ensureLoaded(options) {
-    return ensureCoValueLoaded(this, options);
+  has(key) {
+    const entry = this.raw.getRaw(key);
+    return entry?.change !== void 0 && entry.change.op !== "del";
   }
-  subscribe(...args) {
-    const { options, listener } = parseSubscribeRestArgs(args);
-    return subscribeToExistingCoValue(this, options, listener);
+  /**
+   * 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)) {
@@ -583,33 +558,146 @@ var _CoMap = class _CoMap extends CoValueBase {
         const descriptor = this.getDescriptor(key);
         if (!descriptor) continue;
         const newValue = newValues[tKey];
-        const currentValue = this[tKey];
+        const currentValue = this.coMap[tKey];
         if (descriptor === "json" || "encoded" in descriptor) {
           if (currentValue !== newValue) {
-            this[tKey] = newValue;
+            this.set(tKey, newValue);
           }
         } else if (isRefEncoded(descriptor)) {
-          const currentId = currentValue?.id;
-          const newId = newValue?.id;
+          const currentId = currentValue?.$jazz.id;
+          let newId = newValue?.$jazz?.id;
           if (currentId !== newId) {
-            this[tKey] = newValue;
+            this.set(tKey, newValue);
           }
         }
       }
     }
-    return this;
+    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
    */
-  waitForSync(options) {
-    return this._raw.core.waitForSync(options);
+  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;
   }
 };
-_CoMap.prototype._type = "CoMap";
-var CoMap = _CoMap;
 var CoMapProxyHandler = {
   get(target, key, receiver) {
     if (key === "_schema") {
@@ -620,11 +708,11 @@ var CoMapProxyHandler = {
       if (typeof key !== "string") {
         return void 0;
       }
-      const descriptor = target.getDescriptor(key);
+      const descriptor = target.$jazz.getDescriptor(key);
       if (!descriptor) {
         return void 0;
       }
-      const raw = target._raw.get(key);
+      const raw = target.$jazz.raw.get(key);
       if (descriptor === "json") {
         return raw;
       } else if ("encoded" in descriptor) {
@@ -635,36 +723,15 @@ var CoMapProxyHandler = {
     }
   },
   set(target, key, value, receiver) {
-    if ((typeof key === "string" || ItemsSym) && typeof value === "object" && value !== null && SchemaInit in value) {
+    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.getDescriptor(key);
+    const descriptor = target.$jazz.getDescriptor(key);
     if (!descriptor) return false;
     if (typeof key === "string") {
-      if (descriptor === "json") {
-        target._raw.set(key, value);
-      } else if ("encoded" in descriptor) {
-        target._raw.set(key, descriptor.encoded.encode(value));
-      } else if (isRefEncoded(descriptor)) {
-        if (value === void 0) {
-          if (descriptor.optional) {
-            target._raw.set(key, null);
-          } else {
-            throw new Error(
-              `Cannot set required reference ${key} to undefined`
-            );
-          }
-        } else if (value?.id) {
-          target._raw.set(key, value.id);
-        } else {
-          throw new Error(
-            `Cannot set reference ${key} to a non-CoValue. Got ${value}`
-          );
-        }
-      }
-      return true;
+      throw Error("Cannot update a CoMap directly. Use `$jazz.set` instead.");
     } else {
       return Reflect.set(target, key, value, receiver);
     }
@@ -680,7 +747,7 @@ var CoMapProxyHandler = {
   },
   ownKeys(target) {
     const keys = Reflect.ownKeys(target).filter((k) => k !== ItemsSym);
-    for (const key of target._raw.keys()) {
+    for (const key of target.$jazz.raw.keys()) {
       if (!keys.includes(key)) {
         keys.push(key);
       }
@@ -691,8 +758,8 @@ var CoMapProxyHandler = {
     if (key in target) {
       return Reflect.getOwnPropertyDescriptor(target, key);
     } else {
-      const descriptor = target.getDescriptor(key);
-      if (descriptor || key in target._raw.latest) {
+      const descriptor = target.$jazz.getDescriptor(key);
+      if (descriptor || key in target.$jazz.raw.latest) {
         return {
           enumerable: true,
           configurable: true,
@@ -702,27 +769,47 @@ var CoMapProxyHandler = {
     }
   },
   has(target, key) {
-    const descriptor = target.getDescriptor(key);
-    if (target._raw && typeof key === "string" && descriptor) {
-      return target._raw.get(key) !== void 0;
+    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.getDescriptor(key);
+    const descriptor = target.$jazz.getDescriptor(key);
     if (typeof key === "string" && descriptor) {
-      target._raw.delete(key);
-      return true;
+      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 { ControlledAccount as ControlledAccount2, RawAccount as RawAccount2, cojsonInternals as cojsonInternals2 } from "cojson";
+import { cojsonInternals as cojsonInternals2 } from "cojson";
 import { calcPatch } from "fast-myers-diff";
 var _CoList = class _CoList extends Array {
   /**
@@ -741,11 +828,11 @@ var _CoList = class _CoList extends Array {
    * @category Declaration
    */
   static Of(item) {
-    var _a, _b;
-    return class CoListOf extends (_b = _CoList, _a = coField.items, _b) {
+    var _a2, _b;
+    return class CoListOf extends (_b = _CoList, _a2 = coField.items, _b) {
       constructor() {
         super(...arguments);
-        this[_a] = item;
+        this[_a2] = item;
       }
     };
   }
@@ -755,79 +842,21 @@ var _CoList = class _CoList extends Array {
   static of(..._args) {
     throw new Error("Can't use Array.of with CoLists");
   }
-  /** @internal */
-  get _schema() {
-    return this.constructor._schema;
-  }
-  /** @category Collaboration */
-  get _owner() {
-    return this._raw.group instanceof RawAccount2 ? coValueClassFromCoValueClassOrSchema(
-      RegisteredSchemas["Account"]
-    ).fromRaw(this._raw.group) : RegisteredSchemas["Group"].fromRaw(this._raw.group);
-  }
-  /**
-   * If a `CoList`'s items are a `coField.ref(...)`, you can use `coList._refs[i]` to access
-   * 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._refs[0].id; // => ID<Animal>
-   * animals._refs[0].value;
-   * // => Animal | null
-   * const animal = await animals._refs[0].load();
-   * ```
-   *
-   * @category Content
-   **/
-  get _refs() {
-    return makeRefs(
-      this,
-      (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 _edits() {
-    throw new Error("Not implemented");
-  }
-  get _loadedAs() {
-    const agent = this._raw.core.node.getCurrentAgent();
-    if (agent instanceof ControlledAccount2) {
-      return coValuesCache.get(
-        agent.account,
-        () => coValueClassFromCoValueClassOrSchema(
-          RegisteredSchemas["Account"]
-        ).fromRaw(agent.account)
-      );
-    }
-    return new AnonymousJazzAgent(this._raw.core.node);
-  }
   static get [(ItemsSym, Symbol.species)]() {
     return Array;
   }
-  getItemsDescriptor() {
-    return this._schema?.[ItemsSym];
-  }
   constructor(options) {
     super();
-    Object.defineProperty(this, "_instanceID", {
-      value: `instance-${Math.random().toString(36).slice(2)}`,
-      enumerable: false
-    });
+    const proxy = new Proxy(this, CoListProxyHandler);
     if (options && "fromRaw" in options) {
       Object.defineProperties(this, {
-        id: {
-          value: options.fromRaw.id,
+        $jazz: {
+          value: new CoListJazzApi(proxy, () => options.fromRaw),
           enumerable: false
-        },
-        _raw: { value: options.fromRaw, enumerable: false }
+        }
       });
     }
-    return new Proxy(this, CoListProxyHandler);
+    return proxy;
   }
   /**
    * Create a new CoList with the given initial values and owner.
@@ -849,126 +878,37 @@ var _CoList = class _CoList extends Array {
    * ```
    *
    * @category Creation
+   * @deprecated Use `co.list(...).create` instead.
    **/
   static create(items, options) {
     const { owner, uniqueness } = parseCoValueCreateOptions(options);
-    const instance = new this({ init: items, owner });
-    const raw = owner._raw.createList(
-      toRawItems(items, instance._schema[ItemsSym], owner),
+    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
     );
-    Object.defineProperties(instance, {
-      id: {
-        value: raw.id,
-        enumerable: false
-      },
-      _raw: { value: raw, enumerable: false }
-    });
     return instance;
   }
-  push(...items) {
-    this._raw.appendItems(
-      toRawItems(items, this._schema[ItemsSym], this._owner),
-      void 0,
-      "private"
-    );
-    return this._raw.entries().length;
-  }
-  unshift(...items) {
-    for (const item of toRawItems(
-      items,
-      this._schema[ItemsSym],
-      this._owner
-    )) {
-      this._raw.prepend(item);
-    }
-    return this._raw.entries().length;
-  }
-  pop() {
-    const last = this[this.length - 1];
-    this._raw.delete(this.length - 1);
-    return last;
-  }
-  shift() {
-    const first = this[0];
-    this._raw.delete(0);
-    return first;
-  }
-  /**
-   * Splice the `CoList` at a given index.
-   *
-   * @param start - The index to start the splice.
-   * @param deleteCount - The number of items to delete.
-   * @param items - The items to insert.
-   */
-  splice(start, deleteCount, ...items) {
-    const deleted = this.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;
-  }
-  /**
-   * Modify the `CoList` to match another list, where the changes are managed internally.
-   *
-   * @param result - The resolved list of items.
-   */
-  applyDiff(result) {
-    const current = this._raw.asArray();
-    const comparator = isRefEncoded(this._schema[ItemsSym]) ? (aIdx, bIdx) => {
-      return current[aIdx]?.id === result[bIdx]?.id;
-    } : void 0;
-    const patches = [...calcPatch(current, result, comparator)];
-    for (const [from, to, insert] of patches.reverse()) {
-      this.splice(from, to - from, ...insert);
-    }
-  }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   toJSON(_key, seenAbove) {
-    const itemDescriptor = this._schema[ItemsSym];
+    const itemDescriptor = this.$jazz.schema[ItemsSym];
     if (itemDescriptor === "json") {
-      return this._raw.asArray();
+      return this.$jazz.raw.asArray();
     } else if ("encoded" in itemDescriptor) {
-      return this._raw.asArray().map((e) => itemDescriptor.encoded.encode(e));
+      return this.$jazz.raw.asArray().map((e) => itemDescriptor.encoded.encode(e));
     } else if (isRefEncoded(itemDescriptor)) {
       return this.map(
-        (item, idx) => seenAbove?.includes(item?.id) ? { _circular: item.id } : item?.toJSON(idx + "", [
+        (item, idx) => seenAbove?.includes(item?.$jazz.id) ? { _circular: item.$jazz.id } : item?.toJSON(idx + "", [
           ...seenAbove || [],
-          this.id
+          this.$jazz.id
         ])
       );
     } else {
@@ -1008,6 +948,7 @@ var _CoList = class _CoList extends Array {
    * ```
    *
    * @category Subscription & Loading
+   * @deprecated Use `co.list(...).load` instead.
    */
   static load(id, options) {
     return loadCoValueWithoutMe(this, id, options);
@@ -1016,24 +957,6 @@ var _CoList = class _CoList extends Array {
     const { options, listener } = parseSubscribeRestArgs(args);
     return subscribeToCoValueWithoutMe(this, id, options, listener);
   }
-  /**
-   * 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, options);
-  }
-  subscribe(...args) {
-    const { options, listener } = parseSubscribeRestArgs(args);
-    return subscribeToExistingCoValue(this, options, listener);
-  }
-  /** @category Type Helpers */
-  castAs(cl) {
-    return cl.fromRaw(this._raw);
-  }
   /** @deprecated Use `CoList.upsertUnique` and `CoList.loadUnique` instead. */
   static findUnique(unique, ownerID, as) {
     return _CoList._findUnique(unique, ownerID, as);
@@ -1050,7 +973,7 @@ var _CoList = class _CoList extends Array {
       meta: null,
       uniqueness: unique
     };
-    const crypto = as._type === "Anonymous" ? as.node.crypto : as._raw.core.node.crypto;
+    const crypto = as[TypeSym] === "Anonymous" ? as.node.crypto : as.$jazz.localNode.crypto;
     return cojsonInternals2.idforHeader(header, crypto);
   }
   /**
@@ -1069,60 +992,377 @@ var _CoList = class _CoList extends Array {
    * );
    * ```
    *
-   * @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.
+   * @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
    */
-  static async upsertUnique(options) {
-    const listId = _CoList._findUnique(
-      options.unique,
-      options.owner.id,
-      options.owner._loadedAs
-    );
-    let list = await loadCoValueWithoutMe(this, listId, {
-      ...options,
-      loadAs: options.owner._loadedAs,
-      skipRetry: true
-    });
-    if (!list) {
-      list = this.create(options.value, {
-        owner: options.owner,
-        unique: options.unique
-      });
-    } else {
-      list.applyDiff(options.value);
-    }
-    return await loadCoValueWithoutMe(this, listId, {
-      ...options,
-      loadAs: options.owner._loadedAs,
-      skipRetry: true
-    });
+  async waitForSync(options) {
+    await this.raw.core.waitForSync(options);
   }
   /**
-   * 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.
+   * Get the descriptor for the items in the `CoList`
+   * @internal
    */
-  static loadUnique(unique, ownerID, options) {
-    return loadCoValueWithoutMe(
-      this,
-      _CoList._findUnique(unique, ownerID, options?.loadAs),
-      { ...options, skipRetry: true }
+  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
     );
   }
   /**
-   * Wait for the `CoList` to be uploaded to the other peers.
+   * Get the edits made to the CoList.
    *
-   * @category Subscription & Loading
+   * @category Collaboration
    */
-  waitForSync(options) {
-    return this._raw.core.waitForSync(options);
+  getEdits() {
+    throw new Error("Not implemented");
+  }
+  /** @internal */
+  get raw() {
+    return this.getRaw();
+  }
+  /** @internal */
+  get schema() {
+    return this.coList.constructor._schema;
   }
 };
-_CoList.prototype._type = "CoList";
-var CoList = _CoList;
 function toRawItems(items, itemDescriptor, owner) {
   let rawItems = [];
   if (itemDescriptor === "json") {
@@ -1131,15 +1371,17 @@ function toRawItems(items, itemDescriptor, owner) {
     rawItems = items?.map((e) => itemDescriptor.encoded.encode(e));
   } else if (isRefEncoded(itemDescriptor)) {
     rawItems = items?.map((value) => {
-      if (value == null) return null;
-      let refId = value.id;
+      if (value == null) {
+        return null;
+      }
+      let refId = value.$jazz?.id;
       if (!refId) {
         const coValue = instantiateRefEncodedWithInit(
           itemDescriptor,
           value,
           owner
         );
-        refId = coValue.id;
+        refId = coValue.$jazz.id;
       }
       return refId;
     });
@@ -1151,8 +1393,8 @@ function toRawItems(items, itemDescriptor, owner) {
 var CoListProxyHandler = {
   get(target, key, receiver) {
     if (typeof key === "string" && !isNaN(+key)) {
-      const itemDescriptor = target._schema[ItemsSym];
-      const rawValue = target._raw.get(Number(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) {
@@ -1161,7 +1403,7 @@ var CoListProxyHandler = {
         return rawValue === void 0 || rawValue === null ? void 0 : accessChildByKey(target, rawValue, key);
       }
     } else if (key === "length") {
-      return target._raw.entries().length;
+      return target.$jazz.raw.entries().length;
     } else {
       return Reflect.get(target, key, receiver);
     }
@@ -1173,31 +1415,7 @@ var CoListProxyHandler = {
       return true;
     }
     if (typeof key === "string" && !isNaN(+key)) {
-      const itemDescriptor = target._schema[ItemsSym];
-      let rawValue;
-      if (itemDescriptor === "json") {
-        rawValue = value;
-      } else if ("encoded" in itemDescriptor) {
-        rawValue = itemDescriptor.encoded.encode(value);
-      } else if (isRefEncoded(itemDescriptor)) {
-        if (value === void 0) {
-          if (itemDescriptor.optional) {
-            rawValue = null;
-          } else {
-            throw new Error(
-              `Cannot set required reference ${key} to undefined`
-            );
-          }
-        } else if (value?.id) {
-          rawValue = value.id;
-        } else {
-          throw new Error(
-            `Cannot set reference ${key} to a non-CoValue. Got ${value}`
-          );
-        }
-      }
-      target._raw.replace(Number(key), rawValue);
-      return true;
+      throw Error("Cannot update a CoList directly. Use `$jazz.set` instead.");
     } else {
       return Reflect.set(target, key, value, receiver);
     }
@@ -1213,7 +1431,7 @@ var CoListProxyHandler = {
   },
   has(target, key) {
     if (typeof key === "string" && !isNaN(+key)) {
-      return Number(key) < target._raw.entries().length;
+      return Number(key) < target.$jazz.raw.entries().length;
     } else {
       return Reflect.has(target, key);
     }
@@ -1235,28 +1453,24 @@ var _CoFeed = class _CoFeed extends CoValueBase {
    * @category Declaration
    */
   static Of(item) {
-    var _a, _b;
-    const cls = class CoFeedOf extends (_b = _CoFeed, _a = coField.items, _b) {
+    var _a2, _b;
+    const cls = class CoFeedOf extends (_b = _CoFeed, _a2 = coField.items, _b) {
       constructor() {
         super(...arguments);
-        this[_a] = item;
+        this[_a2] = item;
       }
     };
     cls._schema ||= {};
     cls._schema[ItemsSym] = item[SchemaInit];
     return cls;
   }
-  /** @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.perAccount[this._loadedAs.id];
+    if (this.$jazz.loadedAs[TypeSym] === "Account") {
+      return this.perAccount[this.$jazz.loadedAs.$jazz.id];
     } else {
       return void 0;
     }
@@ -1304,102 +1518,45 @@ var _CoFeed = class _CoFeed extends CoValueBase {
    * @category Content
    */
   get inCurrentSession() {
-    if (this._loadedAs._type === "Account") {
-      return this.perSession[this._loadedAs.sessionID];
+    if (this.$jazz.loadedAs[TypeSym] === "Account") {
+      return this.perSession[this.$jazz.loadedAs.$jazz.sessionID];
     } else {
       return void 0;
     }
   }
+  /** @internal */
   constructor(options) {
     super();
-    if (options && "fromRaw" in options) {
-      Object.defineProperties(this, {
-        id: {
-          value: options.fromRaw.id,
-          enumerable: false
-        },
-        _raw: { value: options.fromRaw, enumerable: false }
-      });
-    }
+    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 instance = new this({ init, owner });
-    const raw = owner._raw.createStream();
-    Object.defineProperties(instance, {
-      id: {
-        value: raw.id,
-        enumerable: false
-      },
-      _raw: { value: raw, enumerable: false }
-    });
+    const raw = owner.$jazz.raw.createStream();
+    const instance = new this({ fromRaw: raw });
     if (init) {
-      instance.push(...init);
+      instance.$jazz.push(...init);
     }
     return instance;
   }
-  getItemsDescriptor() {
-    return this._schema?.[ItemsSym];
-  }
-  /**
-   * 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.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.id;
-      if (!refId) {
-        const coValue = instantiateRefEncodedWithInit(
-          itemDescriptor,
-          item,
-          this._owner
-        );
-        refId = coValue.id;
-      }
-      this._raw.push(refId);
-    }
-  }
   /**
    * Get a JSON representation of the `CoFeed`
    * @category
    */
   toJSON() {
-    const itemDescriptor = this._schema[ItemsSym];
-    const mapper = itemDescriptor === "json" ? (v) => v : "encoded" in itemDescriptor ? itemDescriptor.encoded.encode : (v) => v && v.id;
+    const itemDescriptor = this.$jazz.schema[ItemsSym];
+    const mapper = itemDescriptor === "json" ? (v) => v : "encoded" in itemDescriptor ? itemDescriptor.encoded.encode : (v) => v && v.$jazz.id;
     return {
-      id: this.id,
-      _type: this._type,
       ...Object.fromEntries(
         Object.entries(this).map(([account, entry]) => [
           account,
@@ -1426,6 +1583,7 @@ var _CoFeed = class _CoFeed extends CoValueBase {
   /**
    * Load a `CoFeed`
    * @category Subscription & Loading
+   * @deprecated Use `co.feed(...).load` instead.
    */
   static load(id, options) {
     return loadCoValueWithoutMe(this, id, options);
@@ -1434,6 +1592,69 @@ var _CoFeed = class _CoFeed extends CoValueBase {
     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
    *
@@ -1441,11 +1662,11 @@ var _CoFeed = class _CoFeed extends CoValueBase {
    * @category Subscription & Loading
    */
   ensureLoaded(options) {
-    return ensureCoValueLoaded(this, options);
+    return ensureCoValueLoaded(this.coFeed, options);
   }
   subscribe(...args) {
     const { options, listener } = parseSubscribeRestArgs(args);
-    return subscribeToExistingCoValue(this, options, listener);
+    return subscribeToExistingCoValue(this.coFeed, options, listener);
   }
   /**
    * Wait for the `CoFeed` to be uploaded to the other peers.
@@ -1453,11 +1674,20 @@ var _CoFeed = class _CoFeed extends CoValueBase {
    * @category Subscription & Loading
    */
   waitForSync(options) {
-    return this._raw.core.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;
   }
 };
-_CoFeed.prototype._type = "CoStream";
-var CoFeed = _CoFeed;
 function entryFromRawEntry(accessFrom, rawEntry, loadedAs, accountID, itemField) {
   return {
     get value() {
@@ -1501,18 +1731,20 @@ function entryFromRawEntry(accessFrom, rawEntry, loadedAs, accountID, itemField)
 var CoStreamPerAccountProxyHandler = (innerTarget) => ({
   get(_target, key, receiver) {
     if (typeof key === "string" && key.startsWith("co_")) {
-      const rawEntry = innerTarget._raw.lastItemBy(key);
+      const rawEntry = innerTarget.$jazz.raw.lastItemBy(key);
       if (!rawEntry) return;
       const entry = entryFromRawEntry(
         receiver,
         rawEntry,
-        innerTarget._loadedAs,
+        innerTarget.$jazz.loadedAs,
         key,
-        innerTarget._schema[ItemsSym]
+        innerTarget.$jazz.schema[ItemsSym]
       );
       Object.defineProperty(entry, "all", {
         get: () => {
-          const allRawEntries = innerTarget._raw.itemsBy(key);
+          const allRawEntries = innerTarget.$jazz.raw.itemsBy(
+            key
+          );
           return function* () {
             while (true) {
               const rawEntry2 = allRawEntries.next();
@@ -1520,9 +1752,9 @@ var CoStreamPerAccountProxyHandler = (innerTarget) => ({
               yield entryFromRawEntry(
                 receiver,
                 rawEntry2.value,
-                innerTarget._loadedAs,
+                innerTarget.$jazz.loadedAs,
                 key,
-                innerTarget._schema[ItemsSym]
+                innerTarget.$jazz.schema[ItemsSym]
               );
             }
           }();
@@ -1534,7 +1766,7 @@ var CoStreamPerAccountProxyHandler = (innerTarget) => ({
     }
   },
   ownKeys(_target) {
-    return Array.from(innerTarget._raw.accounts());
+    return Array.from(innerTarget.$jazz.raw.accounts());
   },
   getOwnPropertyDescriptor(_target, key) {
     if (typeof key === "string" && key.startsWith("co_")) {
@@ -1552,19 +1784,19 @@ var CoStreamPerSessionProxyHandler = (innerTarget, accessFrom) => ({
   get(_target, key, receiver) {
     if (typeof key === "string" && key.includes("session")) {
       const sessionID = key;
-      const rawEntry = innerTarget._raw.lastItemIn(sessionID);
+      const rawEntry = innerTarget.$jazz.raw.lastItemIn(sessionID);
       if (!rawEntry) return;
       const by = cojsonInternals3.accountOrAgentIDfromSessionID(sessionID);
       const entry = entryFromRawEntry(
         accessFrom,
         rawEntry,
-        innerTarget._loadedAs,
+        innerTarget.$jazz.loadedAs,
         cojsonInternals3.isAccountID(by) ? by : void 0,
-        innerTarget._schema[ItemsSym]
+        innerTarget.$jazz.schema[ItemsSym]
       );
       Object.defineProperty(entry, "all", {
         get: () => {
-          const allRawEntries = innerTarget._raw.itemsIn(sessionID);
+          const allRawEntries = innerTarget.$jazz.raw.itemsIn(sessionID);
           return function* () {
             while (true) {
               const rawEntry2 = allRawEntries.next();
@@ -1572,9 +1804,9 @@ var CoStreamPerSessionProxyHandler = (innerTarget, accessFrom) => ({
               yield entryFromRawEntry(
                 accessFrom,
                 rawEntry2.value,
-                innerTarget._loadedAs,
+                innerTarget.$jazz.loadedAs,
                 cojsonInternals3.isAccountID(by) ? by : void 0,
-                innerTarget._schema[ItemsSym]
+                innerTarget.$jazz.schema[ItemsSym]
               );
             }
           }();
@@ -1586,7 +1818,7 @@ var CoStreamPerSessionProxyHandler = (innerTarget, accessFrom) => ({
     }
   },
   ownKeys() {
-    return innerTarget._raw.sessions();
+    return innerTarget.$jazz.raw.sessions();
   },
   getOwnPropertyDescriptor(target, key) {
     if (typeof key === "string" && key.startsWith("co_")) {
@@ -1607,16 +1839,15 @@ var FileStream = class extends CoValueBase {
     if ("fromRaw" in options) {
       raw = options.fromRaw;
     } else {
-      const rawOwner = options.owner._raw;
+      const rawOwner = options.owner.$jazz.raw;
       raw = rawOwner.createBinaryStream();
     }
     Object.defineProperties(this, {
-      id: {
-        value: raw.id,
+      [TypeSym]: { value: "BinaryCoStream", enumerable: false },
+      $jazz: {
+        value: new FileStreamJazzApi(this, raw),
         enumerable: false
-      },
-      _type: { value: "BinaryCoStream", enumerable: false },
-      _raw: { value: raw, enumerable: false }
+      }
     });
   }
   /**
@@ -1641,27 +1872,28 @@ var FileStream = class extends CoValueBase {
    * 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._raw.getBinaryStreamInfo();
+    return this.$jazz.raw.getBinaryStreamInfo();
   }
   getChunks(options) {
-    return this._raw.getBinaryChunks(options?.allowUnfinished);
+    return this.$jazz.raw.getBinaryChunks(options?.allowUnfinished);
   }
   isBinaryStreamEnded() {
-    return this._raw.isBinaryStreamEnded();
+    return this.$jazz.raw.isBinaryStreamEnded();
   }
   start(options) {
-    this._raw.startBinaryStream(options);
+    this.$jazz.raw.startBinaryStream(options);
   }
   push(data) {
-    this._raw.pushBinaryStreamChunk(data);
+    this.$jazz.raw.pushBinaryStreamChunk(data);
   }
   end() {
-    this._raw.endBinaryStream();
+    this.$jazz.raw.endBinaryStream();
   }
   toBlob(options) {
     const chunks = this.getChunks({
@@ -1676,6 +1908,7 @@ var FileStream = class extends CoValueBase {
    * 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);
@@ -1712,6 +1945,7 @@ var FileStream = class extends CoValueBase {
    * 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();
@@ -1732,6 +1966,7 @@ var FileStream = class extends CoValueBase {
    * 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);
@@ -1770,8 +2005,6 @@ var FileStream = class extends CoValueBase {
    */
   toJSON() {
     return {
-      id: this.id,
-      _type: this._type,
       ...this.getChunks()
     };
   }
@@ -1782,6 +2015,7 @@ var FileStream = class extends CoValueBase {
   /**
    * Load a `FileStream`
    * @category Subscription & Loading
+   * @deprecated Use `co.fileStream(...).load` instead.
    */
   static async load(id, options) {
     const stream = await loadCoValueWithoutMe(this, id, options);
@@ -1806,12 +2040,29 @@ var FileStream = class extends CoValueBase {
     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, {}, listener);
+    return subscribeToExistingCoValue(this.fileStream, {}, listener);
   }
   /**
    * Wait for the `FileStream` to be uploaded to the other peers.
@@ -1819,146 +2070,114 @@ var FileStream = class extends CoValueBase {
    * @category Subscription & Loading
    */
   waitForSync(options) {
-    return this._raw.core.waitForSync(options);
+    return this.raw.core.waitForSync(options);
   }
 };
 
 // src/tools/coValues/account.ts
 import {
-  ControlledAccount as ControlledAccount3,
-  LocalNode,
+  ControlledAccount as RawControlledAccount,
+  LocalNode as LocalNode2,
   cojsonInternals as cojsonInternals4
 } from "cojson";
-var _Account = class _Account extends CoValueBase {
-  get _schema() {
-    return this.constructor._schema;
-  }
-  get _owner() {
-    return this;
-  }
-  get _loadedAs() {
-    if (this.isLocalNodeOwner) return this;
-    const agent = this._raw.core.node.getCurrentAgent();
-    if (agent instanceof ControlledAccount3) {
-      return coValuesCache.get(
-        agent.account,
-        () => _Account.fromRaw(agent.account)
-      );
-    }
-    return new AnonymousJazzAgent(this._raw.core.node);
-  }
-  getDescriptor(key) {
-    if (key === "profile") {
-      return this._schema.profile;
-    } else if (key === "root") {
-      return this._schema.root;
-    }
-    return void 0;
-  }
-  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
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ) : void 0,
-      root: rootID ? new Ref(
-        rootID,
-        this._loadedAs,
-        this._schema.root,
-        this
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ) : void 0
-    };
-  }
-  /**
-   * Whether this account is the currently active account.
-   */
-  get isMe() {
-    return activeAccountContext.get().id === this.id;
-  }
+var Account = class extends CoValueBase {
   constructor(options) {
     super();
     if (!("fromRaw" in options)) {
       throw new Error("Can only construct account from raw or with .create()");
     }
-    this.isLocalNodeOwner = options.fromRaw.id == options.fromRaw.core.node.getCurrentAgent().id;
+    const proxy = new Proxy(
+      this,
+      AccountAndGroupProxyHandler
+    );
     Object.defineProperties(this, {
-      id: {
-        value: options.fromRaw.id,
+      [TypeSym]: { value: "Account", enumerable: false },
+      $jazz: {
+        value: new AccountJazzApi(proxy, options.fromRaw),
         enumerable: false
-      },
-      _raw: { value: options.fromRaw, enumerable: false },
-      _type: { value: "Account", enumerable: false }
+      }
     });
-    if (this.isLocalNodeOwner) {
-      this.sessionID = options.fromRaw.core.node.currentSessionID;
-    }
-    return new Proxy(this, AccountAndGroupProxyHandler);
+    return proxy;
   }
-  myRole() {
-    if (this.isLocalNodeOwner) {
-      return "admin";
+  /**
+   * 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.id) {
+    if (member === this.$jazz.id) {
       return "admin";
     }
     return void 0;
   }
-  getParentGroups() {
-    return [];
-  }
-  get members() {
-    const ref2 = new Ref(
-      this.id,
-      this._loadedAs,
-      {
-        ref: () => this.constructor,
-        optional: false
-      },
-      this
-    );
-    return [{ id: this.id, role: "admin", ref: ref2, account: this }];
-  }
   canRead(value) {
-    const role = value._owner.getRoleOf(this.id);
+    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 role = value._owner.getRoleOf(this.id);
+    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) {
-    return value._owner.getRoleOf(this.id) === "admin";
-  }
-  async acceptInvite(valueID, inviteSecret, coValueClass) {
-    if (!this.isLocalNodeOwner) {
-      throw new Error("Only a controlled account can accept invites");
-    }
-    await this._raw.core.node.acceptInvite(
-      valueID,
-      inviteSecret
-    );
-    return loadCoValue(
-      coValueClassFromCoValueClassOrSchema(coValueClass),
-      valueID,
-      {
-        loadAs: this
+    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 LocalNode.withNewlyCreatedAccount({
+    const { node } = await LocalNode2.withNewlyCreatedAccount({
       ...options,
       migration: async (rawAccount, _node, creationProps) => {
         const account = new this({
@@ -1972,19 +2191,22 @@ var _Account = class _Account extends CoValueBase {
   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._raw.core.node.syncManager.addPeer(connectedPeers[1]);
+    as.$jazz.localNode.syncManager.addPeer(connectedPeers[1]);
     const account = await this.create({
       creationProps: options.creationProps,
-      crypto: as._raw.core.node.crypto,
+      crypto: as.$jazz.localNode.crypto,
       peersToLoadFrom: [connectedPeers[0]]
     });
-    await account.waitForAllCoValuesSync();
+    await account.$jazz.waitForAllCoValuesSync();
     return account;
   }
   static fromNode(node) {
@@ -1994,10 +2216,7 @@ var _Account = class _Account extends CoValueBase {
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   toJSON() {
-    return {
-      id: this.id,
-      _type: this._type
-    };
+    return {};
   }
   [inspect]() {
     return this.toJSON();
@@ -2006,17 +2225,13 @@ var _Account = class _Account extends CoValueBase {
     await this.migrate(creationProps);
     if (this.profile === void 0 && creationProps) {
       const profileGroup = RegisteredSchemas["Group"].create({ owner: this });
-      this.profile = Profile.create({ name: creationProps.name }, profileGroup);
+      this.$jazz.set(
+        "profile",
+        Profile.create({ name: creationProps.name }, profileGroup)
+      );
       profileGroup.addMember("everyone", "reader");
-    } else if (this.profile && creationProps) {
-      if (this.profile._owner._type !== "Group") {
-        throw new Error("Profile must be owned by a Group", {
-          cause: `The profile of the account "${this.id}" was created with an Account as owner, which is not allowed.`
-        });
-      }
     }
-    const node = this._raw.core.node;
-    const profile = node.expectCoValueLoaded(this._raw.get("profile")).getCurrentContent();
+    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);
@@ -2027,7 +2242,11 @@ var _Account = class _Account extends CoValueBase {
   migrate(creationProps) {
     creationProps;
   }
-  /** @category Subscription & Loading */
+  /**
+   * Load an `Account`
+   * @category Subscription & Loading
+   * @deprecated Use `co.account(...).load` instead.
+   */
   static load(id, options) {
     return loadCoValueWithoutMe(this, id, options);
   }
@@ -2035,13 +2254,113 @@ var _Account = class _Account extends CoValueBase {
     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");
+    }
+  }
+  has(key) {
+    const entry = this.raw.getRaw(key);
+    return entry?.change !== void 0 && entry.change.op !== "del";
+  }
+  /**
+   * 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, options);
+    return ensureCoValueLoaded(this.account, options);
   }
   subscribe(...args) {
     const { options, listener } = parseSubscribeRestArgs(args);
-    return subscribeToExistingCoValue(this, options, listener);
+    return subscribeToExistingCoValue(this.account, options, listener);
   }
   /**
    * Wait for the `Account` to be uploaded to the other peers.
@@ -2049,7 +2368,7 @@ var _Account = class _Account extends CoValueBase {
    * @category Subscription & Loading
    */
   waitForSync(options) {
-    return this._raw.core.waitForSync(options);
+    return this.raw.core.waitForSync(options);
   }
   /**
    * Wait for all the available `CoValues` to be uploaded to the other peers.
@@ -2057,26 +2376,28 @@ var _Account = class _Account extends CoValueBase {
    * @category Subscription & Loading
    */
   waitForAllCoValuesSync(options) {
-    return this._raw.core.node.syncManager.waitForAllCoValuesSync(
-      options?.timeout
-    );
+    return this.localNode.syncManager.waitForAllCoValuesSync(options?.timeout);
   }
-};
-_Account._schema = {
-  profile: {
-    ref: () => Profile,
-    optional: false
-  },
-  root: {
-    ref: () => RegisteredSchemas["CoMap"],
-    optional: true
+  /** @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 AnonymousJazzAgent(this.localNode);
   }
 };
-var Account = _Account;
 var AccountAndGroupProxyHandler = {
   get(target, key, receiver) {
     if (key === "profile" || key === "root") {
-      const id = target._raw.get(key);
+      const id = target.$jazz.raw.get(key);
       if (id) {
         return accessChildByKey(target, id, key);
       } else {
@@ -2087,26 +2408,13 @@ var AccountAndGroupProxyHandler = {
     }
   },
   set(target, key, value, receiver) {
-    if ((key === "profile" || key === "root") && typeof value === "object" && SchemaInit in value) {
+    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 (key === "profile") {
-      if (value) {
-        target._raw.set(
-          "profile",
-          value.id,
-          "trusting"
-        );
-      }
-      return true;
-    } else if (key === "root") {
+    } else if (target instanceof Account && (key === "profile" || key === "root")) {
       if (value) {
-        target._raw.set(
-          "root",
-          value.id,
-          "trusting"
-        );
+        target.$jazz.set(key, value);
       }
       return true;
     } else {
@@ -2124,35 +2432,12 @@ var AccountAndGroupProxyHandler = {
   }
 };
 function isControlledAccount(account) {
-  return account.isLocalNodeOwner;
+  return account.$jazz.isLocalNodeOwner;
 }
 RegisteredSchemas["Account"] = Account;
 
 // src/tools/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,
-        this
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ) : void 0,
-      root: rootID ? new Ref(
-        rootID,
-        this._loadedAs,
-        this._schema.root,
-        this
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ) : void 0
-    };
-  }
   /** @deprecated Don't use constructor directly, use .create */
   constructor(options) {
     super();
@@ -2162,43 +2447,49 @@ var _Group = class _Group extends CoValueBase {
     } else {
       const initOwner = options.owner;
       if (!initOwner) throw new Error("No owner provided");
-      if (initOwner._type === "Account" && isControlledAccount(initOwner)) {
-        const rawOwner = initOwner._raw;
+      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, {
-      id: {
-        value: raw.id,
+      $jazz: {
+        value: new GroupJazzApi(proxy, raw),
         enumerable: false
-      },
-      _raw: { value: raw, enumerable: false }
+      }
     });
-    return new Proxy(this, AccountAndGroupProxyHandler);
+    return proxy;
   }
   static create(options) {
     return new this(parseGroupCreateOptions(options));
   }
   myRole() {
-    return this._raw.myRole();
+    return this.$jazz.raw.myRole();
   }
   addMember(member, role) {
-    if (member !== "everyone" && member._type === "Group") {
+    if (member !== "everyone" && member[TypeSym] === "Group") {
       if (role === "writeOnly")
         throw new Error("Cannot add group as member with write-only role");
-      this._raw.extend(member._raw, role);
+      this.$jazz.raw.extend(member.$jazz.raw, role);
     } else if (role !== void 0 && role !== "inherit") {
-      this._raw.addMember(member === "everyone" ? member : member._raw, role);
+      this.$jazz.raw.addMember(
+        member === "everyone" ? member : member.$jazz.raw,
+        role
+      );
     }
   }
   removeMember(member) {
-    if (member !== "everyone" && member._type === "Group") {
-      this._raw.revokeExtend(member._raw);
+    if (member !== "everyone" && member[TypeSym] === "Group") {
+      this.$jazz.raw.revokeExtend(member.$jazz.raw);
     } else {
-      return this._raw.removeMember(
-        member === "everyone" ? member : member._raw
+      return this.$jazz.raw.removeMember(
+        member === "everyone" ? member : member.$jazz.raw
       );
     }
   }
@@ -2210,11 +2501,11 @@ var _Group = class _Group extends CoValueBase {
     };
     for (const accountID of accountIDs) {
       if (!isAccountID(accountID)) continue;
-      const role = this._raw.roleOf(accountID);
+      const role = this.$jazz.raw.roleOf(accountID);
       if (role === "admin" || role === "writer" || role === "reader" || role === "writeOnly") {
         const ref2 = new Ref(
           accountID,
-          this._loadedAs,
+          this.$jazz.loadedAs,
           refEncodedAccountSchema,
           this
         );
@@ -2241,7 +2532,7 @@ var _Group = class _Group extends CoValueBase {
    * @returns The members of the group.
    */
   get members() {
-    return this.getMembersFromKeys(this._raw.getAllMemberKeysSet());
+    return this.getMembersFromKeys(this.$jazz.raw.getAllMemberKeysSet());
   }
   /**
    * Returns the direct members of the group.
@@ -2251,17 +2542,11 @@ var _Group = class _Group extends CoValueBase {
    * @returns The direct members of the group.
    */
   getDirectMembers() {
-    return this.getMembersFromKeys(this._raw.getMemberKeys());
+    return this.getMembersFromKeys(this.$jazz.raw.getMemberKeys());
   }
   getRoleOf(member) {
-    if (member === "me") {
-      return this._raw.roleOf(
-        activeAccountContext.get().id
-      );
-    }
-    return this._raw.roleOf(
-      member === "everyone" ? member : 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.
@@ -2275,7 +2560,7 @@ var _Group = class _Group extends CoValueBase {
     return this;
   }
   getParentGroups() {
-    return this._raw.getParentGroups().map((group) => _Group.fromRaw(group));
+    return this.$jazz.raw.getParentGroups().map((group) => _Group.fromRaw(group));
   }
   /** @category Identity & Permissions
    * Gives members of a parent group membership in this group.
@@ -2285,7 +2570,7 @@ var _Group = class _Group extends CoValueBase {
    * @returns This group.
    */
   extend(parent, roleMapping) {
-    this._raw.extend(parent._raw, roleMapping);
+    this.$jazz.raw.extend(parent.$jazz.raw, roleMapping);
     return this;
   }
   /** @category Identity & Permissions
@@ -2295,7 +2580,7 @@ var _Group = class _Group extends CoValueBase {
    * @returns This group.
    */
   async revokeExtend(parent) {
-    await this._raw.revokeExtend(parent._raw);
+    await this.$jazz.raw.revokeExtend(parent.$jazz.raw);
     return this;
   }
   /** @category Subscription & Loading */
@@ -2306,13 +2591,35 @@ var _Group = class _Group extends CoValueBase {
     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, options);
+    return ensureCoValueLoaded(this.group, options);
   }
   subscribe(...args) {
     const { options, listener } = parseSubscribeRestArgs(args);
-    return subscribeToExistingCoValue(this, options, listener);
+    return subscribeToExistingCoValue(this.group, options, listener);
   }
   /**
    * Wait for the `Group` to be uploaded to the other peers.
@@ -2320,23 +2627,23 @@ var _Group = class _Group extends CoValueBase {
    * @category Subscription & Loading
    */
   waitForSync(options) {
-    return this._raw.core.waitForSync(options);
+    return this.raw.core.waitForSync(options);
   }
 };
-_Group.prototype._type = "Group";
-_Group._schema = {
-  profile: "json",
-  root: "json"
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-};
-Object.defineProperty(_Group.prototype, "_schema", {
-  get: () => _Group._schema
-});
-var Group = _Group;
-RegisteredSchemas["Group"] = Group;
+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 {
@@ -2352,10 +2659,11 @@ var Profile = class extends CoMap {
    * 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?._type === "Account") {
+    if (owner?.[TypeSym] === "Account") {
       throw new Error("Profiles should be owned by a group");
     }
     return super.create(init, options);
@@ -2363,7 +2671,7 @@ var Profile = class extends CoMap {
 };
 
 // src/tools/coValues/inbox.ts
-import { RawAccount as RawAccount4 } from "cojson";
+import { RawAccount as RawAccount2 } from "cojson";
 
 // src/tools/lib/id.ts
 function isCoValueId(id) {
@@ -2372,10 +2680,10 @@ function isCoValueId(id) {
 
 // src/tools/coValues/inbox.ts
 function createInboxRoot(account) {
-  if (!account.isLocalNodeOwner) {
+  if (!account.$jazz.isLocalNodeOwner) {
     throw new Error("Account is not controlled");
   }
-  const rawAccount = account._raw;
+  const rawAccount = account.$jazz.raw;
   const group = rawAccount.core.node.createGroup();
   const messagesFeed = group.createStream();
   const inboxRoot = rawAccount.createMap();
@@ -2391,18 +2699,18 @@ function createInboxRoot(account) {
   };
 }
 async function createInboxMessage(payload, inboxOwner) {
-  const group = payload._raw.group;
-  if (group instanceof RawAccount4) {
+  const group = payload.$jazz.raw.group;
+  if (group instanceof RawAccount2) {
     throw new Error("Inbox messages should be owned by a group");
   }
   group.addMember(inboxOwner, "writer");
   const message = group.createMap({
-    payload: payload.id,
+    payload: payload.$jazz.id,
     result: void 0,
     processed: false,
     error: void 0
   });
-  await payload._raw.core.waitForSync();
+  await payload.$jazz.raw.core.waitForSync();
   await message.core.waitForSync();
   return message;
 }
@@ -2415,10 +2723,10 @@ var Inbox = class _Inbox {
     this.processed = processed;
     this.failed = failed;
   }
-  subscribe(Schema, callback, options = {}) {
+  subscribe(Schema4, callback, options = {}) {
     const processed = /* @__PURE__ */ new Set();
     const failed = /* @__PURE__ */ new Map();
-    const node = this.account._raw.core.node;
+    const node = this.account.$jazz.localNode;
     this.processed.subscribe((stream) => {
       for (const items of Object.values(stream.items)) {
         for (const item of items) {
@@ -2453,7 +2761,7 @@ var Inbox = class _Inbox {
                 );
               }
               return loadCoValue(
-                coValueClassFromCoValueClassOrSchema(Schema),
+                coValueClassFromCoValueClassOrSchema(Schema4),
                 message.get("payload"),
                 {
                   loadAs: account
@@ -2469,7 +2777,7 @@ var Inbox = class _Inbox {
             }).then((result) => {
               const inboxMessage = node.expectCoValueLoaded(item.value).getCurrentContent();
               if (result) {
-                inboxMessage.set("result", result.id);
+                inboxMessage.set("result", result.$jazz.id);
               }
               inboxMessage.set("processed", true);
               this.processed.push(txKey);
@@ -2518,7 +2826,7 @@ var Inbox = class _Inbox {
     if (!profile.inbox) {
       throw new Error("The account has not set up their inbox");
     }
-    const node = account._raw.core.node;
+    const node = account.$jazz.localNode;
     const root = await node.load(profile.inbox);
     if (root === "unavailable") {
       throw new Error("Inbox not found");
@@ -2563,7 +2871,7 @@ var InboxSender = class _InboxSender {
   }
   static async load(inboxOwnerID, currentAccount) {
     currentAccount ||= activeAccountContext.get();
-    const node = currentAccount._raw.core.node;
+    const node = currentAccount.$jazz.localNode;
     const inboxOwnerRaw = await node.load(
       inboxOwnerID
     );
@@ -2574,7 +2882,7 @@ var InboxSender = class _InboxSender {
     if (inboxOwnerProfileRaw === "unavailable") {
       throw new Error("Failed to load the inbox owner profile");
     }
-    if (inboxOwnerProfileRaw.group.roleOf(currentAccount._raw.id) !== "reader" && inboxOwnerProfileRaw.group.roleOf(currentAccount._raw.id) !== "writer" && inboxOwnerProfileRaw.group.roleOf(currentAccount._raw.id) !== "admin") {
+    if (inboxOwnerProfileRaw.group.roleOf(currentAccount.$jazz.raw.id) !== "reader" && inboxOwnerProfileRaw.group.roleOf(currentAccount.$jazz.raw.id) !== "writer" && inboxOwnerProfileRaw.group.roleOf(currentAccount.$jazz.raw.id) !== "admin") {
       throw new Error(
         "Insufficient permissions to access the inbox, make sure its user profile is publicly readable."
       );
@@ -2598,10 +2906,10 @@ async function acceptInvite(invite, account) {
   if (!isCoValueId(id) || !inviteSecret.startsWith("inviteSecret_")) {
     throw new Error("Invalid inbox ticket");
   }
-  if (!account.isLocalNodeOwner) {
+  if (!account.$jazz.isLocalNodeOwner) {
     throw new Error("Account is not controlled");
   }
-  await account._raw.core.node.acceptInvite(id, inviteSecret);
+  await account.$jazz.localNode.acceptInvite(id, inviteSecret);
   return id;
 }
 function getAccountIDfromSessionID(sessionID) {
@@ -2614,44 +2922,9 @@ function getAccountIDfromSessionID(sessionID) {
 }
 
 // src/tools/coValues/coPlainText.ts
-import {
-  ControlledAccount as ControlledAccount4,
-  RawAccount as RawAccount5,
-  stringifyOpID
-} from "cojson";
+import { stringifyOpID } from "cojson";
 import { calcPatch as calcPatch2 } from "fast-myers-diff";
-
-// 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/coValues/coPlainText.ts
 var CoPlainText = class extends String {
-  get _owner() {
-    return this._raw.group instanceof RawAccount5 ? Account.fromRaw(this._raw.group) : Group.fromRaw(this._raw.group);
-  }
-  get _loadedAs() {
-    const agent = this._raw.core.node.getCurrentAgent();
-    if (agent instanceof ControlledAccount4) {
-      return coValuesCache.get(
-        agent.account,
-        () => coValueClassFromCoValueClassOrSchema(
-          RegisteredSchemas["Account"]
-        ).fromRaw(agent.account)
-      );
-    }
-    return new AnonymousJazzAgent(this._raw.core.node);
-  }
   /** @internal */
   constructor(options) {
     if (!options) {
@@ -2662,19 +2935,23 @@ var CoPlainText = class extends String {
       super(options.fromRaw.toString());
       const raw = options.fromRaw;
       Object.defineProperties(this, {
-        id: { value: raw.id, enumerable: false },
-        _type: { value: "CoPlainText", enumerable: false },
-        _raw: { value: raw, enumerable: false }
+        [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._raw.createPlainText(options.text);
+      const raw = options.owner.$jazz.raw.createPlainText(options.text);
       Object.defineProperties(this, {
-        id: { value: raw.id, enumerable: false },
-        _type: { value: "CoPlainText", enumerable: false },
-        _raw: { value: raw, enumerable: false }
+        [TypeSym]: { value: "CoPlainText", enumerable: false },
+        $jazz: {
+          value: new CoTextJazzApi(this, raw),
+          enumerable: false
+        }
       });
       return;
     }
@@ -2693,73 +2970,57 @@ var CoPlainText = class extends String {
    * ```
    *
    * @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._raw.toString().length;
+    return this.$jazz.raw.toString().length;
   }
   toString() {
-    return this._raw.toString();
+    return this.$jazz.raw.toString();
   }
   valueOf() {
-    return this._raw.toString();
+    return this.$jazz.raw.toString();
   }
   toJSON() {
-    return this._raw.toString();
+    return this.$jazz.raw.toString();
   }
   [inspect]() {
     return this.toJSON();
   }
   insertBefore(idx, text) {
-    this._raw.insertBefore(idx, text);
+    this.$jazz.raw.insertBefore(idx, text);
   }
   insertAfter(idx, text) {
-    this._raw.insertAfter(idx, text);
+    this.$jazz.raw.insertAfter(idx, text);
   }
   deleteRange(range) {
-    this._raw.deleteRange(range);
+    this.$jazz.raw.deleteRange(range);
   }
   posBefore(idx) {
-    return this._raw.mapping.opIDbeforeIdx[idx];
+    return this.$jazz.raw.mapping.opIDbeforeIdx[idx];
   }
   posAfter(idx) {
-    return this._raw.mapping.opIDafterIdx[idx];
+    return this.$jazz.raw.mapping.opIDafterIdx[idx];
   }
   idxBefore(pos) {
-    return this._raw.mapping.idxBeforeOpID[stringifyOpID(pos)];
+    return this.$jazz.raw.mapping.idxBeforeOpID[stringifyOpID(pos)];
   }
   idxAfter(pos) {
-    return this._raw.mapping.idxAfterOpID[stringifyOpID(pos)];
+    return this.$jazz.raw.mapping.idxAfterOpID[stringifyOpID(pos)];
   }
+  /** @category Internals */
   static fromRaw(raw) {
     return new this({ fromRaw: raw });
   }
-  /**
-   * 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.deleteRange({ from, to });
-      }
-      if (insert.length > 0) {
-        this.insertBefore(from, this._raw.fromGraphemes(insert));
-      }
-    }
-  }
   /**
    * 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);
@@ -2768,18 +3029,6 @@ var CoPlainText = class extends String {
     const { options, listener } = parseSubscribeRestArgs(args);
     return subscribeToCoValueWithoutMe(this, id, options, listener);
   }
-  /**
-   * 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);
-  }
   /**
    * Allow CoPlainText to behave like a primitive string in most contexts (e.g.,
    * string concatenation, template literals, React rendering, etc.) by implementing
@@ -2792,9 +3041,53 @@ var CoPlainText = class extends String {
    */
   [Symbol.toPrimitive](hint) {
     if (hint === "number") {
-      return Number(this._raw.toString());
+      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));
+      }
     }
-    return this._raw.toString();
+  }
+  /**
+   * 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);
   }
 };
 
@@ -2879,10 +3172,12 @@ var SchemaUnion = class _SchemaUnion extends CoValueBase {
 };
 
 // src/tools/implementation/anonymousJazzAgent.ts
+var _a;
+_a = TypeSym;
 var AnonymousJazzAgent = class {
   constructor(node) {
     this.node = node;
-    this._type = "Anonymous";
+    this[_a] = "Anonymous";
   }
 };
 
@@ -3099,19 +3394,19 @@ function instantiateRefEncodedWithInit(schema, init, parentOwner) {
       `Cannot automatically create CoValue from value: ${JSON.stringify(init)}. Use the CoValue schema's create() method instead.`
     );
   }
-  const node = parentOwner._raw.core.node;
+  const node = parentOwner.$jazz.localNode;
   const rawGroup = node.createGroup();
-  const owner = new Group({ fromRaw: rawGroup });
-  owner.addMember(parentOwner.castAs(Group));
+  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._raw.core.node;
+  const node = instance.$jazz.raw.core.node;
   const migratedCoValues = node._migratedCoValues ??= /* @__PURE__ */ new Set();
-  if ("migrate" in instance && typeof instance.migrate === "function" && instance._type !== "Account" && !migratedCoValues.has(instance.id)) {
-    migratedCoValues.add(instance.id);
+  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");
@@ -3212,19 +3507,34 @@ var JazzError = class _JazzError {
 };
 
 // src/tools/subscribe/utils.ts
-import { RawAccount as RawAccount6 } from "cojson";
-function getOwnerFromRawValue(raw) {
-  const owner = raw.group;
-  return coValuesCache.get(
-    owner,
-    () => owner instanceof RawAccount6 ? coValueClassFromCoValueClassOrSchema(
-      RegisteredSchemas["Account"]
-    ).fromRaw(owner) : RegisteredSchemas["Group"].fromRaw(owner)
+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, "_subscriptionScope", {
+  Object.defineProperty(freshValueInstance.$jazz, "_subscriptionScope", {
     value: subscriptionScope,
     writable: false,
     enumerable: false,
@@ -3273,7 +3583,7 @@ var SubscriptionScope = class _SubscriptionScope {
       if (this.shouldSendUpdates()) {
         if (this.value.type === "loaded") {
           this.updateValue(
-            createCoValue(this.schema, this.value.value._raw, this)
+            createCoValue(this.schema, this.value.value.$jazz.raw, this)
           );
         }
       }
@@ -3334,7 +3644,7 @@ var SubscriptionScope = class _SubscriptionScope {
       return;
     }
     const ruleset = update.core.verified.header.ruleset;
-    const hasAccess = ruleset.type !== "ownedByGroup" || getOwnerFromRawValue(update).myRole() !== void 0;
+    const hasAccess = ruleset.type !== "ownedByGroup" || myRoleForRawValue(update) !== void 0;
     if (!hasAccess) {
       if (this.value.type !== "unauthorized") {
         this.updateValue(
@@ -3358,9 +3668,9 @@ var SubscriptionScope = class _SubscriptionScope {
       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
+      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._raw !== update;
+      this.value.value.$jazz.raw !== update;
       if (this.loadChildren()) {
         this.updateValue(createCoValue(this.schema, update, this));
       } else if (hasChanged) {
@@ -3440,13 +3750,13 @@ var SubscriptionScope = class _SubscriptionScope {
     if (this.value.type !== "loaded") {
       return false;
     }
-    return this.value.value._raw.core.verified.isStreaming();
+    return this.value.value.$jazz.raw.core.verified.isStreaming();
   }
   isFileStream() {
     if (this.value.type !== "loaded") {
       return false;
     }
-    return this.value.value._raw.core.verified.header.meta?.type === "binary";
+    return this.value.value.$jazz.raw.core.verified.header.meta?.type === "binary";
   }
   triggerUpdate() {
     if (!this.shouldSendUpdates()) return;
@@ -3486,10 +3796,10 @@ var SubscriptionScope = class _SubscriptionScope {
     }
     const value = this.value.value;
     this.silenceUpdates = true;
-    if (value._type === "CoMap" || value._type === "Account") {
+    if (value[TypeSym] === "CoMap" || value[TypeSym] === "Account") {
       const map = value;
       this.loadCoMapKey(map, key, true);
-    } else if (value._type === "CoList") {
+    } else if (value[TypeSym] === "CoList") {
       const list = value;
       this.loadCoListKey(list, key, true);
     }
@@ -3524,23 +3834,23 @@ var SubscriptionScope = class _SubscriptionScope {
     const depth = typeof resolve !== "object" || resolve === null ? {} : resolve;
     let hasChanged = false;
     const idsToLoad = new Set(this.idsSubscribed);
-    const coValueType = value._type;
+    const coValueType = value[TypeSym];
     if (Object.keys(depth).length > 0) {
-      if (coValueType === "CoMap" || coValueType === "Account") {
+      if (coValueType === "CoMap" || coValueType === "Account" || coValueType === "Group") {
         const map = value;
-        const keys = "$each" in depth ? map._raw.keys() : Object.keys(depth);
+        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._type === "CoList") {
+      } else if (value[TypeSym] === "CoList") {
         const list = value;
-        const descriptor = list.getItemsDescriptor();
+        const descriptor = list.$jazz.getItemsDescriptor();
         if (descriptor && isRefEncoded(descriptor)) {
-          list._raw.processNewTransactions();
-          const entries = list._raw.entries();
+          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);
@@ -3549,12 +3859,12 @@ var SubscriptionScope = class _SubscriptionScope {
             }
           }
         }
-      } else if (value._type === "CoStream") {
+      } else if (value[TypeSym] === "CoStream") {
         const stream = value;
-        const descriptor = stream.getItemsDescriptor();
+        const descriptor = stream.$jazz.getItemsDescriptor();
         if (descriptor && isRefEncoded(descriptor)) {
-          for (const session of stream._raw.sessions()) {
-            const values = stream._raw.items[session] ?? [];
+          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]) {
@@ -3601,8 +3911,8 @@ var SubscriptionScope = class _SubscriptionScope {
     if (key === "$onError") {
       return void 0;
     }
-    const id = map._raw.get(key);
-    const descriptor = map.getDescriptor(key);
+    const id = map.$jazz.raw.get(key);
+    const descriptor = map.$jazz.getDescriptor(key);
     if (!descriptor) {
       this.childErrors.set(
         key,
@@ -3639,11 +3949,11 @@ var SubscriptionScope = class _SubscriptionScope {
     return void 0;
   }
   loadCoListKey(list, key, depth) {
-    const descriptor = list.getItemsDescriptor();
+    const descriptor = list.$jazz.getItemsDescriptor();
     if (!descriptor || !isRefEncoded(descriptor)) {
       return void 0;
     }
-    const entries = list._raw.entries();
+    const entries = list.$jazz.raw.entries();
     const entry = entries[Number(key)];
     if (!entry) {
       return void 0;
@@ -3704,18 +4014,18 @@ var SubscriptionScope = class _SubscriptionScope {
 
 // src/tools/subscribe/index.ts
 function getSubscriptionScope(value) {
-  const subscriptionScope = value._subscriptionScope;
+  const subscriptionScope = value.$jazz._subscriptionScope;
   if (subscriptionScope) {
     return subscriptionScope;
   }
-  const node = value._raw.core.node;
+  const node = value.$jazz.raw.core.node;
   const resolve = true;
-  const id = value.id;
+  const id = value.$jazz.id;
   const newSubscriptionScope = new SubscriptionScope(node, resolve, id, {
     ref: value.constructor,
     optional: false
   });
-  Object.defineProperty(value, "_subscriptionScope", {
+  Object.defineProperty(value.$jazz, "_subscriptionScope", {
     value: subscriptionScope,
     writable: false,
     enumerable: false,
@@ -3748,7 +4058,7 @@ function accessChildById(parent, childId, schema) {
 
 // src/tools/implementation/createContext.ts
 import {
-  LocalNode as LocalNode2
+  LocalNode as LocalNode3
 } from "cojson";
 async function randomSessionProvider(accountID, crypto) {
   return {
@@ -3772,7 +4082,7 @@ async function createJazzContextFromExistingCredentials({
   );
   const CurrentAccountSchema = PropsAccountSchema ?? RegisteredSchemas["Account"];
   const AccountClass = coValueClassFromCoValueClassOrSchema(CurrentAccountSchema);
-  const node = await LocalNode2.withLoadedAccount({
+  const node = await LocalNode3.withLoadedAccount({
     accountID: credentials.accountID,
     accountSecret: credentials.secret,
     sessionID,
@@ -3812,7 +4122,7 @@ async function createJazzContextForNewAccount({
 }) {
   const CurrentAccountSchema = PropsAccountSchema ?? RegisteredSchemas["Account"];
   const AccountClass = coValueClassFromCoValueClassOrSchema(CurrentAccountSchema);
-  const { node } = await LocalNode2.withNewlyCreatedAccount({
+  const { node } = await LocalNode3.withNewlyCreatedAccount({
     creationProps,
     peersToLoadFrom,
     crypto,
@@ -3878,7 +4188,7 @@ async function createJazzContext(options) {
     });
     if (!options.newAccountProps) {
       await authSecretStorage.setWithoutNotify({
-        accountID: context.account.id,
+        accountID: context.account.$jazz.id,
         secretSeed,
         accountSecret: context.node.getCurrentAgent().agentSecret,
         provider: "anonymous"
@@ -3896,7 +4206,7 @@ function createAnonymousJazzContext({
   storage
 }) {
   const agentSecret = crypto.newRandomAgentSecret();
-  const node = new LocalNode2(
+  const node = new LocalNode3(
     agentSecret,
     crypto.newRandomSessionID(crypto.getAgentID(agentSecret)),
     crypto
@@ -4938,7 +5248,7 @@ var JazzContextManager = class {
         await this.handleAnonymousAccountMigration(prevContext);
       }
       if (this.context && "me" in this.context) {
-        return this.context.me.id;
+        return this.context.me.$jazz.id;
       }
       throw new Error("The registration hasn't created a new account");
     };
@@ -5017,8 +5327,8 @@ var JazzContextManager = class {
     const currentContext = this.context;
     if (prevContext && currentContext && "me" in prevContext && "me" in currentContext) {
       const [prevAccountAsPeer, currentAccountAsPeer] = cojsonInternals5.connectedPeers(
-        prevContext.me.id,
-        currentContext.me.id,
+        prevContext.me.$jazz.id,
+        currentContext.me.$jazz.id,
         {
           peer1role: "client",
           peer2role: "server"
@@ -5029,7 +5339,7 @@ var JazzContextManager = class {
       prevContext.node.syncManager.addPeer(currentAccountAsPeer);
       try {
         await this.props.onAnonymousAccountDiscarded?.(prevContext.me);
-        await prevContext.me.waitForAllCoValuesSync();
+        await prevContext.me.$jazz.waitForAllCoValuesSync();
       } catch (error) {
         console.error("Error onAnonymousAccountDiscarded", error);
       }
@@ -5056,22 +5366,22 @@ function createResolvablePromise() {
 globalThis.devtoolsFormatters = [
   {
     header: (object2) => {
-      if (object2._type === "CoMap") {
+      if (object2[TypeSym] === "CoMap") {
         return ["div", {}, ["span", {}, object2.constructor.name]];
-      } else if (object2._type === "CoList") {
+      } else if (object2[TypeSym] === "CoList") {
         return [
           "div",
           {},
           ["span", {}, object2.constructor.name + "(" + object2.length + ") "]
         ];
-      } else if (object2._type === "Account") {
+      } else if (object2[TypeSym] === "Account") {
         return [
           "div",
           {},
           [
             "span",
             {},
-            object2.constructor.name + "(" + object2._refs.profile.value?.name + (object2.isMe ? " ME" : "") + ")"
+            object2.constructor.name + "(" + object2.$jazz.refs.profile.value?.name + (object2.isMe ? " ME" : "") + ")"
           ]
         ];
       } else {
@@ -5082,7 +5392,7 @@ globalThis.devtoolsFormatters = [
       return true;
     },
     body: function(object2) {
-      if (object2._type === "CoMap" || object2._type === "Account") {
+      if (object2[TypeSym] === "CoMap" || object2[TypeSym] === "Account") {
         return [
           "div",
           { style: "margin-left: 15px" },
@@ -5097,13 +5407,13 @@ globalThis.devtoolsFormatters = [
                 "span",
                 { style: "opacity: 0.5" },
                 ` (pending ${object2._schema[k].name} `,
-                ["object", { object: object2._refs[k] }],
+                ["object", { object: object2.$jazz.refs[k] }],
                 ")"
               ]
             ] : [] : []
           ])
         ];
-      } else if (object2._type === "CoList") {
+      } else if (object2[TypeSym] === "CoList") {
         return [
           "div",
           { style: "margin-left: 15px" },
@@ -5118,7 +5428,7 @@ globalThis.devtoolsFormatters = [
                 "span",
                 { style: "opacity: 0.5" },
                 ` (pending ${object2._schema[ItemsSym].name} `,
-                ["object", { object: object2._refs[i] }],
+                ["object", { object: object2.$jazz.refs[i] }],
                 ")"
               ]
             ] : [] : []
@@ -5166,14 +5476,14 @@ function loadCoValue(cls, id, options) {
 async function ensureCoValueLoaded(existing, options) {
   const response = await loadCoValue(
     existing.constructor,
-    existing.id,
+    existing.$jazz.id,
     {
-      loadAs: existing._loadedAs,
+      loadAs: existing.$jazz.loadedAs,
       resolve: options?.resolve
     }
   );
   if (!response) {
-    throw new Error("Failed to deeply load CoValue " + existing.id);
+    throw new Error("Failed to deeply load CoValue " + existing.$jazz.id);
   }
   return response;
 }
@@ -5213,7 +5523,7 @@ function subscribeToCoValueWithoutMe(cls, id, options, listener) {
 }
 function subscribeToCoValue(cls, id, options, listener) {
   const loadAs = options.loadAs ?? activeAccountContext.get();
-  const node = "node" in loadAs ? loadAs.node : loadAs._raw.core.node;
+  const node = "node" in loadAs ? loadAs.node : loadAs.$jazz.localNode;
   const resolve = options.resolve ?? true;
   let unsubscribed = false;
   const rootNode = new SubscriptionScope(
@@ -5258,9 +5568,9 @@ function subscribeToCoValue(cls, id, options, listener) {
 function subscribeToExistingCoValue(existing, options, listener) {
   return subscribeToCoValue(
     existing.constructor,
-    existing.id,
+    existing.$jazz.id,
     {
-      loadAs: existing._loadedAs,
+      loadAs: existing.$jazz.loadedAs,
       resolve: options?.resolve,
       onUnavailable: options?.onUnavailable,
       onUnauthorized: options?.onUnauthorized
@@ -5272,33 +5582,42 @@ function isAccountInstance(instance) {
   if (typeof instance !== "object" || instance === null) {
     return false;
   }
-  return "_type" in instance && instance._type === "Account";
+  return TypeSym in instance && instance[TypeSym] === "Account";
 }
 function parseCoValueCreateOptions(options) {
-  const Group10 = RegisteredSchemas["Group"];
+  const Group16 = RegisteredSchemas["Group"];
   if (!options) {
-    return { owner: Group10.create(), uniqueness: void 0 };
+    return { owner: Group16.create(), uniqueness: void 0 };
   }
-  if ("_type" in options) {
-    if (options._type === "Account" || options._type === "Group") {
+  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;
-  return {
-    owner: options.owner ?? Group10.create(),
+  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 "_type" in options && isAccountInstance(options) ? { owner: options } : { owner: options.owner ?? activeAccountContext.get() };
+  return TypeSym in options && isAccountInstance(options) ? { owner: options } : { owner: options.owner ?? activeAccountContext.get() };
 }
 async function exportCoValue(cls, id, options) {
   const loadAs = options.loadAs ?? activeAccountContext.get();
-  const node = "node" in loadAs ? loadAs.node : loadAs._raw.core.node;
+  const node = "node" in loadAs ? loadAs.node : loadAs.$jazz.localNode;
   const resolve = options.resolve ?? true;
   const rootNode = new SubscriptionScope(
     node,
@@ -5338,7 +5657,7 @@ function loadContentPiecesFromSubscription(subscription, valuesExported, content
     return;
   }
   valuesExported.add(subscription.id);
-  const core2 = subscription.getCurrentValue()?._raw.core;
+  const core2 = subscription.getCurrentValue()?.$jazz.raw.core;
   if (core2) {
     loadContentPiecesFromCoValue(core2, valuesExported, contentPieces);
   }
@@ -5364,7 +5683,7 @@ function loadContentPiecesFromCoValue(core2, valuesExported, contentPieces) {
 }
 function importContentPieces(contentPieces, loadAs) {
   const account = loadAs ?? Account.getMe();
-  const node = "node" in account ? account.node : account._raw.core.node;
+  const node = "node" in account ? account.node : account.$jazz.localNode;
   for (const piece of contentPieces) {
     node.syncManager.handleNewContent(piece, "import");
   }
@@ -5383,7 +5702,7 @@ export {
   FileStream,
   Account,
   isControlledAccount,
-  Group,
+  Group6 as Group,
   Profile,
   isCoValueId,
   Inbox,
@@ -5412,4 +5731,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-LZOF6WP5.js.map
+//# sourceMappingURL=chunk-IERUTUXB.js.map