jazz-tools 0.13.17 → 0.13.19

package/dist/{chunk-PYBQOYML.js → chunk-4HBHY4I7.js}

@@ -38,7 +38,7 @@ var AnonymousJazzAgent = class {
 };
 
 // src/coValues/interfaces.ts
-import { RawAccount as RawAccount3 } from "cojson";
+import { ControlledAccount, RawAccount as RawAccount3 } from "cojson";
 
 // src/implementation/inspect.ts
 var inspect = Symbol.for("nodejs.util.inspect.custom");
@@ -47,203 +47,100 @@ var inspect = Symbol.for("nodejs.util.inspect.custom");
 var SchemaInit = "$SchemaInit$";
 var ItemsSym = "$items$";
 
-// src/coValues/deepLoading.ts
-function hasRefValue(value, key) {
-  return Boolean(
-    value._refs?.[key]
-  );
-}
-function hasReadAccess(value, key) {
-  return Boolean(
-    value._refs?.[key]?.hasReadAccess()
-  );
-}
-function isOptionalField(value, key) {
-  return value._schema[key]?.optional ?? false;
-}
-function fulfillsDepth(depth, value) {
-  if (depth === true || depth === void 0) {
-    return {
-      status: "fulfilled"
+// src/subscribe/CoValueCoreSubscription.ts
+var CoValueCoreSubscription = class {
+  constructor(node, id, listener) {
+    this.node = node;
+    this.id = id;
+    this.listener = listener;
+    this._unsubscribe = () => {
     };
-  }
-  if (value._type === "CoMap" || value._type === "Group" || value._type === "Account") {
-    const map = value;
-    if ("$each" in depth) {
-      const result = { status: "fulfilled" };
-      for (const [key, item] of Object.entries(value)) {
-        const rawValue = map._raw.get(key);
-        if (rawValue !== void 0 && rawValue !== null) {
-          if (!item) {
-            if (hasReadAccess(map, key)) {
-              result.status = "unfulfilled";
-              continue;
-            } else {
-              return {
-                status: "unauthorized",
-                path: [key],
-                id: rawValue
-              };
-            }
-          }
-          const innerResult = fulfillsDepth(depth.$each, item);
-          if (innerResult.status === "unfulfilled") {
-            result.status = "unfulfilled";
-          } else if (innerResult.status === "unauthorized" && !isOptionalField(value, ItemsSym)) {
-            innerResult.path.unshift(key);
-            return innerResult;
-          }
-        } else if (!isOptionalField(value, ItemsSym)) {
-          return {
-            status: "unfulfilled"
-          };
-        }
-      }
-      return result;
+    this.unsubscribed = false;
+    const entry = this.node.getCoValue(this.id);
+    if (entry?.isAvailable()) {
+      this.subscribe(entry.getCurrentContent());
     } else {
-      const result = { status: "fulfilled" };
-      for (const key of Object.keys(depth)) {
-        const rawValue = map._raw.get(key);
-        if (rawValue === void 0 || rawValue === null) {
-          if (!map._schema?.[key]) {
-            if (map._schema?.[ItemsSym]) {
-              if (isOptionalField(map, ItemsSym)) {
-                continue;
-              } else {
-                throw new Error(
-                  `The ref ${key} requested on ${map.constructor.name} is missing`
-                );
-              }
-            } else {
-              throw new Error(
-                `The ref ${key} requested on ${map.constructor.name} is not defined in the schema`
-              );
-            }
-          } else if (isOptionalField(map, key)) {
-            continue;
-          } else {
-            throw new Error(
-              `The ref ${key} on ${map.constructor.name} is required but missing`
-            );
-          }
+      this.node.loadCoValueCore(this.id).then((value) => {
+        if (this.unsubscribed) return;
+        if (value.isAvailable()) {
+          this.subscribe(value.getCurrentContent());
         } else {
-          const item = value[key];
-          if (!item) {
-            if (hasReadAccess(map, key)) {
-              result.status = "unfulfilled";
-              continue;
-            } else {
-              return {
-                status: "unauthorized",
-                path: [key],
-                id: rawValue
-              };
-            }
-          }
-          const innerResult = fulfillsDepth(depth[key], item);
-          if (innerResult.status === "unfulfilled") {
-            result.status = "unfulfilled";
-          } else if (innerResult.status === "unauthorized" && !isOptionalField(value, key)) {
-            innerResult.path.unshift(key);
-            return innerResult;
-          }
+          this.listener("unavailable");
+          this.subscribeToState();
         }
-      }
-      return result;
+      });
     }
-  } else if (value._type === "CoList") {
-    if ("$each" in depth) {
-      const result = { status: "fulfilled" };
-      const list = value;
-      for (const [key, item] of value.entries()) {
-        const rawValue = list._raw.get(key);
-        if (!rawValue) {
-          if (isOptionalField(value, ItemsSym)) {
-            continue;
-          }
-          throw new Error(
-            `The ref ${key} on ${list.constructor.name} is required but missing`
-          );
-        }
-        if (hasRefValue(value, key)) {
-          if (!item) {
-            if (hasReadAccess(value, key)) {
-              result.status = "unfulfilled";
-              continue;
-            } else {
-              return {
-                status: "unauthorized",
-                path: [key.toString()],
-                id: value._raw.get(key) ?? "undefined"
-              };
-            }
-          }
-          const innerResult = fulfillsDepth(depth.$each, item);
-          if (innerResult.status === "unfulfilled") {
-            result.status = "unfulfilled";
-          } else if (innerResult.status === "unauthorized" && !isOptionalField(value, ItemsSym)) {
-            innerResult.path.unshift(key.toString());
-            return innerResult;
-          }
-        } else if (!isOptionalField(value, ItemsSym)) {
-          return {
-            status: "unfulfilled"
-          };
-        }
+  }
+  subscribeToState() {
+    const entry = this.node.getCoValue(this.id);
+    const handleStateChange = (core, unsubFromStateChange2) => {
+      if (this.unsubscribed) {
+        unsubFromStateChange2();
+        return;
       }
-      return result;
-    }
-    return {
-      status: "fulfilled"
-    };
-  } else if (value._type === "CoStream") {
-    if ("$each" in depth) {
-      const result = { status: "fulfilled" };
-      for (const item of Object.values(value.perSession)) {
-        if (item.ref) {
-          if (!item.value) {
-            if (item.ref.hasReadAccess()) {
-              result.status = "unfulfilled";
-              continue;
-            } else {
-              return {
-                status: "unauthorized",
-                path: [item.ref.id],
-                id: item.ref.id
-              };
-            }
-          }
-          const innerResult = fulfillsDepth(depth.$each, item.value);
-          if (innerResult.status === "unfulfilled") {
-            result.status = "unfulfilled";
-          } else if (innerResult.status === "unauthorized" && !isOptionalField(value, ItemsSym)) {
-            innerResult.path.unshift(item.ref.id);
-            return innerResult;
-          }
-        } else if (!isOptionalField(value, ItemsSym)) {
-          return {
-            status: "unfulfilled"
-          };
-        }
+      if (core.isAvailable()) {
+        this.subscribe(core.getCurrentContent());
+        unsubFromStateChange2();
       }
-      return result;
-    }
-    return {
-      status: "fulfilled"
     };
-  } else if (value._type === "BinaryCoStream" || value._type === "CoPlainText") {
-    return {
-      status: "fulfilled"
+    const unsubFromStateChange = entry.subscribe(handleStateChange);
+    this._unsubscribe = () => {
+      unsubFromStateChange();
     };
-  } else {
-    console.error(value);
-    throw new Error("Unexpected value type: " + value._type);
   }
-}
+  subscribe(value) {
+    if (this.unsubscribed) return;
+    this._unsubscribe = value.subscribe((value2) => {
+      this.listener(value2);
+    });
+    this.listener(value);
+  }
+  unsubscribe() {
+    if (this.unsubscribed) return;
+    this.unsubscribed = true;
+    this._unsubscribe();
+  }
+};
 
-// src/implementation/refs.ts
+// src/subscribe/JazzError.ts
+var JazzError = class _JazzError {
+  constructor(id, type, issues) {
+    this.id = id;
+    this.type = type;
+    this.issues = issues;
+  }
+  toString() {
+    return this.issues.map((issue) => {
+      let message = `${issue.message}`;
+      if (this.id) {
+        message += ` from ${this.id}`;
+      }
+      if (issue.path.length > 0) {
+        message += ` on path ${issue.path.join(".")}`;
+      }
+      return message;
+    }).join("\n");
+  }
+  prependPath(item) {
+    if (this.issues.length === 0) {
+      return this;
+    }
+    const issues = this.issues.map((issue) => {
+      return {
+        ...issue,
+        path: [item].concat(issue.path)
+      };
+    });
+    return new _JazzError(this.id, this.type, issues);
+  }
+};
+
+// src/subscribe/utils.ts
 import { RawAccount, RawGroup } from "cojson";
 
+// src/coValues/registeredSchemas.ts
+var RegisteredSchemas = {};
+
 // src/lib/cache.ts
 var weakMap = /* @__PURE__ */ new WeakMap();
 var coValuesCache = {
@@ -258,114 +155,498 @@ var coValuesCache = {
   }
 };
 
-// src/implementation/refs.ts
-var TRACE_ACCESSES = false;
-var Ref = class _Ref {
-  constructor(id, controlledAccount, schema) {
+// src/subscribe/utils.ts
+function getOwnerFromRawValue(raw) {
+  let owner = raw instanceof RawGroup ? raw : raw.group;
+  return coValuesCache.get(
+    owner,
+    () => owner instanceof RawAccount ? RegisteredSchemas["Account"].fromRaw(owner) : RegisteredSchemas["Group"].fromRaw(owner)
+  );
+}
+function createCoValue(ref2, raw, subscriptionScope) {
+  const freshValueInstance = instantiateRefEncoded(ref2, raw);
+  Object.defineProperty(freshValueInstance, "_subscriptionScope", {
+    value: subscriptionScope,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  return {
+    type: "loaded",
+    value: freshValueInstance,
+    id: subscriptionScope.id
+  };
+}
+
+// src/subscribe/SubscriptionScope.ts
+var SubscriptionScope = class _SubscriptionScope {
+  constructor(node, resolve, id, schema) {
+    this.node = node;
     this.id = id;
-    this.controlledAccount = controlledAccount;
     this.schema = schema;
-    if (!isRefEncoded(schema)) {
-      throw new Error("Ref must be constructed with a ref schema");
-    }
+    this.childNodes = /* @__PURE__ */ new Map();
+    this.childValues = /* @__PURE__ */ new Map();
+    this.childErrors = /* @__PURE__ */ new Map();
+    this.validationErrors = /* @__PURE__ */ new Map();
+    this.dirty = false;
+    this.idsSubscribed = /* @__PURE__ */ new Set();
+    this.autoloaded = /* @__PURE__ */ new Set();
+    this.autoloadedKeys = /* @__PURE__ */ new Set();
+    this.totalValidTransactions = 0;
+    this.silenceUpdates = false;
+    this.handleChildUpdate = (id, value, key) => {
+      if (value.type === "unloaded") {
+        return;
+      }
+      this.childValues.set(id, value);
+      if (value.type === "unavailable" || value.type === "unauthorized") {
+        this.childErrors.set(id, value.prependPath(key ?? id));
+        this.errorFromChildren = this.computeChildErrors();
+      } else if (this.errorFromChildren && this.childErrors.has(id)) {
+        this.childErrors.delete(id);
+        this.errorFromChildren = this.computeChildErrors();
+      }
+      if (this.shouldSendUpdates()) {
+        if (this.value.type === "loaded") {
+          this.updateValue(
+            createCoValue(this.schema, this.value.value._raw, this)
+          );
+        }
+      }
+      this.triggerUpdate();
+    };
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.resolve = resolve;
+    this.value = { type: "unloaded", id };
+    this.subscription = new CoValueCoreSubscription(node, id, (value) => {
+      this.handleUpdate(value);
+    });
   }
-  getNode() {
-    return "node" in this.controlledAccount ? this.controlledAccount.node : this.controlledAccount._raw.core.node;
+  updateValue(value) {
+    this.value = value;
+    this.dirty = true;
+  }
+  handleUpdate(update) {
+    if (update === "unavailable") {
+      if (this.value.type === "unloaded") {
+        this.updateValue(
+          new JazzError(this.id, "unavailable", [
+            {
+              code: "unavailable",
+              message: "The value is unavailable",
+              params: {
+                id: this.id
+              },
+              path: []
+            }
+          ])
+        );
+      }
+      this.triggerUpdate();
+      return;
+    }
+    const owner = getOwnerFromRawValue(update);
+    const ruleset = update.core.verified.header.ruleset;
+    const hasAccess = ruleset.type === "group" || owner.myRole() !== void 0;
+    if (!hasAccess) {
+      if (this.value.type !== "unauthorized") {
+        this.updateValue(
+          new JazzError(this.id, "unauthorized", [
+            {
+              code: "unauthorized",
+              message: "The current user is not authorized to access this value",
+              params: {
+                id: this.id
+              },
+              path: []
+            }
+          ])
+        );
+        this.triggerUpdate();
+      }
+      return;
+    }
+    this.silenceUpdates = true;
+    if (this.value.type !== "loaded") {
+      this.updateValue(createCoValue(this.schema, update, this));
+      this.loadChildren();
+    } else {
+      const hasChanged = update.totalValidTransactions !== this.totalValidTransactions || // Checking the identity of the _raw value makes us cover the cases where the group
+      // has been updated and the coValues that don't update the totalValidTransactions value (e.g. FileStream)
+      this.value.value._raw !== update;
+      if (this.loadChildren()) {
+        this.updateValue(createCoValue(this.schema, update, this));
+      } else if (hasChanged) {
+        this.updateValue(createCoValue(this.schema, update, this));
+      }
+    }
+    this.totalValidTransactions = update.totalValidTransactions;
+    this.silenceUpdates = false;
+    this.triggerUpdate();
   }
-  hasReadAccess() {
-    const node = this.getNode();
-    const raw = node.getLoaded(this.id);
-    if (!raw) {
-      return true;
+  computeChildErrors() {
+    let issues = [];
+    let errorType = "unavailable";
+    if (this.childErrors.size === 0 && this.validationErrors.size === 0) {
+      return void 0;
     }
-    if (raw instanceof RawAccount || raw instanceof RawGroup) {
-      return true;
+    for (const [key, value] of this.childErrors.entries()) {
+      if (this.autoloaded.has(key)) {
+        continue;
+      }
+      errorType = value.type;
+      if (value.issues) {
+        issues.push(...value.issues);
+      }
+    }
+    for (const value of this.validationErrors.values()) {
+      errorType = value.type;
+      if (value.issues) {
+        issues.push(...value.issues);
+      }
+    }
+    if (issues.length) {
+      return new JazzError(this.id, errorType, issues);
     }
-    const group = raw.core.getGroup();
-    if (group instanceof RawAccount) {
-      if (node.account.id !== group.id) {
+    return void 0;
+  }
+  shouldSendUpdates() {
+    if (this.value.type === "unloaded") return false;
+    if (this.value.type !== "loaded") return true;
+    for (const value of this.childValues.values()) {
+      if (value.type === "unloaded" && !this.autoloaded.has(value.id)) {
         return false;
       }
-    } else if (group.myRole() === void 0) {
-      return false;
     }
     return true;
   }
-  getValueWithoutAccessCheck() {
-    const node = this.getNode();
-    const raw = node.getLoaded(this.id);
-    if (raw) {
-      return coValuesCache.get(
-        raw,
-        () => instantiateRefEncoded(this.schema, raw)
-      );
-    } else {
-      return null;
+  triggerUpdate() {
+    if (!this.shouldSendUpdates()) return;
+    if (!this.dirty) return;
+    if (this.subscribers.size === 0) return;
+    if (this.silenceUpdates) return;
+    const error = this.errorFromChildren;
+    const value = this.value;
+    if (error) {
+      this.subscribers.forEach((listener) => listener(error));
+    } else if (value.type !== "unloaded") {
+      this.subscribers.forEach((listener) => listener(value));
     }
+    this.dirty = false;
   }
-  get value() {
-    if (!this.hasReadAccess()) {
-      return null;
-    }
-    return this.getValueWithoutAccessCheck();
+  subscribe(listener) {
+    this.subscribers.add(listener);
+    return () => {
+      this.subscribers.delete(listener);
+    };
   }
-  async loadHelper() {
-    const node = "node" in this.controlledAccount ? this.controlledAccount.node : this.controlledAccount._raw.core.node;
-    const raw = await node.load(this.id);
-    if (raw === "unavailable") {
-      return "unavailable";
-    } else {
-      return new _Ref(this.id, this.controlledAccount, this.schema).value;
+  setListener(listener) {
+    this.subscribers.add(listener);
+    this.triggerUpdate();
+  }
+  subscribeToKey(key) {
+    if (this.resolve === true || !this.resolve) {
+      this.resolve = {};
+    }
+    if (this.resolve.$each || key in this.resolve) {
+      return;
+    }
+    this.resolve[key] = true;
+    this.autoloadedKeys.add(key);
+    if (this.value.type !== "loaded") {
+      return;
+    }
+    const value = this.value.value;
+    this.silenceUpdates = true;
+    if (value._type === "CoMap" || value._type === "Account") {
+      const map = value;
+      this.loadCoMapKey(map, key, true);
+    } else if (value._type === "CoList") {
+      const list = value;
+      this.loadCoListKey(list, key, true);
     }
+    this.silenceUpdates = false;
   }
-  syncLoad() {
-    const node = "node" in this.controlledAccount ? this.controlledAccount.node : this.controlledAccount._raw.core.node;
-    const entry = node.coValuesStore.get(
-      this.id
+  subscribeToId(id, descriptor) {
+    if (this.idsSubscribed.has(id) || this.childValues.has(id)) {
+      return;
+    }
+    this.idsSubscribed.add(id);
+    this.autoloaded.add(id);
+    this.silenceUpdates = true;
+    this.childValues.set(id, { type: "unloaded", id });
+    const child = new _SubscriptionScope(
+      this.node,
+      true,
+      id,
+      descriptor
     );
-    if (entry.highLevelState === "available") {
-      return new _Ref(this.id, this.controlledAccount, this.schema).value;
+    this.childNodes.set(id, child);
+    child.setListener((value) => this.handleChildUpdate(id, value));
+    this.silenceUpdates = false;
+  }
+  loadChildren() {
+    const { resolve } = this;
+    if (this.value.type !== "loaded") {
+      return false;
     }
-    return void 0;
+    const value = this.value.value;
+    const depth = typeof resolve !== "object" || resolve === null ? {} : resolve;
+    let hasChanged = false;
+    const idsToLoad = new Set(this.idsSubscribed);
+    const coValueType = value._type;
+    if (Object.keys(depth).length > 0) {
+      if (coValueType === "CoMap" || coValueType === "Account") {
+        const map = value;
+        const keys = "$each" in depth ? map._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") {
+        const list = value;
+        const descriptor = list.getItemsDescriptor();
+        if (descriptor && isRefEncoded(descriptor)) {
+          list._raw.processNewTransactions();
+          const entries = list._raw.entries();
+          const keys = "$each" in depth ? Object.keys(entries) : Object.keys(depth);
+          for (const key of keys) {
+            const id = this.loadCoListKey(list, key, depth[key] ?? depth.$each);
+            if (id) {
+              idsToLoad.add(id);
+            }
+          }
+        }
+      } else if (value._type === "CoStream") {
+        const stream = value;
+        const descriptor = stream.getItemsDescriptor();
+        if (descriptor && isRefEncoded(descriptor)) {
+          for (const session of stream._raw.sessions()) {
+            const values = stream._raw.items[session] ?? [];
+            for (const [i, item] of values.entries()) {
+              const key = `${session}/${i}`;
+              if (!depth.$each && !depth[key]) {
+                continue;
+              }
+              const id = item.value;
+              if (id) {
+                idsToLoad.add(id);
+                this.loadChildNode(id, depth[key] ?? depth.$each, descriptor);
+                this.validationErrors.delete(key);
+              } else if (!descriptor.optional) {
+                this.validationErrors.set(
+                  key,
+                  new JazzError(void 0, "unavailable", [
+                    {
+                      code: "validationError",
+                      message: `The ref on position ${key} requested on ${stream.constructor.name} is missing`,
+                      params: {},
+                      path: [key]
+                    }
+                  ])
+                );
+              }
+            }
+          }
+        }
+      }
+    }
+    this.errorFromChildren = this.computeChildErrors();
+    for (const id of this.childNodes.keys()) {
+      if (!idsToLoad.has(id)) {
+        hasChanged = true;
+        const childNode = this.childNodes.get(id);
+        if (childNode) {
+          childNode.destroy();
+        }
+        this.childNodes.delete(id);
+        this.childValues.delete(id);
+      }
+    }
+    return hasChanged;
   }
-  async load() {
-    const result = await this.loadHelper();
-    if (result === "unavailable") {
+  loadCoMapKey(map, key, depth) {
+    const id = map._raw.get(key);
+    const descriptor = map.getDescriptor(key);
+    if (!descriptor) {
+      this.childErrors.set(
+        key,
+        new JazzError(void 0, "unavailable", [
+          {
+            code: "validationError",
+            message: `The ref ${key} requested on ${map.constructor.name} is not defined in the schema`,
+            params: {},
+            path: [key]
+          }
+        ])
+      );
       return void 0;
-    } else {
-      return result;
-    }
-  }
-  accessFrom(fromScopeValue, key) {
-    const subScope = subscriptionsScopes.get(fromScopeValue);
-    subScope?.onRefAccessedOrSet(fromScopeValue.id, this.id);
-    TRACE_ACCESSES && console.log(subScope?.scopeID, "accessing", fromScopeValue, key, this.id);
-    if (this.value && subScope) {
-      subscriptionsScopes.set(this.value, subScope);
-    }
-    if (subScope) {
-      const cached = subScope.cachedValues[this.id];
-      if (cached) {
-        TRACE_ACCESSES && console.log("cached", cached);
-        return cached;
-      } else if (this.value !== null) {
-        const freshValueInstance = instantiateRefEncoded(
-          this.schema,
-          this.value._raw
+    }
+    if (isRefEncoded(descriptor)) {
+      if (id) {
+        this.loadChildNode(id, depth, descriptor, key);
+        this.validationErrors.delete(key);
+        return id;
+      } else if (!descriptor.optional) {
+        this.validationErrors.set(
+          key,
+          new JazzError(void 0, "unavailable", [
+            {
+              code: "validationError",
+              message: `The ref ${key} requested on ${map.constructor.name} is missing`,
+              params: {},
+              path: [key]
+            }
+          ])
         );
-        TRACE_ACCESSES && console.log("freshValueInstance", freshValueInstance);
-        subScope.cachedValues[this.id] = freshValueInstance;
-        subscriptionsScopes.set(freshValueInstance, subScope);
-        return freshValueInstance;
-      } else {
-        return null;
       }
+    }
+    return void 0;
+  }
+  loadCoListKey(list, key, depth) {
+    const descriptor = list.getItemsDescriptor();
+    if (!descriptor || !isRefEncoded(descriptor)) {
+      return void 0;
+    }
+    const entries = list._raw.entries();
+    const entry = entries[Number(key)];
+    if (!entry) {
+      return void 0;
+    }
+    const id = entry.value;
+    if (id) {
+      this.loadChildNode(id, depth, descriptor, key);
+      this.validationErrors.delete(key);
+      return id;
+    } else if (!descriptor.optional) {
+      this.validationErrors.set(
+        key,
+        new JazzError(void 0, "unavailable", [
+          {
+            code: "validationError",
+            message: `The ref on position ${key} requested on ${list.constructor.name} is missing`,
+            params: {},
+            path: [key]
+          }
+        ])
+      );
+    }
+    return void 0;
+  }
+  loadChildNode(id, query, descriptor, key) {
+    if (this.childValues.has(id)) {
+      return;
+    }
+    if (key && this.autoloadedKeys.has(key)) {
+      this.autoloaded.add(id);
+    }
+    const resolve = typeof query === "object" && query !== null ? { ...query } : query;
+    this.childValues.set(id, { type: "unloaded", id });
+    const child = new _SubscriptionScope(
+      this.node,
+      resolve,
+      id,
+      descriptor
+    );
+    this.childNodes.set(id, child);
+    child.setListener((value) => this.handleChildUpdate(id, value, key));
+  }
+  destroy() {
+    this.subscription.unsubscribe();
+    this.subscribers.clear();
+    this.childNodes.forEach((child) => child.destroy());
+  }
+};
+
+// src/subscribe/index.ts
+function getSubscriptionScope(value) {
+  const subscriptionScope = value._subscriptionScope;
+  if (subscriptionScope) {
+    return subscriptionScope;
+  }
+  const node = value._raw.core.node;
+  const resolve = true;
+  const id = value.id;
+  const newSubscriptionScope = new SubscriptionScope(node, resolve, id, {
+    ref: value.constructor,
+    optional: false
+  });
+  Object.defineProperty(value, "_subscriptionScope", {
+    value: subscriptionScope,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  return newSubscriptionScope;
+}
+function accessChildByKey(parent, childId, key) {
+  const subscriptionScope = getSubscriptionScope(parent);
+  if (!subscriptionScope.childValues.has(childId)) {
+    subscriptionScope.subscribeToKey(key);
+  }
+  const value = subscriptionScope.childValues.get(childId);
+  if (value?.type === "loaded") {
+    return value.value;
+  } else {
+    return null;
+  }
+}
+function accessChildById(parent, childId, schema) {
+  const subscriptionScope = getSubscriptionScope(parent);
+  subscriptionScope.subscribeToId(childId, schema);
+  const value = subscriptionScope.childValues.get(childId);
+  if (value?.type === "loaded") {
+    return value.value;
+  } else {
+    return null;
+  }
+}
+
+// src/implementation/refs.ts
+var Ref = class {
+  constructor(id, controlledAccount, schema, parent) {
+    this.id = id;
+    this.controlledAccount = controlledAccount;
+    this.schema = schema;
+    this.parent = parent;
+    if (!isRefEncoded(schema)) {
+      throw new Error("Ref must be constructed with a ref schema");
+    }
+  }
+  async load() {
+    const subscriptionScope = getSubscriptionScope(this.parent);
+    subscriptionScope.subscribeToId(this.id, this.schema);
+    const node = subscriptionScope.childNodes.get(this.id);
+    if (!node) {
+      return null;
+    }
+    const value = node.value;
+    if (value?.type === "loaded") {
+      return value.value;
     } else {
-      return this.value;
+      return new Promise((resolve) => {
+        const unsubscribe = node.subscribe((value2) => {
+          if (value2?.type === "loaded") {
+            unsubscribe();
+            resolve(value2.value);
+          } else if (value2?.type === "unavailable") {
+            unsubscribe();
+            resolve(null);
+          } else if (value2?.type === "unauthorized") {
+            unsubscribe();
+            resolve(null);
+          }
+        });
+      });
     }
   }
+  get value() {
+    return accessChildById(this.parent, this.id, this.schema);
+  }
 };
-function makeRefs(getIdForKey, getKeysWithIds, controlledAccount, refSchemaForKey) {
+function makeRefs(parent, getIdForKey, getKeysWithIds, controlledAccount, refSchemaForKey) {
   const refs = {};
   return new Proxy(refs, {
     get(_target, key) {
@@ -375,7 +656,8 @@ function makeRefs(getIdForKey, getKeysWithIds, controlledAccount, refSchemaForKe
             yield new Ref(
               getIdForKey(key2),
               controlledAccount,
-              refSchemaForKey(key2)
+              refSchemaForKey(key2),
+              parent
             );
           }
         };
@@ -389,7 +671,8 @@ function makeRefs(getIdForKey, getKeysWithIds, controlledAccount, refSchemaForKe
       return new Ref(
         id,
         controlledAccount,
-        refSchemaForKey(key)
+        refSchemaForKey(key),
+        parent
       );
     },
     ownKeys() {
@@ -498,119 +781,10 @@ function instantiateRefEncoded(schema, raw) {
   ).fromRaw(raw);
 }
 
-// src/implementation/subscriptionScope.ts
-var subscriptionsScopes = /* @__PURE__ */ new WeakMap();
-var SubscriptionScope = class {
-  constructor(root, rootSchema, onUpdate) {
-    this.scopeID = `scope-${Math.random().toString(36).slice(2)}`;
-    this.entries = /* @__PURE__ */ new Map();
-    this.scheduledUpdate = false;
-    this.cachedValues = {};
-    this.parents = {};
-    this.syncResolution = false;
-    this.unsubscribeAll = () => {
-      for (const entry of this.entries.values()) {
-        if (entry.state === "loaded") {
-          entry.rawUnsub();
-        } else {
-          entry.immediatelyUnsub = true;
-        }
-      }
-      this.entries.clear();
-    };
-    this.rootEntry = {
-      state: "loaded",
-      value: root._raw,
-      rawUnsub: () => {
-      }
-      // placeholder
-    };
-    this.entries.set(root.id, this.rootEntry);
-    subscriptionsScopes.set(root, this);
-    this.subscriber = root._loadedAs;
-    this.scheduleUpdate = () => {
-      const value = rootSchema.fromRaw(this.rootEntry.value);
-      subscriptionsScopes.set(value, this);
-      onUpdate(value, this);
-    };
-    this.rootEntry.rawUnsub = root._raw.core.subscribe(
-      (rawUpdate) => {
-        if (!rawUpdate) return;
-        this.rootEntry.value = rawUpdate;
-        this.scheduleUpdate();
-      }
-    );
-  }
-  onRefAccessedOrSet(fromId, accessedOrSetId) {
-    if (!accessedOrSetId) {
-      return;
-    }
-    this.parents[accessedOrSetId] = this.parents[accessedOrSetId] || /* @__PURE__ */ new Set();
-    this.parents[accessedOrSetId].add(fromId);
-    if (!this.entries.has(accessedOrSetId)) {
-      const loadingEntry = {
-        state: "loading",
-        immediatelyUnsub: false
-      };
-      this.entries.set(accessedOrSetId, loadingEntry);
-      const node = this.subscriber._type === "Account" ? this.subscriber._raw.core.node : this.subscriber.node;
-      loadCoValue(
-        node,
-        accessedOrSetId,
-        (core) => {
-          if (loadingEntry.state === "loading" && loadingEntry.immediatelyUnsub) {
-            return;
-          }
-          if (core !== "unavailable") {
-            const entry = {
-              state: "loaded",
-              rawUnsub: () => {
-              }
-              // placeholder
-            };
-            this.entries.set(accessedOrSetId, entry);
-            const rawUnsub = core.subscribe((rawUpdate) => {
-              if (!rawUpdate) return;
-              this.invalidate(accessedOrSetId);
-              this.scheduleUpdate();
-            });
-            entry.rawUnsub = rawUnsub;
-          }
-        },
-        this.syncResolution
-      );
-    }
-  }
-  invalidate(id, seen = /* @__PURE__ */ new Set()) {
-    if (seen.has(id)) return;
-    delete this.cachedValues[id];
-    seen.add(id);
-    for (const parent of this.parents[id] || []) {
-      this.invalidate(parent, seen);
-    }
-  }
-};
-function loadCoValue(node, id, callback, syncResolution) {
-  const entry = node.coValuesStore.get(id);
-  if (entry.isAvailable() && syncResolution) {
-    callback(entry.core);
-  } else {
-    void node.loadCoValueCore(id).then((core) => {
-      callback(core);
-    });
-  }
-}
-
 // src/implementation/createContext.ts
 import {
-  ControlledAgent,
   LocalNode
 } from "cojson";
-
-// src/coValues/registeredSchemas.ts
-var RegisteredSchemas = {};
-
-// src/implementation/createContext.ts
 async function randomSessionProvider(accountID, crypto) {
   return {
     sessionID: crypto.newRandomSessionID(accountID),
@@ -737,7 +911,7 @@ async function createJazzContext(options) {
       await authSecretStorage.setWithoutNotify({
         accountID: context.account.id,
         secretSeed,
-        accountSecret: context.node.account.agentSecret,
+        accountSecret: context.node.getCurrentAgent().agentSecret,
         provider: "anonymous"
       });
     }
@@ -752,10 +926,9 @@ async function createAnonymousJazzContext({
   crypto
 }) {
   const agentSecret = crypto.newRandomAgentSecret();
-  const rawAgent = new ControlledAgent(agentSecret, crypto);
   const node = new LocalNode(
-    rawAgent,
-    crypto.newRandomSessionID(rawAgent.id),
+    agentSecret,
+    crypto.newRandomSessionID(crypto.getAgentID(agentSecret)),
     crypto
   );
   for (const peer of peersToLoadFrom) {
@@ -854,21 +1027,19 @@ function isCoValueClass(value) {
 }
 var CoValueBase = class {
   get _owner() {
-    const owner = this._raw.group instanceof RawAccount3 ? RegisteredSchemas["Account"].fromRaw(this._raw.group) : RegisteredSchemas["Group"].fromRaw(this._raw.group);
-    const subScope = subscriptionsScopes.get(this);
-    if (subScope) {
-      subScope.onRefAccessedOrSet(this.id, owner.id);
-      subscriptionsScopes.set(owner, subScope);
-    }
+    const owner = coValuesCache.get(
+      this._raw.group,
+      () => this._raw.group instanceof RawAccount3 ? RegisteredSchemas["Account"].fromRaw(this._raw.group) : RegisteredSchemas["Group"].fromRaw(this._raw.group)
+    );
     return owner;
   }
   /** @private */
   get _loadedAs() {
-    const rawAccount = this._raw.core.node.account;
-    if (rawAccount instanceof RawAccount3) {
+    const agent = this._raw.core.node.getCurrentAgent();
+    if (agent instanceof ControlledAccount) {
       return coValuesCache.get(
-        rawAccount,
-        () => RegisteredSchemas["Account"].fromRaw(rawAccount)
+        agent.account,
+        () => RegisteredSchemas["Account"].fromRaw(agent.account)
       );
     }
     return new AnonymousJazzAgent(this._raw.core.node);
@@ -897,21 +1068,16 @@ var CoValueBase = class {
   }
   /** @category Type Helpers */
   castAs(cl) {
-    const casted = cl.fromRaw(this._raw);
-    const subscriptionScope = subscriptionsScopes.get(this);
-    if (subscriptionScope) {
-      subscriptionsScopes.set(casted, subscriptionScope);
-    }
-    return casted;
+    return cl.fromRaw(this._raw);
   }
 };
 function loadCoValueWithoutMe(cls, id, options) {
-  return loadCoValue2(cls, id, {
+  return loadCoValue(cls, id, {
     ...options,
     loadAs: options?.loadAs ?? activeAccountContext.get()
   });
 }
-function loadCoValue2(cls, id, options) {
+function loadCoValue(cls, id, options) {
   return new Promise((resolve) => {
     subscribeToCoValue(
       cls,
@@ -919,6 +1085,7 @@ function loadCoValue2(cls, id, options) {
       {
         resolve: options.resolve,
         loadAs: options.loadAs,
+        syncResolution: true,
         onUnavailable: () => {
           resolve(null);
         },
@@ -934,7 +1101,7 @@ function loadCoValue2(cls, id, options) {
   });
 }
 async function ensureCoValueLoaded(existing, options) {
-  const response = await loadCoValue2(
+  const response = await loadCoValue(
     existing.constructor,
     existing.id,
     {
@@ -982,80 +1149,42 @@ function subscribeToCoValueWithoutMe(cls, id, options, listener) {
   );
 }
 function subscribeToCoValue(cls, id, options, listener) {
-  const ref2 = new Ref(id, options.loadAs, { ref: cls, optional: false });
+  const loadAs = options.loadAs ?? activeAccountContext.get();
+  const node = "node" in loadAs ? loadAs.node : loadAs._raw.core.node;
+  const resolve = options.resolve ?? true;
   let unsubscribed = false;
-  let unsubscribe;
-  function subscribe() {
-    const value = ref2.getValueWithoutAccessCheck();
-    if (!value) {
-      options.onUnavailable?.();
-      return;
-    }
+  const rootNode = new SubscriptionScope(node, resolve, id, {
+    ref: cls,
+    optional: false
+  });
+  const handleUpdate = (value) => {
     if (unsubscribed) return;
-    const subscription = new SubscriptionScope(
-      value,
-      cls,
-      (update, subscription2) => {
-        if (subscription2.syncResolution) return;
-        if (!ref2.hasReadAccess()) {
-          console.error(
-            "Not enough permissions to load / subscribe to CoValue",
-            id
-          );
-          options.onUnauthorized?.([]);
-          return;
-        }
-        let result;
-        try {
-          subscription2.syncResolution = true;
-          result = fulfillsDepth(options.resolve, update);
-        } catch (e) {
-          console.error(
-            "Failed to load / subscribe to CoValue",
-            e,
-            e instanceof Error ? e.stack : void 0
-          );
-          options.onUnavailable?.();
-          return;
-        } finally {
-          subscription2.syncResolution = false;
-        }
-        if (result.status === "unauthorized") {
-          console.error(
-            "Not enough permissions to load / subscribe to CoValue",
-            id,
-            "on path",
-            result.path.join("."),
-            "unaccessible value:",
-            result.id
-          );
-          options.onUnauthorized?.(result.path);
-          return;
-        }
-        if (result.status === "fulfilled") {
-          listener(update, subscription2.unsubscribeAll);
-        }
-      }
-    );
-    unsubscribe = subscription.unsubscribeAll;
-  }
-  const sync = options.syncResolution ? ref2.syncLoad() : void 0;
-  if (sync) {
-    subscribe();
-  } else {
-    ref2.load().then(() => subscribe()).catch((e) => {
-      console.error(
-        "Failed to load / subscribe to CoValue",
-        e,
-        e instanceof Error ? e.stack : void 0
-      );
+    if (value.type === "unavailable") {
       options.onUnavailable?.();
-    });
-  }
-  return function unsubscribeAtAnyPoint() {
-    unsubscribed = true;
-    unsubscribe && unsubscribe();
+      console.error(value.toString());
+    } else if (value.type === "unauthorized") {
+      options.onUnauthorized?.();
+      console.error(value.toString());
+    } else if (value.type === "loaded") {
+      listener(value.value, unsubscribe);
+    }
   };
+  let shouldDefer = !options.syncResolution;
+  rootNode.setListener((value) => {
+    if (shouldDefer) {
+      shouldDefer = false;
+      Promise.resolve().then(() => {
+        handleUpdate(value);
+      });
+    } else {
+      handleUpdate(value);
+    }
+  });
+  function unsubscribe() {
+    unsubscribed = true;
+    rootNode.destroy();
+  }
+  return unsubscribe;
 }
 function createCoValueObservable(initialValue = void 0) {
   let currentValue = initialValue;
@@ -1140,15 +1269,13 @@ function parseGroupCreateOptions(options) {
 }
 
 // src/coValues/inbox.ts
-import {
-  RawAccount as RawAccount4
-} from "cojson";
+import { RawAccount as RawAccount4 } from "cojson";
 function createInboxRoot(account) {
   if (!account.isLocalNodeOwner) {
     throw new Error("Account is not controlled");
   }
   const rawAccount = account._raw;
-  const group = rawAccount.createGroup();
+  const group = rawAccount.core.node.createGroup();
   const messagesFeed = group.createStream();
   const inboxRoot = rawAccount.createMap();
   const processedFeed = rawAccount.createStream();
@@ -1224,7 +1351,7 @@ var Inbox = class _Inbox {
                   new Error("Unable to load inbox message " + id)
                 );
               }
-              return loadCoValue2(Schema, message.get("payload"), {
+              return loadCoValue(Schema, message.get("payload"), {
                 loadAs: account
               });
             }).then((value) => {
@@ -1369,7 +1496,7 @@ async function acceptInvite(invite, account) {
   if (!account.isLocalNodeOwner) {
     throw new Error("Account is not controlled");
   }
-  await account._raw.acceptInvite(id, inviteSecret);
+  await account._raw.core.node.acceptInvite(id, inviteSecret);
   return id;
 }
 function getAccountIDfromSessionID(sessionID) {
@@ -1408,32 +1535,34 @@ var _CoMap = class _CoMap extends CoValueBase {
    **/
   get _refs() {
     return makeRefs(
+      this,
       (key) => this._raw.get(key),
       () => {
         const keys = this._raw.keys().filter((key) => {
-          const schema = this._schema[key] || this._schema[ItemsSym];
-          return schema && schema !== "json" && isRefEncoded(schema);
+          const descriptor = this.getDescriptor(key);
+          return descriptor && descriptor !== "json" && isRefEncoded(descriptor);
         });
         return keys;
       },
       this._loadedAs,
-      (key) => this._schema[key] || this._schema[ItemsSym]
+      (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) : new Ref(
+      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
-      ).accessFrom(target, "_edits." + key + ".value"),
-      ref: descriptor !== "json" && isRefEncoded(descriptor) ? new Ref(rawEdit.value, target._loadedAs, descriptor) : void 0,
-      by: rawEdit.by && new Ref(rawEdit.by, target._loadedAs, {
+        descriptor,
+        target
+      ) : void 0,
+      by: rawEdit.by && accessChildById(target, rawEdit.by, {
         ref: RegisteredSchemas["Account"],
         optional: false
-      }).accessFrom(target, "_edits." + key + ".by"),
+      }),
       madeAt: rawEdit.at,
       key
     };
@@ -1447,7 +1576,8 @@ var _CoMap = class _CoMap extends CoValueBase {
         get(_target, key) {
           const rawEdit = map._raw.lastEditAt(key);
           if (!rawEdit) return void 0;
-          const descriptor = map._schema[key];
+          const descriptor = map.getDescriptor(key);
+          if (!descriptor) return void 0;
           return {
             ...map.getEditFromRaw(map, rawEdit, descriptor, key),
             get all() {
@@ -1532,7 +1662,7 @@ var _CoMap = class _CoMap extends CoValueBase {
     };
     for (const key of this._raw.keys()) {
       const tKey = key;
-      const descriptor = this._schema[tKey] || this._schema[ItemsSym];
+      const descriptor = this.getDescriptor(tKey);
       if (!descriptor) {
         continue;
       }
@@ -1572,7 +1702,7 @@ var _CoMap = class _CoMap extends CoValueBase {
     if (init)
       for (const key of Object.keys(init)) {
         const initValue = init[key];
-        const descriptor = this._schema[key] || this._schema[ItemsSym];
+        const descriptor = this.getDescriptor(key);
         if (!descriptor) {
           continue;
         }
@@ -1591,6 +1721,9 @@ 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`.
    *
@@ -1657,7 +1790,7 @@ var _CoMap = class _CoMap extends CoValueBase {
       meta: null,
       uniqueness: unique
     };
-    const crypto = as._type === "Anonymous" ? as.node.crypto : as._raw.core.crypto;
+    const crypto = as._type === "Anonymous" ? as.node.crypto : as._raw.core.node.crypto;
     return cojsonInternals.idforHeader(header, crypto);
   }
   /**
@@ -1678,20 +1811,19 @@ var _CoMap = class _CoMap extends CoValueBase {
     for (const key in newValues) {
       if (Object.prototype.hasOwnProperty.call(newValues, key)) {
         const tKey = key;
-        const descriptor = this._schema[tKey] || this._schema[ItemsSym];
-        if (tKey in this._schema) {
-          const newValue = newValues[tKey];
-          const currentValue = this[tKey];
-          if (descriptor === "json" || "encoded" in descriptor) {
-            if (currentValue !== newValue) {
-              this[tKey] = newValue;
-            }
-          } else if (isRefEncoded(descriptor)) {
-            const currentId = currentValue?.id;
-            const newId = newValue?.id;
-            if (currentId !== newId) {
-              this[tKey] = newValue;
-            }
+        const descriptor = this.getDescriptor(key);
+        if (!descriptor) continue;
+        const newValue = newValues[tKey];
+        const currentValue = this[tKey];
+        if (descriptor === "json" || "encoded" in descriptor) {
+          if (currentValue !== newValue) {
+            this[tKey] = newValue;
+          }
+        } else if (isRefEncoded(descriptor)) {
+          const currentId = currentValue?.id;
+          const newId = newValue?.id;
+          if (currentId !== newId) {
+            this[tKey] = newValue;
           }
         }
       }
@@ -1716,27 +1848,21 @@ var CoMapProxyHandler = {
     } else if (key in target) {
       return Reflect.get(target, key, receiver);
     } else {
-      const schema = target._schema;
-      if (!schema) {
+      if (typeof key !== "string") {
         return void 0;
       }
-      const descriptor = schema[key] || schema[ItemsSym];
-      if (descriptor && typeof key === "string") {
-        const raw = target._raw.get(key);
-        if (descriptor === "json") {
-          return raw;
-        } else if ("encoded" in descriptor) {
-          return raw === void 0 ? void 0 : descriptor.encoded.decode(raw);
-        } else if (isRefEncoded(descriptor)) {
-          return raw === void 0 ? void 0 : new Ref(
-            raw,
-            target._loadedAs,
-            descriptor
-          ).accessFrom(receiver, key);
-        }
-      } else {
+      const descriptor = target.getDescriptor(key);
+      if (!descriptor) {
         return void 0;
       }
+      const raw = target._raw.get(key);
+      if (descriptor === "json") {
+        return raw;
+      } else if ("encoded" in descriptor) {
+        return raw === void 0 ? void 0 : descriptor.encoded.decode(raw);
+      } else if (isRefEncoded(descriptor)) {
+        return raw === void 0 ? void 0 : accessChildByKey(target, raw, key);
+      }
     }
   },
   set(target, key, value, receiver) {
@@ -1745,8 +1871,9 @@ var CoMapProxyHandler = {
       target.constructor._schema[key] = value[SchemaInit];
       return true;
     }
-    const descriptor = target._schema[key] || target._schema[ItemsSym];
-    if (descriptor && typeof key === "string") {
+    const descriptor = target.getDescriptor(key);
+    if (!descriptor) return false;
+    if (typeof key === "string") {
       if (descriptor === "json") {
         target._raw.set(key, value);
       } else if ("encoded" in descriptor) {
@@ -1760,7 +1887,6 @@ var CoMapProxyHandler = {
           }
         } else if (value?.id) {
           target._raw.set(key, value.id);
-          subscriptionsScopes.get(target)?.onRefAccessedOrSet(target.id, value.id);
         } else {
           throw new Error(
             `Cannot set reference ${key} to a non-CoValue. Got ${value}`
@@ -1794,7 +1920,7 @@ var CoMapProxyHandler = {
     if (key in target) {
       return Reflect.getOwnPropertyDescriptor(target, key);
     } else {
-      const descriptor = target._schema[key] || target._schema[ItemsSym];
+      const descriptor = target.getDescriptor(key);
       if (descriptor || key in target._raw.latest) {
         return {
           enumerable: true,
@@ -1805,7 +1931,7 @@ var CoMapProxyHandler = {
     }
   },
   has(target, key) {
-    const descriptor = target._schema?.[key] || target._schema?.[ItemsSym];
+    const descriptor = target.getDescriptor(key);
     if (target._raw && typeof key === "string" && descriptor) {
       return target._raw.get(key) !== void 0;
     } else {
@@ -1813,7 +1939,7 @@ var CoMapProxyHandler = {
     }
   },
   deleteProperty(target, key) {
-    const descriptor = target._schema[key] || target._schema[ItemsSym];
+    const descriptor = target.getDescriptor(key);
     if (typeof key === "string" && descriptor) {
       target._raw.delete(key);
       return true;
@@ -1853,8 +1979,8 @@ var Profile = class extends CoMap {
 
 // src/coValues/account.ts
 import {
+  ControlledAccount as ControlledAccount2,
   LocalNode as LocalNode2,
-  RawAccount as RawAccount5,
   cojsonInternals as cojsonInternals2
 } from "cojson";
 var _Account = class _Account extends CoValueBase {
@@ -1866,12 +1992,23 @@ var _Account = class _Account extends CoValueBase {
   }
   get _loadedAs() {
     if (this.isLocalNodeOwner) return this;
-    const rawAccount = this._raw.core.node.account;
-    if (rawAccount instanceof RawAccount5) {
-      return coValuesCache.get(rawAccount, () => _Account.fromRaw(rawAccount));
+    const agent = this._raw.core.node.getCurrentAgent();
+    if (agent instanceof ControlledAccount2) {
+      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");
@@ -1879,13 +2016,15 @@ var _Account = class _Account extends CoValueBase {
       profile: profileID && new Ref(
         profileID,
         this._loadedAs,
-        this._schema.profile
+        this._schema.profile,
+        this
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       ),
       root: rootID && new Ref(
         rootID,
         this._loadedAs,
-        this._schema.root
+        this._schema.root,
+        this
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       )
     };
@@ -1901,7 +2040,7 @@ var _Account = class _Account extends CoValueBase {
     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.account.id;
+    this.isLocalNodeOwner = options.fromRaw.id == options.fromRaw.core.node.getCurrentAgent().id;
     Object.defineProperties(this, {
       id: {
         value: options.fromRaw.id,
@@ -1933,10 +2072,15 @@ var _Account = class _Account extends CoValueBase {
     return [];
   }
   get members() {
-    const ref2 = new Ref(this.id, this._loadedAs, {
-      ref: () => this.constructor,
-      optional: false
-    });
+    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) {
@@ -1954,11 +2098,11 @@ var _Account = class _Account extends CoValueBase {
     if (!this.isLocalNodeOwner) {
       throw new Error("Only a controlled account can accept invites");
     }
-    await this._raw.acceptInvite(
+    await this._raw.core.node.acceptInvite(
       valueID,
       inviteSecret
     );
-    return loadCoValue2(coValueClass, valueID, {
+    return loadCoValue(coValueClass, valueID, {
       loadAs: this
     });
   }
@@ -1995,7 +2139,7 @@ var _Account = class _Account extends CoValueBase {
   }
   static fromNode(node) {
     return new this({
-      fromRaw: node.account
+      fromRaw: node.expectCurrentAccount("jazz-tools/Account.fromNode")
     });
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -2081,15 +2225,13 @@ _Account._schema = {
 var Account = _Account;
 var AccountAndGroupProxyHandler = {
   get(target, key, receiver) {
-    if (key === "profile") {
-      const ref2 = target._refs.profile;
-      return ref2 ? ref2.accessFrom(receiver, "profile") : (
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        void 0
-      );
-    } else if (key === "root") {
-      const ref2 = target._refs.root;
-      return ref2 ? ref2.accessFrom(receiver, "root") : void 0;
+    if (key === "profile" || key === "root") {
+      const id = target._raw.get(key);
+      if (id) {
+        return accessChildByKey(target, id, key);
+      } else {
+        return void 0;
+      }
     } else {
       return Reflect.get(target, key, receiver);
     }
@@ -2107,13 +2249,11 @@ var AccountAndGroupProxyHandler = {
           "trusting"
         );
       }
-      subscriptionsScopes.get(receiver)?.onRefAccessedOrSet(target.id, value.id);
       return true;
     } else if (key === "root") {
       if (value) {
         target._raw.set("root", value.id);
       }
-      subscriptionsScopes.get(receiver)?.onRefAccessedOrSet(target.id, value.id);
       return true;
     } else {
       return Reflect.set(target, key, value, receiver);
@@ -2219,6 +2359,9 @@ var _CoFeed = class _CoFeed extends CoValueBase {
     }
     return instance;
   }
+  getItemsDescriptor() {
+    return this._schema?.[ItemsSym];
+  }
   /**
    * Push items to this `CoFeed`
    *
@@ -2330,9 +2473,10 @@ function entryFromRawEntry(accessFrom, rawEntry, loadedAs, accountID, itemField)
       } else if ("encoded" in itemField) {
         return itemField.encoded.decode(rawEntry.value);
       } else if (isRefEncoded(itemField)) {
-        return this.ref?.accessFrom(
+        return accessChildById(
           accessFrom,
-          rawEntry.by + rawEntry.tx.sessionID + rawEntry.tx.txIndex + ".value"
+          rawEntry.value,
+          itemField
         );
       } else {
         throw new Error("Invalid item field schema");
@@ -2344,20 +2488,18 @@ function entryFromRawEntry(accessFrom, rawEntry, loadedAs, accountID, itemField)
         return new Ref(
           rawId,
           loadedAs,
-          itemField
+          itemField,
+          accessFrom
         );
       } else {
         return void 0;
       }
     },
     get by() {
-      return accountID && new Ref(accountID, loadedAs, {
+      return accountID && accessChildById(accessFrom, accountID, {
         ref: RegisteredSchemas["Account"],
         optional: false
-      })?.accessFrom(
-        accessFrom,
-        rawEntry.by + rawEntry.tx.sessionID + rawEntry.tx.txIndex + ".by"
-      );
+      });
     },
     madeAt: rawEntry.at,
     tx: rawEntry.tx
@@ -2670,7 +2812,7 @@ var FileStream = class extends CoValueBase {
 };
 
 // src/coValues/coList.ts
-import { RawAccount as RawAccount6 } from "cojson";
+import { ControlledAccount as ControlledAccount3, RawAccount as RawAccount6 } from "cojson";
 import { calcPatch } from "fast-myers-diff";
 var _CoList = class _CoList extends Array {
   /**
@@ -2729,6 +2871,7 @@ var _CoList = class _CoList extends Array {
    **/
   get _refs() {
     return makeRefs(
+      this,
       (idx) => this._raw.get(idx),
       () => Array.from({ length: this._raw.entries().length }, (_, idx) => idx),
       this._loadedAs,
@@ -2740,11 +2883,11 @@ var _CoList = class _CoList extends Array {
     throw new Error("Not implemented");
   }
   get _loadedAs() {
-    const rawAccount = this._raw.core.node.account;
-    if (rawAccount instanceof RawAccount6) {
+    const agent = this._raw.core.node.getCurrentAgent();
+    if (agent instanceof ControlledAccount3) {
       return coValuesCache.get(
-        rawAccount,
-        () => RegisteredSchemas["Account"].fromRaw(rawAccount)
+        agent.account,
+        () => RegisteredSchemas["Account"].fromRaw(agent.account)
       );
     }
     return new AnonymousJazzAgent(this._raw.core.node);
@@ -2752,6 +2895,9 @@ var _CoList = class _CoList extends Array {
   static get [(ItemsSym, Symbol.species)]() {
     return Array;
   }
+  getItemsDescriptor() {
+    return this._schema?.[ItemsSym];
+  }
   constructor(options) {
     super();
     Object.defineProperty(this, "_instanceID", {
@@ -2961,12 +3107,7 @@ var _CoList = class _CoList extends Array {
   }
   /** @category Type Helpers */
   castAs(cl) {
-    const casted = cl.fromRaw(this._raw);
-    const subscriptionScope = subscriptionsScopes.get(this);
-    if (subscriptionScope) {
-      subscriptionsScopes.set(casted, subscriptionScope);
-    }
-    return casted;
+    return cl.fromRaw(this._raw);
   }
   /**
    * Wait for the `CoList` to be uploaded to the other peers.
@@ -2998,11 +3139,7 @@ var CoListProxyHandler = {
       } else if ("encoded" in itemDescriptor) {
         return rawValue === void 0 ? void 0 : itemDescriptor.encoded.decode(rawValue);
       } else if (isRefEncoded(itemDescriptor)) {
-        return rawValue === void 0 ? void 0 : new Ref(
-          rawValue,
-          target._loadedAs,
-          itemDescriptor
-        ).accessFrom(receiver, Number(key));
+        return rawValue === void 0 ? void 0 : accessChildByKey(target, rawValue, key);
       }
     } else if (key === "length") {
       return target._raw.entries().length;
@@ -3074,13 +3211,15 @@ var _Group = class _Group extends CoValueBase {
       profile: profileID && new Ref(
         profileID,
         this._loadedAs,
-        this._schema.profile
+        this._schema.profile,
+        this
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       ),
       root: rootID && new Ref(
         rootID,
         this._loadedAs,
-        this._schema.root
+        this._schema.root,
+        this
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       )
     };
@@ -3096,7 +3235,7 @@ var _Group = class _Group extends CoValueBase {
       if (!initOwner) throw new Error("No owner provided");
       if (initOwner._type === "Account" && isControlledAccount(initOwner)) {
         const rawOwner = initOwner._raw;
-        raw = rawOwner.createGroup();
+        raw = rawOwner.core.node.createGroup();
       } else {
         throw new Error("Can only construct group as a controlled account");
       }
@@ -3136,18 +3275,16 @@ var _Group = class _Group extends CoValueBase {
         const ref2 = new Ref(
           accountID,
           this._loadedAs,
-          refEncodedAccountSchema
+          refEncodedAccountSchema,
+          this
         );
-        const accessRef = () => ref2.accessFrom(this, "members." + accountID);
-        if (!ref2.syncLoad()) {
-          console.warn("Account not loaded", accountID);
-        }
+        const group = this;
         members.push({
           id: accountID,
           role,
           ref: ref2,
           get account() {
-            return accessRef();
+            return accessChildById(group, accountID, refEncodedAccountSchema);
           }
         });
       }
@@ -3217,6 +3354,7 @@ function isAccountID(id) {
 
 // src/coValues/coPlainText.ts
 import {
+  ControlledAccount as ControlledAccount4,
   RawAccount as RawAccount7,
   stringifyOpID
 } from "cojson";
@@ -3226,7 +3364,14 @@ var CoPlainText = class extends String {
     return this._raw.group instanceof RawAccount7 ? Account.fromRaw(this._raw.group) : Group.fromRaw(this._raw.group);
   }
   get _loadedAs() {
-    return Account.fromNode(this._raw.core.node);
+    const agent = this._raw.core.node.getCurrentAgent();
+    if (agent instanceof ControlledAccount4) {
+      return coValuesCache.get(
+        agent.account,
+        () => RegisteredSchemas["Account"].fromRaw(agent.account)
+      );
+    }
+    return new AnonymousJazzAgent(this._raw.core.node);
   }
   constructor(options) {
     super("fromRaw" in options ? options.fromRaw.toString() : options.text);
@@ -3340,11 +3485,6 @@ var ImageDefinition = class extends (_b = CoMap, _a = co.items, _b) {
     this[_a] = co.ref(FileStream);
   }
   highestResAvailable(options) {
-    if (!subscriptionsScopes.get(this)) {
-      console.warn(
-        "highestResAvailable() only makes sense when used within a subscription."
-      );
-    }
     const resolutions = Object.keys(this).filter(
       (key) => key.match(/^\d+x\d+$/)
     );
@@ -3997,10 +4137,10 @@ import { cojsonInternals as cojsonInternals6 } from "cojson";
 function createInviteLink(value, role, baseURL, valueHint) {
   const coValueCore = value._raw.core;
   let currentCoValue = coValueCore;
-  while (currentCoValue.header.ruleset.type === "ownedByGroup") {
+  while (currentCoValue.verified.header.ruleset.type === "ownedByGroup") {
     currentCoValue = currentCoValue.getGroup().core;
   }
-  const { ruleset, meta } = currentCoValue.header;
+  const { ruleset, meta } = currentCoValue.verified.header;
   if (ruleset.type !== "group" || meta?.type === "account") {
     throw new Error("Can't create invite link for object without group");
   }
@@ -4051,7 +4191,7 @@ export {
   activeAccountContext,
   AnonymousJazzAgent,
   CoValueBase,
-  loadCoValue2 as loadCoValue,
+  loadCoValue,
   subscribeToCoValue,
   createCoValueObservable,
   Encoders,
@@ -4086,4 +4226,4 @@ export {
   consumeInviteLink
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-PYBQOYML.js.map
+//# sourceMappingURL=chunk-4HBHY4I7.js.map