jazz-tools 0.8.44 → 0.8.48

package/dist/chunk-6OHBW32Q.js

@@ -0,0 +1,2853 @@
+// src/implementation/anonymousJazzAgent.ts
+var AnonymousJazzAgent = class {
+  constructor(node) {
+    this.node = node;
+    this._type = "Anonymous";
+  }
+};
+
+// src/coValues/interfaces.ts
+import { RawAccount as RawAccount2 } from "cojson";
+
+// src/implementation/symbols.ts
+var SchemaInit = Symbol.for("SchemaInit");
+var ItemsSym = Symbol.for("items");
+var MembersSym = Symbol.for("members");
+
+// src/implementation/inspect.ts
+var inspect = Symbol.for("nodejs.util.inspect.custom");
+
+// src/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/implementation/refs.ts
+var TRACE_ACCESSES = false;
+var Ref = class _Ref {
+  constructor(id, controlledAccount, schema) {
+    this.id = id;
+    this.controlledAccount = controlledAccount;
+    this.schema = schema;
+    if (!isRefEncoded(schema)) {
+      throw new Error("Ref must be constructed with a ref schema");
+    }
+  }
+  get value() {
+    const node = "node" in this.controlledAccount ? this.controlledAccount.node : this.controlledAccount._raw.core.node;
+    const raw = node.getLoaded(this.id);
+    if (raw) {
+      return coValuesCache.get(
+        raw,
+        () => instantiateRefEncoded(this.schema, raw)
+      );
+    } else {
+      return null;
+    }
+  }
+  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;
+    }
+  }
+  async load() {
+    const result = await this.loadHelper();
+    if (result === "unavailable") {
+      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
+        );
+        TRACE_ACCESSES && console.log("freshValueInstance", freshValueInstance);
+        subScope.cachedValues[this.id] = freshValueInstance;
+        subscriptionsScopes.set(freshValueInstance, subScope);
+        return freshValueInstance;
+      } else {
+        return null;
+      }
+    } else {
+      return this.value;
+    }
+  }
+};
+function makeRefs(getIdForKey, getKeysWithIds, controlledAccount, refSchemaForKey) {
+  const refs = {};
+  return new Proxy(refs, {
+    get(_target, key) {
+      if (key === Symbol.iterator) {
+        return function* () {
+          for (const key2 of getKeysWithIds()) {
+            yield new Ref(
+              getIdForKey(key2),
+              controlledAccount,
+              refSchemaForKey(key2)
+            );
+          }
+        };
+      }
+      if (typeof key === "symbol") return void 0;
+      if (key === "length") {
+        return getKeysWithIds().length;
+      }
+      const id = getIdForKey(key);
+      if (!id) return void 0;
+      return new Ref(
+        id,
+        controlledAccount,
+        refSchemaForKey(key)
+      );
+    },
+    ownKeys() {
+      return getKeysWithIds().map((key) => key.toString());
+    },
+    getOwnPropertyDescriptor(target, key) {
+      const id = getIdForKey(key);
+      if (id) {
+        return {
+          enumerable: true,
+          configurable: true,
+          writable: true
+        };
+      } else {
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      }
+    }
+  });
+}
+
+// src/implementation/schema.ts
+var Encoders = {
+  Date: {
+    encode: (value) => value.toISOString(),
+    decode: (value) => new Date(value)
+  }
+};
+var optional = {
+  ref: optionalRef,
+  json() {
+    return { [SchemaInit]: "json" };
+  },
+  encoded(arg) {
+    return { [SchemaInit]: { encoded: arg } };
+  },
+  string: {
+    [SchemaInit]: "json"
+  },
+  number: {
+    [SchemaInit]: "json"
+  },
+  boolean: {
+    [SchemaInit]: "json"
+  },
+  null: {
+    [SchemaInit]: "json"
+  },
+  Date: {
+    [SchemaInit]: { encoded: Encoders.Date }
+  },
+  literal(..._lit) {
+    return { [SchemaInit]: "json" };
+  }
+};
+var co = {
+  string: {
+    [SchemaInit]: "json"
+  },
+  number: {
+    [SchemaInit]: "json"
+  },
+  boolean: {
+    [SchemaInit]: "json"
+  },
+  null: {
+    [SchemaInit]: "json"
+  },
+  Date: {
+    [SchemaInit]: { encoded: Encoders.Date }
+  },
+  literal(..._lit) {
+    return { [SchemaInit]: "json" };
+  },
+  json() {
+    return { [SchemaInit]: "json" };
+  },
+  encoded(arg) {
+    return { [SchemaInit]: { encoded: arg } };
+  },
+  ref,
+  items: ItemsSym,
+  members: MembersSym,
+  optional
+};
+function optionalRef(arg) {
+  return ref(arg, { optional: true });
+}
+function ref(arg, options) {
+  return {
+    [SchemaInit]: {
+      ref: arg,
+      optional: options?.optional || false
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  };
+}
+function isRefEncoded(schema) {
+  return typeof schema === "object" && "ref" in schema && "optional" in schema && typeof schema.ref === "function";
+}
+function instantiateRefEncoded(schema, raw) {
+  return isCoValueClass(schema.ref) ? schema.ref.fromRaw(raw) : schema.ref(
+    raw
+  ).fromRaw(raw);
+}
+
+// src/implementation/subscriptionScope.ts
+var subscriptionsScopes = /* @__PURE__ */ new WeakMap();
+var TRACE_INVALIDATIONS = false;
+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.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.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;
+      void node.loadCoValueCore(accessedOrSetId).then((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;
+        }
+      });
+    }
+  }
+  invalidate(id, fromChild, seen = /* @__PURE__ */ new Set()) {
+    if (seen.has(id)) return;
+    TRACE_INVALIDATIONS && console.log("invalidating", fromChild, "->", id, this.cachedValues[id]);
+    delete this.cachedValues[id];
+    seen.add(id);
+    for (const parent of this.parents[id] || []) {
+      this.invalidate(parent, id, seen);
+    }
+  }
+  unsubscribeAll() {
+    for (const entry of this.entries.values()) {
+      if (entry.state === "loaded") {
+        entry.rawUnsub();
+      } else {
+        entry.immediatelyUnsub = true;
+      }
+    }
+    this.entries.clear();
+  }
+};
+
+// src/coValues/deepLoading.ts
+function fulfillsDepth(depth, value) {
+  if (value._type === "CoMap" || value._type === "Group" || value._type === "Account") {
+    if (Array.isArray(depth) && depth.length === 1) {
+      return Object.entries(value).every(([key, item]) => {
+        return value._refs[key] ? item && fulfillsDepth(depth[0], item) : value._schema[ItemsSym].optional;
+      });
+    } else {
+      for (const key of Object.keys(depth)) {
+        const map = value;
+        if (!map._refs[key] && map._schema[key].optional) {
+          continue;
+        }
+        if (!map[key]) {
+          return false;
+        }
+        if (!fulfillsDepth(depth[key], map[key])) {
+          return false;
+        }
+      }
+      return true;
+    }
+  } else if (value._type === "CoList") {
+    if (depth.length === 0) {
+      return true;
+    } else {
+      const itemDepth = depth[0];
+      return value.every(
+        (item, i) => value._refs[i] ? item && fulfillsDepth(itemDepth, item) : value._schema[ItemsSym].optional
+      );
+    }
+  } else if (value._type === "CoStream") {
+    if (depth.length === 0) {
+      return true;
+    } else {
+      const itemDepth = depth[0];
+      return Object.values(value.perSession).every(
+        (entry) => entry.ref ? entry.value && fulfillsDepth(itemDepth, entry.value) : value._schema[ItemsSym].optional
+      );
+    }
+  } else if (value._type === "BinaryCoStream") {
+    return true;
+  } else {
+    console.error(value);
+    throw new Error("Unexpected value type: " + value._type);
+  }
+}
+
+// src/implementation/createContext.ts
+import {
+  ControlledAgent,
+  LocalNode
+} from "cojson";
+
+// src/coValues/registeredSchemas.ts
+var RegisteredSchemas = {};
+
+// src/implementation/createContext.ts
+var fixedCredentialsAuth = (credentials) => {
+  return {
+    start: async () => ({
+      type: "existing",
+      credentials,
+      saveCredentials: async () => {
+      },
+      onSuccess: () => {
+      },
+      onError: () => {
+      },
+      logOut: () => {
+      }
+    })
+  };
+};
+var ephemeralCredentialsAuth = () => {
+  return {
+    start: async () => ({
+      type: "new",
+      creationProps: { name: "Ephemeral" },
+      saveCredentials: async () => {
+      },
+      onSuccess: () => {
+      },
+      onError: () => {
+      },
+      logOut: () => {
+      }
+    })
+  };
+};
+async function randomSessionProvider(accountID, crypto) {
+  return {
+    sessionID: crypto.newRandomSessionID(accountID),
+    sessionDone: () => {
+    }
+  };
+}
+async function createJazzContext(options) {
+  while (true) {
+    if (!("auth" in options)) {
+      return createAnonymousJazzContext({
+        peersToLoadFrom: options.peersToLoadFrom,
+        crypto: options.crypto
+      });
+    }
+    const { auth, sessionProvider, peersToLoadFrom, crypto } = options;
+    const AccountSchema = options.AccountSchema ?? RegisteredSchemas["Account"];
+    let authResult;
+    try {
+      authResult = await auth.start(crypto);
+    } catch (e) {
+      console.error("error", e);
+      throw e;
+    }
+    if (authResult.type === "existing") {
+      try {
+        const { sessionID, sessionDone } = await sessionProvider(
+          authResult.credentials.accountID,
+          crypto
+        );
+        try {
+          const node = await LocalNode.withLoadedAccount({
+            accountID: authResult.credentials.accountID,
+            accountSecret: authResult.credentials.secret,
+            sessionID,
+            peersToLoadFrom,
+            crypto,
+            migration: async (rawAccount, _node, creationProps) => {
+              const account2 = new AccountSchema({
+                fromRaw: rawAccount
+              });
+              await account2.applyMigration(creationProps);
+            }
+          });
+          const account = AccountSchema.fromNode(node);
+          if (authResult.saveCredentials) {
+            await authResult.saveCredentials({
+              accountID: node.account.id,
+              secret: node.account.agentSecret
+            });
+          }
+          authResult.onSuccess();
+          return {
+            account,
+            done: () => {
+              node.gracefulShutdown();
+              sessionDone();
+            },
+            logOut: () => {
+              node.gracefulShutdown();
+              sessionDone();
+              authResult.logOut();
+            }
+          };
+        } catch (e) {
+          authResult.onError(new Error("Error loading account", { cause: e }));
+          sessionDone();
+        }
+      } catch (e) {
+        authResult.onError(
+          new Error("Error acquiring sessionID", { cause: e })
+        );
+      }
+    } else if (authResult.type === "new") {
+      try {
+        const { node } = await LocalNode.withNewlyCreatedAccount({
+          creationProps: authResult.creationProps,
+          peersToLoadFrom,
+          crypto,
+          initialAgentSecret: authResult.initialSecret,
+          migration: async (rawAccount, _node, creationProps) => {
+            const account2 = new AccountSchema({
+              fromRaw: rawAccount
+            });
+            await account2.applyMigration(creationProps);
+          }
+        });
+        const account = AccountSchema.fromNode(node);
+        await authResult.saveCredentials({
+          accountID: node.account.id,
+          secret: node.account.agentSecret
+        });
+        authResult.onSuccess();
+        return {
+          account,
+          done: () => {
+            node.gracefulShutdown();
+          },
+          logOut: () => {
+            node.gracefulShutdown();
+            authResult.logOut();
+          }
+        };
+      } catch (e) {
+        authResult.onError(new Error("Error creating account", { cause: e }));
+      }
+    }
+  }
+}
+async function createAnonymousJazzContext({
+  peersToLoadFrom,
+  crypto
+}) {
+  const agentSecret = crypto.newRandomAgentSecret();
+  const rawAgent = new ControlledAgent(agentSecret, crypto);
+  const node = new LocalNode(
+    rawAgent,
+    crypto.newRandomSessionID(rawAgent.id),
+    crypto
+  );
+  for (const peer of peersToLoadFrom) {
+    node.syncManager.addPeer(peer);
+  }
+  return {
+    agent: new AnonymousJazzAgent(node),
+    done: () => {
+    },
+    logOut: () => {
+    }
+  };
+}
+
+// src/implementation/devtoolsFormatters.ts
+globalThis.devtoolsFormatters = [
+  {
+    header: (object) => {
+      if (object._type === "CoMap") {
+        return ["div", {}, ["span", {}, object.constructor.name]];
+      } else if (object._type === "CoList") {
+        return [
+          "div",
+          {},
+          ["span", {}, object.constructor.name + "(" + object.length + ") "]
+        ];
+      } else if (object._type === "Account") {
+        return [
+          "div",
+          {},
+          [
+            "span",
+            {},
+            object.constructor.name + "(" + object._refs.profile.value?.name + (object.isMe ? " ME" : "") + ")"
+          ]
+        ];
+      } else {
+        return null;
+      }
+    },
+    hasBody: function() {
+      return true;
+    },
+    body: function(object) {
+      if (object._type === "CoMap" || object._type === "Account") {
+        return [
+          "div",
+          { style: "margin-left: 15px" },
+          ["div", "id: ", ["object", { object: object.id }]],
+          ...Object.entries(object).map(([k, v]) => [
+            "div",
+            { style: "white-space: nowrap;" },
+            ["span", { style: "font-weight: bold; opacity: 0.6" }, k, ": "],
+            ["object", { object: v }],
+            ...typeof object._schema[k] === "function" ? v === null ? [
+              [
+                "span",
+                { style: "opacity: 0.5" },
+                ` (pending ${object._schema[k].name} `,
+                ["object", { object: object._refs[k] }],
+                ")"
+              ]
+            ] : [] : []
+          ])
+        ];
+      } else if (object._type === "CoList") {
+        return [
+          "div",
+          { style: "margin-left: 15px" },
+          ["div", "id: ", ["object", { object: object.id }]],
+          ...object.map((v, i) => [
+            "div",
+            { style: "white-space: nowrap;" },
+            ["span", { style: "font-weight: bold; opacity: 0.6" }, i, ": "],
+            ["object", { object: v }],
+            ...typeof object._schema[ItemsSym] === "function" ? v === null ? [
+              [
+                "span",
+                { style: "opacity: 0.5" },
+                ` (pending ${object._schema[ItemsSym].name} `,
+                ["object", { object: object._refs[i] }],
+                ")"
+              ]
+            ] : [] : []
+          ])
+        ];
+      }
+    }
+  }
+];
+
+// src/coValues/interfaces.ts
+function isCoValueClass(value) {
+  return typeof value === "function" && value.fromRaw !== void 0;
+}
+var CoValueBase = class {
+  get _owner() {
+    const owner = this._raw.group instanceof RawAccount2 ? 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);
+    }
+    return owner;
+  }
+  /** @private */
+  get _loadedAs() {
+    const rawAccount = this._raw.core.node.account;
+    if (rawAccount instanceof RawAccount2) {
+      return coValuesCache.get(
+        rawAccount,
+        () => RegisteredSchemas["Account"].fromRaw(rawAccount)
+      );
+    }
+    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 });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  toJSON() {
+    return {
+      id: this.id,
+      type: this._type,
+      error: "unknown CoValue class"
+    };
+  }
+  [inspect]() {
+    return this.toJSON();
+  }
+  /** @category Type Helpers */
+  castAs(cl) {
+    const casted = cl.fromRaw(this._raw);
+    const subscriptionScope = subscriptionsScopes.get(this);
+    if (subscriptionScope) {
+      subscriptionsScopes.set(casted, subscriptionScope);
+    }
+    return casted;
+  }
+};
+function loadCoValue(cls, id, as, depth) {
+  return new Promise((resolve) => {
+    const unsubscribe = subscribeToCoValue(
+      cls,
+      id,
+      as,
+      depth,
+      (value) => {
+        resolve(value);
+        unsubscribe();
+      },
+      () => {
+        resolve(void 0);
+        unsubscribe();
+      }
+    );
+  });
+}
+function ensureCoValueLoaded(existing, depth) {
+  return loadCoValue(
+    existing.constructor,
+    existing.id,
+    existing._loadedAs,
+    depth
+  );
+}
+function subscribeToCoValue(cls, id, as, depth, listener, onUnavailable) {
+  const ref2 = new Ref(id, as, { ref: cls, optional: false });
+  let unsubscribed = false;
+  let unsubscribe;
+  ref2.load().then((value) => {
+    if (!value) {
+      onUnavailable && onUnavailable();
+      return;
+    }
+    if (unsubscribed) return;
+    const subscription = new SubscriptionScope(
+      value,
+      cls,
+      (update) => {
+        if (fulfillsDepth(depth, update)) {
+          listener(update);
+        }
+      }
+    );
+    unsubscribe = () => subscription.unsubscribeAll();
+  }).catch((e) => {
+    console.error("Failed to load / subscribe to CoValue", e);
+  });
+  return function unsubscribeAtAnyPoint() {
+    unsubscribed = true;
+    unsubscribe && unsubscribe();
+  };
+}
+function createCoValueObservable() {
+  let currentValue = void 0;
+  let subscriberCount = 0;
+  function subscribe(cls, id, as, depth, listener, onUnavailable) {
+    subscriberCount++;
+    const unsubscribe = subscribeToCoValue(
+      cls,
+      id,
+      as,
+      depth,
+      (value) => {
+        currentValue = value;
+        listener();
+      },
+      onUnavailable
+    );
+    return () => {
+      unsubscribe();
+      subscriberCount--;
+      if (subscriberCount === 0) {
+        currentValue = void 0;
+      }
+    };
+  }
+  const observable = {
+    getCurrentValue: () => currentValue,
+    subscribe
+  };
+  return observable;
+}
+function subscribeToExistingCoValue(existing, depth, listener) {
+  return subscribeToCoValue(
+    existing.constructor,
+    existing.id,
+    existing._loadedAs,
+    depth,
+    listener
+  );
+}
+
+// src/coValues/inbox.ts
+import {
+  RawAccount as RawAccount3
+} from "cojson";
+function createInboxRoot(account) {
+  if (!account.isMe) {
+    throw new Error("Account is not controlled");
+  }
+  const rawAccount = account._raw;
+  const group = rawAccount.createGroup();
+  const messagesFeed = group.createStream();
+  const inboxRoot = rawAccount.createMap();
+  const processedFeed = rawAccount.createStream();
+  const failedFeed = rawAccount.createStream();
+  const inviteLink = `${messagesFeed.id}/${group.createInvite("writeOnly")}`;
+  inboxRoot.set("messages", messagesFeed.id);
+  inboxRoot.set("processed", processedFeed.id);
+  inboxRoot.set("failed", failedFeed.id);
+  return {
+    id: inboxRoot.id,
+    inviteLink
+  };
+}
+function createInboxMessage(payload, inboxOwner) {
+  const group = payload._raw.group;
+  if (group instanceof RawAccount3) {
+    throw new Error("Inbox messages should be owned by a group");
+  }
+  group.addMember(inboxOwner, "writer");
+  const message = group.createMap({
+    payload: payload.id,
+    result: void 0,
+    processed: false,
+    error: void 0
+  });
+  return message;
+}
+var Inbox = class _Inbox {
+  constructor(account, root, messages, processed, failed) {
+    this.processing = /* @__PURE__ */ new Set();
+    this.account = account;
+    this.root = root;
+    this.messages = messages;
+    this.processed = processed;
+    this.failed = failed;
+  }
+  subscribe(Schema, callback, options = {}) {
+    const processed = /* @__PURE__ */ new Set();
+    const failed = /* @__PURE__ */ new Map();
+    const node = this.account._raw.core.node;
+    this.processed.subscribe((stream) => {
+      for (const items of Object.values(stream.items)) {
+        for (const item of items) {
+          processed.add(item.value);
+        }
+      }
+    });
+    const { account } = this;
+    const { retries = 3 } = options;
+    let failTimer = void 0;
+    const clearFailTimer = () => {
+      clearTimeout(failTimer);
+      failTimer = void 0;
+    };
+    const handleNewMessages = (stream) => {
+      clearFailTimer();
+      for (const [sessionID, items] of Object.entries(stream.items)) {
+        const accountID = getAccountIDfromSessionID(sessionID);
+        if (!accountID) {
+          console.warn("Received message from unknown account", sessionID);
+          continue;
+        }
+        for (const item of items) {
+          const txKey = `${sessionID}/${item.tx.txIndex}`;
+          if (!processed.has(txKey) && !this.processing.has(txKey)) {
+            this.processing.add(txKey);
+            const id = item.value;
+            node.load(id).then((message) => {
+              if (message === "unavailable") {
+                return Promise.reject(
+                  new Error("Unable to load inbox message " + id)
+                );
+              }
+              return loadCoValue(
+                Schema,
+                message.get("payload"),
+                account,
+                []
+              );
+            }).then((value) => {
+              if (!value) {
+                return Promise.reject(
+                  new Error("Unable to load inbox message " + id)
+                );
+              }
+              return callback(value, accountID);
+            }).then((result) => {
+              const inboxMessage = node.expectCoValueLoaded(item.value).getCurrentContent();
+              if (result) {
+                inboxMessage.set("result", result.id);
+              }
+              inboxMessage.set("processed", true);
+              this.processed.push(txKey);
+              this.processing.delete(txKey);
+            }).catch((error) => {
+              console.error("Error processing inbox message", error);
+              this.processing.delete(txKey);
+              const errors = failed.get(txKey) ?? [];
+              const stringifiedError = String(error);
+              errors.push(stringifiedError);
+              const inboxMessage = node.expectCoValueLoaded(item.value).getCurrentContent();
+              inboxMessage.set("error", stringifiedError);
+              if (errors.length > retries) {
+                inboxMessage.set("processed", true);
+                this.processed.push(txKey);
+                this.failed.push({ errors, value: item.value });
+              } else {
+                failed.set(txKey, errors);
+                if (!failTimer) {
+                  failTimer = setTimeout(
+                    () => handleNewMessages(stream),
+                    100
+                  );
+                }
+              }
+            });
+          }
+        }
+      }
+    };
+    return this.messages.subscribe(handleNewMessages);
+  }
+  static async load(account) {
+    const profile = account.profile;
+    if (!profile) {
+      throw new Error("Account profile should already be loaded");
+    }
+    if (!profile.inbox) {
+      throw new Error("The account has not set up their inbox");
+    }
+    const node = account._raw.core.node;
+    const root = await node.load(profile.inbox);
+    if (root === "unavailable") {
+      throw new Error("Inbox not found");
+    }
+    const [messages, processed, failed] = await Promise.all([
+      node.load(root.get("messages")),
+      node.load(root.get("processed")),
+      node.load(root.get("failed"))
+    ]);
+    if (messages === "unavailable" || processed === "unavailable" || failed === "unavailable") {
+      throw new Error("Inbox not found");
+    }
+    return new _Inbox(account, root, messages, processed, failed);
+  }
+};
+var InboxSender = class _InboxSender {
+  constructor(currentAccount, owner, messages) {
+    this.currentAccount = currentAccount;
+    this.owner = owner;
+    this.messages = messages;
+  }
+  getOwnerAccount() {
+    return this.owner;
+  }
+  sendMessage(message) {
+    const inboxMessage = createInboxMessage(message, this.owner);
+    this.messages.push(inboxMessage.id);
+    return new Promise((resolve, reject) => {
+      inboxMessage.subscribe((message2) => {
+        if (message2.get("processed")) {
+          const error = message2.get("error");
+          if (error) {
+            reject(new Error(error));
+          } else {
+            resolve(
+              message2.get("result")
+            );
+          }
+        }
+      });
+    });
+  }
+  static async load(inboxOwnerID, currentAccount) {
+    const node = currentAccount._raw.core.node;
+    const inboxOwnerRaw = await node.load(
+      inboxOwnerID
+    );
+    if (inboxOwnerRaw === "unavailable") {
+      throw new Error("Failed to load the inbox owner");
+    }
+    const inboxOwnerProfileRaw = await node.load(inboxOwnerRaw.get("profile"));
+    if (inboxOwnerProfileRaw === "unavailable") {
+      throw new Error("Failed to load the inbox owner profile");
+    }
+    const inboxInvite = inboxOwnerProfileRaw.get("inboxInvite");
+    if (!inboxInvite) {
+      throw new Error("The user has not set up their inbox");
+    }
+    const id = await acceptInvite(inboxInvite, currentAccount);
+    const messages = await node.load(id);
+    if (messages === "unavailable") {
+      throw new Error("Inbox not found");
+    }
+    return new _InboxSender(currentAccount, inboxOwnerRaw, messages);
+  }
+};
+async function acceptInvite(invite, account) {
+  const id = invite.slice(0, invite.indexOf("/"));
+  const inviteSecret = invite.slice(invite.indexOf("/") + 1);
+  if (!id?.startsWith("co_z") || !inviteSecret.startsWith("inviteSecret_")) {
+    throw new Error("Invalid inbox ticket");
+  }
+  if (!account.isMe) {
+    throw new Error("Account is not controlled");
+  }
+  await account._raw.acceptInvite(id, inviteSecret);
+  return id;
+}
+function getAccountIDfromSessionID(sessionID) {
+  const until = sessionID.indexOf("_session");
+  const accountID = sessionID.slice(0, until);
+  if (accountID.startsWith("co_z")) {
+    return accountID;
+  }
+  return;
+}
+
+// src/coValues/coMap.ts
+import {
+  cojsonInternals
+} from "cojson";
+var _CoMap = class _CoMap extends CoValueBase {
+  /** @internal */
+  get _schema() {
+    return this.constructor._schema;
+  }
+  /**
+   * If property `prop` is a `co.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(
+      (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);
+        });
+        return keys;
+      },
+      this._loadedAs,
+      (key) => this._schema[key] || this._schema[ItemsSym]
+      // 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(
+        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, {
+        ref: RegisteredSchemas["Account"],
+        optional: false
+      }).accessFrom(target, "_edits." + key + ".by"),
+      madeAt: rawEdit.at
+    };
+  }
+  /** @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._schema[key];
+          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();
+    if (options) {
+      if ("fromRaw" in options) {
+        Object.defineProperties(this, {
+          id: {
+            value: options.fromRaw.id,
+            enumerable: false
+          },
+          _raw: { value: options.fromRaw, enumerable: false }
+        });
+      } else {
+        throw new Error("Invalid CoMap constructor arguments");
+      }
+    }
+    return new Proxy(this, CoMapProxyHandler);
+  }
+  /**
+   * Create a new CoMap with the given initial values and owner.
+   *
+   * The owner (a Group or Account) determines access rights to the CoMap.
+   *
+   * The CoMap will immediately be persisted and synced to connected peers.
+   *
+   * @example
+   * ```ts
+   * const person = Person.create({
+   *   name: "Alice",
+   *   age: 42,
+   *   pet: cat,
+   * }, { owner: friendGroup });
+   * ```
+   *
+   * @category Creation
+   **/
+  static create(init, options) {
+    const instance = new this();
+    const raw = instance.rawFromInit(
+      init,
+      options.owner,
+      options.unique === void 0 ? void 0 : { uniqueness: options.unique }
+    );
+    Object.defineProperties(instance, {
+      id: {
+        value: raw.id,
+        enumerable: false
+      },
+      _raw: { value: raw, enumerable: false }
+    });
+    return instance;
+  }
+  /**
+   * Return a JSON representation of the `CoMap`
+   * @category Content
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  toJSON(_key, seenAbove) {
+    const jsonedFields = this._raw.keys().map((key) => {
+      const tKey = key;
+      const descriptor = this._schema[tKey] || this._schema[ItemsSym];
+      if (descriptor == "json" || "encode" in descriptor) {
+        return [key, this._raw.get(key)];
+      } else if (isRefEncoded(descriptor)) {
+        if (seenAbove?.includes(this[tKey]?.id)) {
+          return [key, { _circular: this[tKey]?.id }];
+        }
+        const jsonedRef = this[tKey]?.toJSON(tKey, [
+          ...seenAbove || [],
+          this.id
+        ]);
+        return [key, jsonedRef];
+      } else {
+        return [key, void 0];
+      }
+    });
+    return {
+      id: this.id,
+      _type: this._type,
+      ...Object.fromEntries(jsonedFields)
+    };
+  }
+  [inspect]() {
+    return this.toJSON();
+  }
+  /**
+   * 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;
+    const rawInit = {};
+    if (init)
+      for (const key of Object.keys(init)) {
+        const initValue = init[key];
+        const descriptor = this._schema[key] || this._schema[ItemsSym];
+        if (!descriptor) {
+          continue;
+        }
+        if (descriptor === "json") {
+          rawInit[key] = initValue;
+        } else if (isRefEncoded(descriptor)) {
+          if (initValue) {
+            rawInit[key] = initValue.id;
+          }
+        } else if ("encoded" in descriptor) {
+          rawInit[key] = descriptor.encoded.encode(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            initValue
+          );
+        }
+      }
+    return rawOwner.createMap(rawInit, null, "private", uniqueness);
+  }
+  /**
+   * Declare a Record-like CoMap schema, by extending `CoMap.Record(...)` and passing the value schema using `co`. Keys are always `string`.
+   *
+   * @example
+   * ```ts
+   * import { co, CoMap } from "jazz-tools";
+   *
+   * class ColorToFruitMap extends CoMap.Record(
+   *  co.ref(Fruit)
+   * ) {}
+   *
+   * // assume we have map: ColorToFruitMap
+   * // and strawberry: Fruit
+   * map["red"] = strawberry;
+   * ```
+   *
+   * @category Declaration
+   */
+  static Record(value) {
+    var _a2, _b2;
+    class RecordLikeCoMap extends (_b2 = _CoMap, _a2 = ItemsSym, _b2) {
+      constructor() {
+        super(...arguments);
+        this[_a2] = value;
+      }
+    }
+    return RecordLikeCoMap;
+  }
+  /**
+   * Load a `CoMap` with a given ID, as a given account.
+   *
+   * `depth` specifies which (if any) fields that reference other CoValues to load as well before resolving.
+   * The `DeeplyLoaded` return type guarantees that corresponding referenced CoValues are loaded to the specified depth.
+   *
+   * You can pass `[]` or `{}` for shallowly loading only this CoMap, or `{ fieldA: depthA, fieldB: depthB }` for recursively loading referenced CoValues.
+   *
+   * Check out the `load` methods on `CoMap`/`CoList`/`CoFeed`/`Group`/`Account` to see which depth structures are valid to nest.
+   *
+   * @example
+   * ```ts
+   * const person = await Person.load(
+   *   "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
+   *   me,
+   *   { pet: {} }
+   * );
+   * ```
+   *
+   * @category Subscription & Loading
+   */
+  static load(id, as, depth) {
+    return loadCoValue(this, id, as, depth);
+  }
+  /**
+   * Load and subscribe to a `CoMap` with a given ID, as a given account.
+   *
+   * Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.
+   *
+   * `depth` specifies which (if any) fields that reference other CoValues to load as well before calling `listener` for the first time.
+   * The `DeeplyLoaded` return type guarantees that corresponding referenced CoValues are loaded to the specified depth.
+   *
+   * You can pass `[]` or `{}` for shallowly loading only this CoMap, or `{ fieldA: depthA, fieldB: depthB }` for recursively loading referenced CoValues.
+   *
+   * Check out the `load` methods on `CoMap`/`CoList`/`CoFeed`/`Group`/`Account` to see which depth structures are valid to nest.
+   *
+   * Returns an unsubscribe function that you should call when you no longer need updates.
+   *
+   * Also see the `useCoState` hook to reactively subscribe to a CoValue in a React component.
+   *
+   * @example
+   * ```ts
+   * const unsub = Person.subscribe(
+   *   "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
+   *   me,
+   *   { pet: {} },
+   *   (person) => console.log(person)
+   * );
+   * ```
+   *
+   * @category Subscription & Loading
+   */
+  static subscribe(id, as, depth, listener) {
+    return subscribeToCoValue(this, id, as, depth, listener);
+  }
+  static findUnique(unique, ownerID, as) {
+    const header = {
+      type: "comap",
+      ruleset: {
+        type: "ownedByGroup",
+        group: ownerID
+      },
+      meta: null,
+      uniqueness: unique
+    };
+    const crypto = as._type === "Anonymous" ? as.node.crypto : as._raw.core.crypto;
+    return cojsonInternals.idforHeader(header, crypto);
+  }
+  /**
+   * 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(depth) {
+    return ensureCoValueLoaded(this, depth);
+  }
+  /**
+   * Given an already loaded `CoMap`, subscribe to updates to the `CoMap` and ensure that the specified fields are loaded to the specified depth.
+   *
+   * Works like `CoMap.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(depth, listener) {
+    return subscribeToExistingCoValue(this, depth, listener);
+  }
+  applyDiff(newValues) {
+    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;
+            }
+          }
+        }
+      }
+    }
+    return this;
+  }
+  /**
+   * Wait for the `CoMap` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForSync(options) {
+    return this._raw.core.waitForSync(options);
+  }
+};
+_CoMap.prototype._type = "CoMap";
+var CoMap = _CoMap;
+var CoMapProxyHandler = {
+  get(target, key, receiver) {
+    if (key === "_schema") {
+      return Reflect.get(target, key);
+    } else if (key in target) {
+      return Reflect.get(target, key, receiver);
+    } else {
+      const schema = target._schema;
+      if (!schema) {
+        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 {
+        return void 0;
+      }
+    }
+  },
+  set(target, key, value, receiver) {
+    if ((typeof key === "string" || ItemsSym) && typeof value === "object" && value !== null && SchemaInit in value) {
+      target.constructor._schema ||= {};
+      target.constructor._schema[key] = value[SchemaInit];
+      return true;
+    }
+    const descriptor = target._schema[key] || target._schema[ItemsSym];
+    if (descriptor && 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 === null) {
+          if (descriptor.optional) {
+            target._raw.set(key, null);
+          } else {
+            throw new Error(`Cannot set required reference ${key} to null`);
+          }
+        } else {
+          target._raw.set(key, value.id);
+          subscriptionsScopes.get(target)?.onRefAccessedOrSet(target.id, value.id);
+        }
+      }
+      return true;
+    } else {
+      return Reflect.set(target, key, value, receiver);
+    }
+  },
+  defineProperty(target, key, attributes) {
+    if ("value" in attributes && typeof attributes.value === "object" && SchemaInit in attributes.value) {
+      target.constructor._schema ||= {};
+      target.constructor._schema[key] = attributes.value[SchemaInit];
+      return true;
+    } else {
+      return Reflect.defineProperty(target, key, attributes);
+    }
+  },
+  ownKeys(target) {
+    const keys = Reflect.ownKeys(target).filter((k) => k !== ItemsSym);
+    for (const key of target._raw.keys()) {
+      if (!keys.includes(key)) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  },
+  getOwnPropertyDescriptor(target, key) {
+    if (key in target) {
+      return Reflect.getOwnPropertyDescriptor(target, key);
+    } else {
+      const descriptor = target._schema[key] || target._schema[ItemsSym];
+      if (descriptor || key in target._raw.latest) {
+        return {
+          enumerable: true,
+          configurable: true,
+          writable: true
+        };
+      }
+    }
+  },
+  has(target, key) {
+    const descriptor = target._schema?.[key] || target._schema?.[ItemsSym];
+    if (target._raw && typeof key === "string" && descriptor) {
+      return target._raw.get(key) !== void 0;
+    } else {
+      return Reflect.has(target, key);
+    }
+  },
+  deleteProperty(target, key) {
+    const descriptor = target._schema[key] || target._schema[ItemsSym];
+    if (typeof key === "string" && descriptor) {
+      target._raw.delete(key);
+      return true;
+    } else {
+      return Reflect.deleteProperty(target, key);
+    }
+  }
+};
+RegisteredSchemas["CoMap"] = CoMap;
+
+// src/coValues/profile.ts
+var Profile = class extends CoMap {
+  constructor() {
+    super(...arguments);
+    this.name = co.string;
+    this.inbox = co.optional.json();
+    this.inboxInvite = co.optional.json();
+  }
+};
+
+// src/coValues/account.ts
+import {
+  LocalNode as LocalNode2,
+  RawAccount as RawAccount4,
+  cojsonInternals as cojsonInternals2
+} from "cojson";
+var _Account = class _Account extends CoValueBase {
+  get _schema() {
+    return this.constructor._schema;
+  }
+  get _owner() {
+    return this;
+  }
+  get _loadedAs() {
+    if (this.isMe) return this;
+    const rawAccount = this._raw.core.node.account;
+    if (rawAccount instanceof RawAccount4) {
+      return coValuesCache.get(rawAccount, () => _Account.fromRaw(rawAccount));
+    }
+    return new AnonymousJazzAgent(this._raw.core.node);
+  }
+  get _refs() {
+    const profileID = this._raw.get("profile");
+    const rootID = this._raw.get("root");
+    return {
+      profile: profileID && new Ref(
+        profileID,
+        this._loadedAs,
+        this._schema.profile
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ),
+      root: rootID && new Ref(
+        rootID,
+        this._loadedAs,
+        this._schema.root
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      )
+    };
+  }
+  constructor(options) {
+    super();
+    if (!("fromRaw" in options)) {
+      throw new Error("Can only construct account from raw or with .create()");
+    }
+    this.isMe = options.fromRaw.id == options.fromRaw.core.node.account.id;
+    Object.defineProperties(this, {
+      id: {
+        value: options.fromRaw.id,
+        enumerable: false
+      },
+      _raw: { value: options.fromRaw, enumerable: false },
+      _type: { value: "Account", enumerable: false }
+    });
+    if (this.isMe) {
+      this.sessionID = options.fromRaw.core.node.currentSessionID;
+    }
+    return new Proxy(this, AccountAndGroupProxyHandler);
+  }
+  myRole() {
+    if (this.isMe) {
+      return "admin";
+    }
+  }
+  async acceptInvite(valueID, inviteSecret, coValueClass) {
+    if (!this.isMe) {
+      throw new Error("Only a controlled account can accept invites");
+    }
+    await this._raw.acceptInvite(
+      valueID,
+      inviteSecret
+    );
+    return loadCoValue(coValueClass, valueID, this, []);
+  }
+  /** @private */
+  static async create(options) {
+    const { node } = await LocalNode2.withNewlyCreatedAccount({
+      ...options,
+      migration: async (rawAccount, _node, creationProps) => {
+        const account = new this({
+          fromRaw: rawAccount
+        });
+        await account.applyMigration?.(creationProps);
+      }
+    });
+    return this.fromNode(node);
+  }
+  static async createAs(as, options) {
+    const connectedPeers = cojsonInternals2.connectedPeers(
+      "creatingAccount",
+      "createdAccount",
+      { peer1role: "server", peer2role: "client" }
+    );
+    as._raw.core.node.syncManager.addPeer(connectedPeers[1]);
+    return this.create({
+      creationProps: options.creationProps,
+      crypto: as._raw.core.node.crypto,
+      peersToLoadFrom: [connectedPeers[0]]
+    });
+  }
+  static fromNode(node) {
+    return new this({
+      fromRaw: node.account
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  toJSON() {
+    return {
+      id: this.id,
+      _type: this._type
+    };
+  }
+  [inspect]() {
+    return this.toJSON();
+  }
+  async applyMigration(creationProps) {
+    if (creationProps) {
+      const profileGroup = RegisteredSchemas["Group"].create({ owner: this });
+      profileGroup.addMember("everyone", "reader");
+      this.profile = Profile.create(
+        { name: creationProps.name },
+        { owner: profileGroup }
+      );
+    }
+    const node = this._raw.core.node;
+    const profile = node.expectCoValueLoaded(this._raw.get("profile")).getCurrentContent();
+    if (!profile.get("inbox")) {
+      const inboxRoot = createInboxRoot(this);
+      profile.set("inbox", inboxRoot.id);
+      profile.set("inboxInvite", inboxRoot.inviteLink);
+    }
+    await this.migrate(creationProps);
+  }
+  // Placeholder method for subclasses to override
+  migrate(creationProps) {
+    creationProps;
+  }
+  /** @category Subscription & Loading */
+  static load(id, as, depth) {
+    return loadCoValue(this, id, as, depth);
+  }
+  /** @category Subscription & Loading */
+  static subscribe(id, as, depth, listener) {
+    return subscribeToCoValue(this, id, as, depth, listener);
+  }
+  /** @category Subscription & Loading */
+  ensureLoaded(depth) {
+    return ensureCoValueLoaded(this, depth);
+  }
+  /** @category Subscription & Loading */
+  subscribe(depth, listener) {
+    return subscribeToExistingCoValue(this, depth, listener);
+  }
+  /**
+   * Wait for the `Account` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForSync(options) {
+    return this._raw.core.waitForSync(options);
+  }
+  /**
+   * Wait for all the available `CoValues` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForAllCoValuesSync(options) {
+    return this._raw.core.node.syncManager.waitForAllCoValuesSync(
+      options?.timeout
+    );
+  }
+};
+_Account._schema = {
+  profile: {
+    ref: () => Profile,
+    optional: false
+  },
+  root: {
+    ref: () => RegisteredSchemas["CoMap"],
+    optional: true
+  }
+};
+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;
+    } else {
+      return Reflect.get(target, key, receiver);
+    }
+  },
+  set(target, key, value, receiver) {
+    if ((key === "profile" || key === "root" || key === MembersSym) && 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"
+        );
+      }
+      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);
+    }
+  },
+  defineProperty(target, key, descriptor) {
+    if ((key === "profile" || key === "root" || key === MembersSym) && typeof descriptor.value === "object" && SchemaInit in descriptor.value) {
+      target.constructor._schema ||= {};
+      target.constructor._schema[key] = descriptor.value[SchemaInit];
+      return true;
+    } else {
+      return Reflect.defineProperty(target, key, descriptor);
+    }
+  }
+};
+function isControlledAccount(account) {
+  return account.isMe;
+}
+RegisteredSchemas["Account"] = Account;
+
+// src/coValues/group.ts
+var _Group = class _Group extends CoValueBase {
+  get _schema() {
+    return this.constructor._schema;
+  }
+  get _refs() {
+    const profileID = this._raw.get("profile");
+    const rootID = this._raw.get("root");
+    return {
+      profile: profileID && new Ref(
+        profileID,
+        this._loadedAs,
+        this._schema.profile
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ),
+      root: rootID && new Ref(
+        rootID,
+        this._loadedAs,
+        this._schema.root
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      )
+    };
+  }
+  /** @deprecated Don't use constructor directly, use .create */
+  constructor(options) {
+    super();
+    let raw;
+    if (options && "fromRaw" in options) {
+      raw = options.fromRaw;
+    } else {
+      const initOwner = options.owner;
+      if (!initOwner) throw new Error("No owner provided");
+      if (initOwner._type === "Account" && isControlledAccount(initOwner)) {
+        const rawOwner = initOwner._raw;
+        raw = rawOwner.createGroup();
+      } else {
+        throw new Error("Can only construct group as a controlled account");
+      }
+    }
+    Object.defineProperties(this, {
+      id: {
+        value: raw.id,
+        enumerable: false
+      },
+      _raw: { value: raw, enumerable: false }
+    });
+    return new Proxy(this, AccountAndGroupProxyHandler);
+  }
+  static create(options) {
+    return new this(options);
+  }
+  myRole() {
+    return this._raw.myRole();
+  }
+  addMember(member, role) {
+    this._raw.addMember(member === "everyone" ? member : member._raw, role);
+    return this;
+  }
+  removeMember(member) {
+    this._raw.removeMember(member === "everyone" ? member : member._raw);
+    return this;
+  }
+  get members() {
+    return this._raw.keys().filter((key) => {
+      return key === "everyone" || key.startsWith("co_");
+    }).map((id) => {
+      const role = this._raw.get(id);
+      const accountID = id === "everyone" ? void 0 : id;
+      const ref2 = accountID && new Ref(
+        accountID,
+        this._loadedAs,
+        this._schema[MembersSym]
+      );
+      const accessRef = () => ref2?.accessFrom(this, "members." + id);
+      return {
+        id,
+        role,
+        ref: ref2,
+        get account() {
+          return accessRef();
+        }
+      };
+    });
+  }
+  extend(parent) {
+    this._raw.extend(parent._raw);
+    return this;
+  }
+  /** @category Subscription & Loading */
+  static load(id, as, depth) {
+    return loadCoValue(this, id, as, depth);
+  }
+  /** @category Subscription & Loading */
+  static subscribe(id, as, depth, listener) {
+    return subscribeToCoValue(this, id, as, depth, listener);
+  }
+  /** @category Subscription & Loading */
+  ensureLoaded(depth) {
+    return ensureCoValueLoaded(this, depth);
+  }
+  /** @category Subscription & Loading */
+  subscribe(depth, listener) {
+    return subscribeToExistingCoValue(this, depth, listener);
+  }
+  /**
+   * Wait for the `Group` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForSync(options) {
+    return this._raw.core.waitForSync(options);
+  }
+};
+_Group.prototype._type = "Group";
+_Group._schema = {
+  profile: "json",
+  root: "json",
+  [MembersSym]: {
+    ref: () => RegisteredSchemas["Account"],
+    optional: false
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+};
+Object.defineProperty(_Group.prototype, "_schema", {
+  get: () => _Group._schema
+});
+var Group = _Group;
+RegisteredSchemas["Group"] = Group;
+
+// src/coValues/coFeed.ts
+import { MAX_RECOMMENDED_TX_SIZE, cojsonInternals as cojsonInternals3 } from "cojson";
+var _CoFeed = class _CoFeed extends CoValueBase {
+  /**
+   * Declare a `CoFeed` by subclassing `CoFeed.Of(...)` and passing the item schema using a `co` primitive or a `co.ref`.
+   *
+   * @example
+   * ```ts
+   * class ColorFeed extends CoFeed.Of(co.string) {}
+   * class AnimalFeed extends CoFeed.Of(co.ref(Animal)) {}
+   * ```
+   *
+   * @category Declaration
+   */
+  static Of(item) {
+    var _a2, _b2;
+    return class CoFeedOf extends (_b2 = _CoFeed, _a2 = co.items, _b2) {
+      constructor() {
+        super(...arguments);
+        this[_a2] = item;
+      }
+    };
+  }
+  /** @internal */
+  get _schema() {
+    return this.constructor._schema;
+  }
+  /**
+   * The current account's view of this `CoFeed`
+   * @category Content
+   */
+  get byMe() {
+    if (this._loadedAs._type === "Account") {
+      return this[this._loadedAs.id];
+    } else {
+      return void 0;
+    }
+  }
+  /**
+   * The current session's view of this `CoFeed`
+   *
+   * This is a shortcut for `this.perSession` where the session ID is the current session ID.
+   *
+   * @category Content
+   */
+  get inCurrentSession() {
+    if (this._loadedAs._type === "Account") {
+      return this.perSession[this._loadedAs.sessionID];
+    } else {
+      return void 0;
+    }
+  }
+  constructor(options) {
+    super();
+    if (options && "fromRaw" in options) {
+      Object.defineProperties(this, {
+        id: {
+          value: options.fromRaw.id,
+          enumerable: false
+        },
+        _raw: { value: options.fromRaw, enumerable: false }
+      });
+    }
+    return new Proxy(this, CoStreamProxyHandler);
+  }
+  /**
+   * Create a new `CoFeed`
+   * @category Creation
+   */
+  static create(init, options) {
+    const instance = new this({ init, owner: options.owner });
+    const raw = options.owner._raw.createStream();
+    Object.defineProperties(instance, {
+      id: {
+        value: raw.id,
+        enumerable: false
+      },
+      _raw: { value: raw, enumerable: false }
+    });
+    if (init) {
+      instance.push(...init);
+    }
+    return instance;
+  }
+  /**
+   * 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)) {
+      this._raw.push(item.id);
+    }
+  }
+  /**
+   * 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;
+    return {
+      id: this.id,
+      _type: this._type,
+      ...Object.fromEntries(
+        Object.entries(this).map(([account, entry]) => [
+          account,
+          mapper(entry.value)
+        ])
+      ),
+      in: Object.fromEntries(
+        Object.entries(this.perSession).map(([session, entry]) => [
+          session,
+          mapper(entry.value)
+        ])
+      )
+    };
+  }
+  /** @internal */
+  [(ItemsSym, inspect)]() {
+    return this.toJSON();
+  }
+  /** @internal */
+  static schema(def) {
+    this._schema ||= {};
+    Object.assign(this._schema, def);
+  }
+  /**
+   * Load a `CoFeed`
+   * @category Subscription & Loading
+   */
+  static load(id, as, depth) {
+    return loadCoValue(this, id, as, depth);
+  }
+  /**
+   * Subscribe to a `CoFeed`, when you have an ID but don't have a `CoFeed` instance yet
+   * @category Subscription & Loading
+   */
+  static subscribe(id, as, depth, listener) {
+    return subscribeToCoValue(this, id, as, depth, listener);
+  }
+  /**
+   * Ensure a `CoFeed` is loaded to the specified depth
+   *
+   * @returns A new instance of the same CoFeed that's loaded to the specified depth,
+   * or undefined if it cannot be loaded that deeply
+   * @category Subscription & Loading
+   */
+  ensureLoaded(depth) {
+    return ensureCoValueLoaded(this, depth);
+  }
+  /**
+   * An instance method to subscribe to an existing `CoFeed`
+   *
+   * No need to provide an ID or Account since they're already part of the instance.
+   * @category Subscription & Loading
+   */
+  subscribe(depth, listener) {
+    return subscribeToExistingCoValue(this, depth, listener);
+  }
+  /**
+   * Wait for the `CoFeed` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForSync(options) {
+    return this._raw.core.waitForSync(options);
+  }
+};
+_CoFeed.prototype._type = "CoStream";
+var CoFeed = _CoFeed;
+function entryFromRawEntry(accessFrom, rawEntry, loadedAs, accountID, itemField) {
+  return {
+    get value() {
+      if (itemField === "json") {
+        return rawEntry.value;
+      } else if ("encoded" in itemField) {
+        return itemField.encoded.decode(rawEntry.value);
+      } else if (isRefEncoded(itemField)) {
+        return this.ref?.accessFrom(
+          accessFrom,
+          rawEntry.by + rawEntry.tx.sessionID + rawEntry.tx.txIndex + ".value"
+        );
+      } else {
+        throw new Error("Invalid item field schema");
+      }
+    },
+    get ref() {
+      if (itemField !== "json" && isRefEncoded(itemField)) {
+        const rawId = rawEntry.value;
+        return new Ref(
+          rawId,
+          loadedAs,
+          itemField
+        );
+      } else {
+        return void 0;
+      }
+    },
+    get by() {
+      return accountID && new Ref(accountID, loadedAs, {
+        ref: RegisteredSchemas["Account"],
+        optional: false
+      })?.accessFrom(
+        accessFrom,
+        rawEntry.by + rawEntry.tx.sessionID + rawEntry.tx.txIndex + ".by"
+      );
+    },
+    madeAt: rawEntry.at,
+    tx: rawEntry.tx
+  };
+}
+var CoStreamProxyHandler = {
+  get(target, key, receiver) {
+    if (typeof key === "string" && key.startsWith("co_")) {
+      const rawEntry = target._raw.lastItemBy(key);
+      if (!rawEntry) return;
+      const entry = entryFromRawEntry(
+        receiver,
+        rawEntry,
+        target._loadedAs,
+        key,
+        target._schema[ItemsSym]
+      );
+      Object.defineProperty(entry, "all", {
+        get: () => {
+          const allRawEntries = target._raw.itemsBy(key);
+          return function* () {
+            while (true) {
+              const rawEntry2 = allRawEntries.next();
+              if (rawEntry2.done) return;
+              yield entryFromRawEntry(
+                receiver,
+                rawEntry2.value,
+                target._loadedAs,
+                key,
+                target._schema[ItemsSym]
+              );
+            }
+          }();
+        }
+      });
+      return entry;
+    } else if (key === "perSession") {
+      return new Proxy({}, CoStreamPerSessionProxyHandler(target, receiver));
+    } else {
+      return Reflect.get(target, key, receiver);
+    }
+  },
+  set(target, key, value, receiver) {
+    if (key === ItemsSym && typeof value === "object" && SchemaInit in value) {
+      target.constructor._schema ||= {};
+      target.constructor._schema[ItemsSym] = value[SchemaInit];
+      return true;
+    } else {
+      return Reflect.set(target, key, value, receiver);
+    }
+  },
+  defineProperty(target, key, descriptor) {
+    if (descriptor.value && key === ItemsSym && typeof descriptor.value === "object" && SchemaInit in descriptor.value) {
+      target.constructor._schema ||= {};
+      target.constructor._schema[ItemsSym] = descriptor.value[SchemaInit];
+      return true;
+    } else {
+      return Reflect.defineProperty(target, key, descriptor);
+    }
+  },
+  ownKeys(target) {
+    const keys = Reflect.ownKeys(target);
+    for (const accountID of target._raw.accounts()) {
+      keys.push(accountID);
+    }
+    return keys;
+  },
+  getOwnPropertyDescriptor(target, key) {
+    if (typeof key === "string" && key.startsWith("co_")) {
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false
+      };
+    } else {
+      return Reflect.getOwnPropertyDescriptor(target, key);
+    }
+  }
+};
+var CoStreamPerSessionProxyHandler = (innerTarget, accessFrom) => ({
+  get(_target, key, receiver) {
+    if (typeof key === "string" && key.includes("session")) {
+      const sessionID = key;
+      const rawEntry = innerTarget._raw.lastItemIn(sessionID);
+      if (!rawEntry) return;
+      const by = cojsonInternals3.accountOrAgentIDfromSessionID(sessionID);
+      const entry = entryFromRawEntry(
+        accessFrom,
+        rawEntry,
+        innerTarget._loadedAs,
+        cojsonInternals3.isAccountID(by) ? by : void 0,
+        innerTarget._schema[ItemsSym]
+      );
+      Object.defineProperty(entry, "all", {
+        get: () => {
+          const allRawEntries = innerTarget._raw.itemsIn(sessionID);
+          return function* () {
+            while (true) {
+              const rawEntry2 = allRawEntries.next();
+              if (rawEntry2.done) return;
+              yield entryFromRawEntry(
+                accessFrom,
+                rawEntry2.value,
+                innerTarget._loadedAs,
+                cojsonInternals3.isAccountID(by) ? by : void 0,
+                innerTarget._schema[ItemsSym]
+              );
+            }
+          }();
+        }
+      });
+      return entry;
+    } else {
+      return Reflect.get(innerTarget, key, receiver);
+    }
+  },
+  ownKeys() {
+    return innerTarget._raw.sessions();
+  },
+  getOwnPropertyDescriptor(target, key) {
+    if (typeof key === "string" && key.startsWith("co_")) {
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false
+      };
+    } else {
+      return Reflect.getOwnPropertyDescriptor(target, key);
+    }
+  }
+});
+var FileStream = class extends CoValueBase {
+  constructor(options) {
+    super();
+    let raw;
+    if ("fromRaw" in options) {
+      raw = options.fromRaw;
+    } else {
+      const rawOwner = options.owner._raw;
+      raw = rawOwner.createBinaryStream();
+    }
+    Object.defineProperties(this, {
+      id: {
+        value: raw.id,
+        enumerable: false
+      },
+      _type: { value: "BinaryCoStream", enumerable: false },
+      _raw: { value: raw, enumerable: false }
+    });
+  }
+  static create(options) {
+    return new this(options);
+  }
+  getChunks(options) {
+    return this._raw.getBinaryChunks(options?.allowUnfinished);
+  }
+  isBinaryStreamEnded() {
+    return this._raw.isBinaryStreamEnded();
+  }
+  start(options) {
+    this._raw.startBinaryStream(options);
+  }
+  push(data) {
+    this._raw.pushBinaryStreamChunk(data);
+  }
+  end() {
+    this._raw.endBinaryStream();
+  }
+  toBlob(options) {
+    const chunks = this.getChunks({
+      allowUnfinished: options?.allowUnfinished
+    });
+    if (!chunks) {
+      return void 0;
+    }
+    return new Blob(chunks.chunks, { type: chunks.mimeType });
+  }
+  /**
+   * Load a `FileStream` as a `Blob`
+   *
+   * @category Content
+   */
+  static async loadAsBlob(id, as, options) {
+    let stream = await this.load(id, as, []);
+    if (!options?.allowUnfinished && !stream?.isBinaryStreamEnded()) {
+      stream = await new Promise((resolve) => {
+        const unsubscribe = subscribeToCoValue(this, id, as, [], (value) => {
+          if (value.isBinaryStreamEnded()) {
+            unsubscribe();
+            resolve(value);
+          }
+        });
+      });
+    }
+    return stream?.toBlob({
+      allowUnfinished: options?.allowUnfinished
+    });
+  }
+  /**
+   * Create a `FileStream` from a `Blob` or `File`
+   *
+   * @example
+   * ```ts
+   * import { co, FileStream } from "jazz-tools";
+   *
+   * const fileStream = await FileStream.createFromBlob(file, {owner: group})
+   * ```
+   * @category Content
+   */
+  static async createFromBlob(blob, options) {
+    const stream = this.create({ owner: options.owner });
+    const start = Date.now();
+    const data = new Uint8Array(await blob.arrayBuffer());
+    stream.start({
+      mimeType: blob.type,
+      totalSizeBytes: blob.size,
+      fileName: blob instanceof File ? blob.name : void 0
+    });
+    const chunkSize = MAX_RECOMMENDED_TX_SIZE;
+    let lastProgressUpdate = Date.now();
+    for (let idx = 0; idx < data.length; idx += chunkSize) {
+      stream.push(data.slice(idx, idx + chunkSize));
+      if (Date.now() - lastProgressUpdate > 100) {
+        options.onProgress?.(idx / data.length);
+        lastProgressUpdate = Date.now();
+      }
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+    stream.end();
+    const end = Date.now();
+    console.debug(
+      "Finished creating binary stream in",
+      (end - start) / 1e3,
+      "s - Throughput in MB/s",
+      1e3 * (blob.size / (end - start)) / (1024 * 1024)
+    );
+    options.onProgress?.(1);
+    return stream;
+  }
+  /**
+   * Get a JSON representation of the `FileStream`
+   * @category Content
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      _type: this._type,
+      ...this.getChunks()
+    };
+  }
+  /** @internal */
+  [inspect]() {
+    return this.toJSON();
+  }
+  /**
+   * Load a `FileStream`
+   * @category Subscription & Loading
+   */
+  static load(id, as, depth) {
+    return loadCoValue(this, id, as, depth);
+  }
+  /**
+   * Subscribe to a `FileStream`, when you have an ID but don't have a `FileStream` instance yet
+   * @category Subscription & Loading
+   */
+  static subscribe(id, as, depth, listener) {
+    return subscribeToCoValue(this, id, as, depth, listener);
+  }
+  ensureLoaded(depth) {
+    return ensureCoValueLoaded(this, depth);
+  }
+  /**
+   * An instance method to subscribe to an existing `FileStream`
+   * @category Subscription & Loading
+   */
+  subscribe(depth, listener) {
+    return subscribeToExistingCoValue(this, depth, listener);
+  }
+  /**
+   * Wait for the `FileStream` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForSync(options) {
+    return this._raw.core.waitForSync(options);
+  }
+};
+
+// src/coValues/coList.ts
+import { RawAccount as RawAccount5 } from "cojson";
+var _CoList = class _CoList extends Array {
+  /**
+   * Declare a `CoList` by subclassing `CoList.Of(...)` and passing the item schema using `co`.
+   *
+   * @example
+   * ```ts
+   * class ColorList extends CoList.Of(
+   *   co.string
+   * ) {}
+   * class AnimalList extends CoList.Of(
+   *   co.ref(Animal)
+   * ) {}
+   * ```
+   *
+   * @category Declaration
+   */
+  static Of(item) {
+    var _a2, _b2;
+    return class CoListOf extends (_b2 = _CoList, _a2 = co.items, _b2) {
+      constructor() {
+        super(...arguments);
+        this[_a2] = item;
+      }
+    };
+  }
+  /**
+   * @ignore
+   * @deprecated Use UPPERCASE `CoList.Of` instead! */
+  static of(..._args) {
+    throw new Error("Can't use Array.of with CoLists");
+  }
+  /** @internal */
+  get _schema() {
+    return this.constructor._schema;
+  }
+  /** @category Collaboration */
+  get _owner() {
+    return this._raw.group instanceof RawAccount5 ? RegisteredSchemas["Account"].fromRaw(this._raw.group) : RegisteredSchemas["Group"].fromRaw(this._raw.group);
+  }
+  /**
+   * If a `CoList`'s items are a `co.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(
+      (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 rawAccount = this._raw.core.node.account;
+    if (rawAccount instanceof RawAccount5) {
+      return coValuesCache.get(
+        rawAccount,
+        () => RegisteredSchemas["Account"].fromRaw(rawAccount)
+      );
+    }
+    return new AnonymousJazzAgent(this._raw.core.node);
+  }
+  static get [(ItemsSym, Symbol.species)]() {
+    return Array;
+  }
+  constructor(options) {
+    super();
+    Object.defineProperty(this, "_instanceID", {
+      value: `instance-${Math.random().toString(36).slice(2)}`,
+      enumerable: false
+    });
+    if (options && "fromRaw" in options) {
+      Object.defineProperties(this, {
+        id: {
+          value: options.fromRaw.id,
+          enumerable: false
+        },
+        _raw: { value: options.fromRaw, enumerable: false }
+      });
+    }
+    return new Proxy(this, CoListProxyHandler);
+  }
+  /**
+   * Create a new CoList with the given initial values and owner.
+   *
+   * The owner (a Group or Account) determines access rights to the CoMap.
+   *
+   * The CoList will immediately be persisted and synced to connected peers.
+   *
+   * @example
+   * ```ts
+   * const colours = ColorList.create(
+   *   ["red", "green", "blue"],
+   *   { owner: me }
+   * );
+   * const animals = AnimalList.create(
+   *   [cat, dog, fish],
+   *   { owner: me }
+   * );
+   * ```
+   *
+   * @category Creation
+   **/
+  static create(items, options) {
+    const instance = new this({ init: items, owner: options.owner });
+    const raw = options.owner._raw.createList(
+      toRawItems(items, instance._schema[ItemsSym])
+    );
+    Object.defineProperties(instance, {
+      id: {
+        value: raw.id,
+        enumerable: false
+      },
+      _raw: { value: raw, enumerable: false }
+    });
+    return instance;
+  }
+  push(...items) {
+    for (const item of toRawItems(items, this._schema[ItemsSym])) {
+      this._raw.append(item);
+    }
+    return this._raw.entries().length;
+  }
+  unshift(...items) {
+    for (const item of toRawItems(items, this._schema[ItemsSym])) {
+      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(start, deleteCount, ...items) {
+    const deleted = this.slice(start, start + deleteCount);
+    for (let idxToDelete = start + deleteCount - 1; idxToDelete >= start; idxToDelete--) {
+      this._raw.delete(idxToDelete);
+    }
+    let appendAfter = Math.max(start - 1, 0);
+    for (const item of toRawItems(items, this._schema[ItemsSym])) {
+      console.log(this._raw.asArray(), appendAfter);
+      this._raw.append(item, appendAfter);
+      appendAfter++;
+    }
+    return deleted;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  toJSON(_key, seenAbove) {
+    const itemDescriptor = this._schema[ItemsSym];
+    if (itemDescriptor === "json") {
+      return this._raw.asArray();
+    } else if ("encoded" in itemDescriptor) {
+      return this._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 + "", [
+          ...seenAbove || [],
+          this.id
+        ])
+      );
+    } else {
+      return [];
+    }
+  }
+  [inspect]() {
+    return this.toJSON();
+  }
+  /** @category Internals */
+  static fromRaw(raw) {
+    return new this({ fromRaw: raw });
+  }
+  /** @internal */
+  static schema(def) {
+    this._schema ||= {};
+    Object.assign(this._schema, def);
+  }
+  /**
+   * Load a `CoList` with a given ID, as a given account.
+   *
+   * `depth` specifies if item CoValue references should be loaded as well before resolving.
+   * The `DeeplyLoaded` return type guarantees that corresponding referenced CoValues are loaded to the specified depth.
+   *
+   * You can pass `[]` or for shallowly loading only this CoList, or `[itemDepth]` for recursively loading referenced CoValues.
+   *
+   * Check out the `load` methods on `CoMap`/`CoList`/`CoFeed`/`Group`/`Account` to see which depth structures are valid to nest.
+   *
+   * @example
+   * ```ts
+   * const animalsWithVets =
+   *   await ListOfAnimals.load(
+   *     "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
+   *     me,
+   *     [{ vet: {} }]
+   *   );
+   * ```
+   *
+   * @category Subscription & Loading
+   */
+  static load(id, as, depth) {
+    return loadCoValue(this, id, as, depth);
+  }
+  /**
+   * Load and subscribe to a `CoList` with a given ID, as a given account.
+   *
+   * Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.
+   *
+   * `depth` specifies if item CoValue references should be loaded as well before calling `listener` for the first time.
+   * The `DeeplyLoaded` return type guarantees that corresponding referenced CoValues are loaded to the specified depth.
+   *
+   * You can pass `[]` or for shallowly loading only this CoList, or `[itemDepth]` for recursively loading referenced CoValues.
+   *
+   * Check out the `load` methods on `CoMap`/`CoList`/`CoFeed`/`Group`/`Account` to see which depth structures are valid to nest.
+   *
+   * Returns an unsubscribe function that you should call when you no longer need updates.
+   *
+   * Also see the `useCoState` hook to reactively subscribe to a CoValue in a React component.
+   *
+   * @example
+   * ```ts
+   * const unsub = ListOfAnimals.subscribe(
+   *   "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
+   *   me,
+   *   { vet: {} },
+   *   (animalsWithVets) => console.log(animalsWithVets)
+   * );
+   * ```
+   *
+   * @category Subscription & Loading
+   */
+  static subscribe(id, as, depth, listener) {
+    return subscribeToCoValue(this, id, as, depth, listener);
+  }
+  /**
+   * 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(depth) {
+    return ensureCoValueLoaded(this, depth);
+  }
+  /**
+   * Given an already loaded `CoList`, subscribe to updates to the `CoList` and ensure that items are loaded to the specified depth.
+   *
+   * Works like `CoList.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(depth, listener) {
+    return subscribeToExistingCoValue(this, depth, listener);
+  }
+  /** @category Type Helpers */
+  castAs(cl) {
+    const casted = cl.fromRaw(this._raw);
+    const subscriptionScope = subscriptionsScopes.get(this);
+    if (subscriptionScope) {
+      subscriptionsScopes.set(casted, subscriptionScope);
+    }
+    return casted;
+  }
+  /**
+   * Wait for the `CoList` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForSync(options) {
+    return this._raw.core.waitForSync(options);
+  }
+};
+_CoList.prototype._type = "CoList";
+var CoList = _CoList;
+function toRawItems(items, itemDescriptor) {
+  const rawItems = itemDescriptor === "json" ? items : "encoded" in itemDescriptor ? items?.map((e) => itemDescriptor.encoded.encode(e)) : isRefEncoded(itemDescriptor) ? items?.map((v) => v.id) : (() => {
+    throw new Error("Invalid element descriptor");
+  })();
+  return rawItems;
+}
+var CoListProxyHandler = {
+  get(target, key, receiver) {
+    if (typeof key === "string" && !isNaN(+key)) {
+      const itemDescriptor = target._schema[ItemsSym];
+      const rawValue = target._raw.get(Number(key));
+      if (itemDescriptor === "json") {
+        return rawValue;
+      } else if ("encoded" in itemDescriptor) {
+        return rawValue === void 0 ? void 0 : itemDescriptor.encoded.decode(rawValue);
+      } else if (isRefEncoded(itemDescriptor)) {
+        return rawValue === void 0 ? void 0 : new Ref(
+          rawValue,
+          target._loadedAs,
+          itemDescriptor
+        ).accessFrom(receiver, Number(key));
+      }
+    } else if (key === "length") {
+      return target._raw.entries().length;
+    } else {
+      return Reflect.get(target, key, receiver);
+    }
+  },
+  set(target, key, value, receiver) {
+    if (key === ItemsSym && typeof value === "object" && SchemaInit in value) {
+      target.constructor._schema ||= {};
+      target.constructor._schema[ItemsSym] = value[SchemaInit];
+      return true;
+    }
+    if (typeof key === "string" && !isNaN(+key)) {
+      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)) {
+        rawValue = value.id;
+      }
+      target._raw.replace(Number(key), rawValue);
+      return true;
+    } else {
+      return Reflect.set(target, key, value, receiver);
+    }
+  },
+  defineProperty(target, key, descriptor) {
+    if (descriptor.value && key === ItemsSym && typeof descriptor.value === "object" && SchemaInit in descriptor.value) {
+      target.constructor._schema ||= {};
+      target.constructor._schema[ItemsSym] = descriptor.value[SchemaInit];
+      return true;
+    } else {
+      return Reflect.defineProperty(target, key, descriptor);
+    }
+  },
+  has(target, key) {
+    if (typeof key === "string" && !isNaN(+key)) {
+      return Number(key) < target._raw.entries().length;
+    } else {
+      return Reflect.has(target, key);
+    }
+  }
+};
+
+// src/coValues/extensions/imageDef.ts
+var _a, _b;
+var ImageDefinition = class extends (_b = CoMap, _a = co.items, _b) {
+  constructor() {
+    super(...arguments);
+    this.originalSize = co.json();
+    this.placeholderDataURL = co.string;
+    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+$/) && (options?.maxWidth === void 0 || Number(key.split("x")[0]) <= options.maxWidth)
+    );
+    resolutions.sort((a, b) => {
+      const aWidth = Number(a.split("x")[0]);
+      const bWidth = Number(b.split("x")[0]);
+      return aWidth - bWidth;
+    });
+    let highestAvailableResolution;
+    for (const resolution of resolutions) {
+      if (this[resolution] && this[resolution]?.getChunks()) {
+        highestAvailableResolution = resolution;
+      } else {
+        return highestAvailableResolution && {
+          res: highestAvailableResolution,
+          stream: this[highestAvailableResolution]
+        };
+      }
+    }
+    return highestAvailableResolution && {
+      res: highestAvailableResolution,
+      stream: this[highestAvailableResolution]
+    };
+  }
+};
+
+// src/coValues/schemaUnion.ts
+var SchemaUnion = class _SchemaUnion extends CoValueBase {
+  /**
+   * Create a new union type from a discriminator function.
+   *
+   * The discriminator function receives the raw data and should return the appropriate concrete class to use for that data.
+   *
+   * When loading a SchemaUnion, the correct subclass will be instantiated based on the discriminator.
+   *
+   * @param discriminator - Function that determines which concrete type to use
+   * @returns A new class that can create/load instances of the union type
+   *
+   * @example
+   * ```ts
+   * const WidgetUnion = SchemaUnion.Of<BaseWidget>((raw) => {
+   *   switch (raw.get("type")) {
+   *     case "button": return ButtonWidget;
+   *     case "slider": return SliderWidget;
+   *     default: throw new Error("Unknown widget type");
+   *   }
+   * });
+   *
+   * const widget = await loadCoValue(WidgetUnion, id, me, {});
+   *
+   * // You can narrow the returned instance to a subclass by using `instanceof`
+   * if (widget instanceof ButtonWidget) {
+   *   console.log(widget.label);
+   * } else if (widget instanceof SliderWidget) {
+   *   console.log(widget.min, widget.max);
+   * }
+   * ```
+   *
+   * @category Declaration
+   **/
+  static Of(discriminator) {
+    return class SchemaUnionClass extends _SchemaUnion {
+      static fromRaw(raw) {
+        const ResolvedClass = discriminator(
+          raw
+        );
+        return ResolvedClass.fromRaw(raw);
+      }
+    };
+  }
+  /**
+   * Create an instance from raw data. This is called internally and should not be used directly.
+   * Use {@link SchemaUnion.Of} to create a union type instead.
+   *
+   * @internal
+   */
+  // @ts-ignore
+  static fromRaw(raw) {
+    throw new Error("Not implemented");
+  }
+};
+
+export {
+  AnonymousJazzAgent,
+  CoValueBase,
+  loadCoValue,
+  subscribeToCoValue,
+  createCoValueObservable,
+  Encoders,
+  co,
+  fixedCredentialsAuth,
+  ephemeralCredentialsAuth,
+  randomSessionProvider,
+  createJazzContext,
+  createAnonymousJazzContext,
+  Inbox,
+  InboxSender,
+  CoMap,
+  Profile,
+  Account,
+  isControlledAccount,
+  Group,
+  CoFeed,
+  FileStream,
+  CoList,
+  ImageDefinition,
+  SchemaUnion
+};
+/* istanbul ignore file -- @preserve */
+//# sourceMappingURL=chunk-6OHBW32Q.js.map