jazz-tools 0.13.16 → 0.13.18

package/src/tests/coMap.test.ts

@@ -1,420 +1,423 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
-import { describe, expect, expectTypeOf, test, vi } from "vitest";
-import { Group, randomSessionProvider } from "../exports.js";
 import {
-  Account,
-  CoMap,
-  Encoders,
-  co,
-  cojsonInternals,
-  createJazzContextFromExistingCredentials,
-  isControlledAccount,
-} from "../index.js";
-import { setupTwoNodes } from "./utils.js";
+  assert,
+  beforeEach,
+  describe,
+  expect,
+  expectTypeOf,
+  it,
+  test,
+  vi,
+} from "vitest";
+import { Group, Resolved, subscribeToCoValue } from "../exports.js";
+import { Account, CoMap, Encoders, co, cojsonInternals } from "../index.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+import { setupTwoNodes, waitFor } from "./utils.js";
 
 const { connectedPeers } = cojsonInternals;
 
 const Crypto = await WasmCrypto.create();
 
-class TestMap extends CoMap {
-  color = co.string;
-  _height = co.number;
-  birthday = co.Date;
-  name? = co.string;
-  nullable = co.optional.encoded<string | undefined>({
-    encode: (value: string | undefined) => value || null,
-    decode: (value: unknown) => (value as string) || undefined,
-  });
-  optionalDate = co.optional.Date;
-
-  get roughColor() {
-    return this.color + "ish";
-  }
-}
+beforeEach(async () => {
+  await setupJazzTestSync();
 
-describe("Simple CoMap operations", async () => {
-  const me = await Account.create({
+  await createJazzTestAccount({
+    isCurrentActiveAccount: true,
     creationProps: { name: "Hermes Puggington" },
-    crypto: Crypto,
   });
+});
 
-  const birthday = new Date();
-
-  const map = TestMap.create(
-    {
-      color: "red",
-      _height: 10,
-      birthday: birthday,
-      nullable: undefined,
-    },
-    { owner: me },
-  );
-
-  test("Construction", () => {
-    expect(map.color).toEqual("red");
-    expect(map.roughColor).toEqual("redish");
-    expect(map._height).toEqual(10);
-    expect(map.birthday).toEqual(birthday);
-    expect(map._raw.get("birthday")).toEqual(birthday.toISOString());
-    expect(Object.keys(map)).toEqual([
-      "color",
-      "_height",
-      "birthday",
-      "nullable",
-    ]);
-  });
+describe("CoMap", async () => {
+  describe("init", () => {
+    test("create a CoMap with basic property access", () => {
+      class Person extends CoMap {
+        color = co.string;
+        _height = co.number;
+        birthday = co.Date;
+        name = co.string;
+        nullable = co.optional.encoded<string | undefined>({
+          encode: (value: string | undefined) => value || null,
+          decode: (value: unknown) => (value as string) || undefined,
+        });
+        optionalDate = co.optional.Date;
+
+        get roughColor() {
+          return this.color + "ish";
+        }
+      }
+
+      const birthday = new Date("1989-11-27");
+
+      const john = Person.create({
+        color: "red",
+        _height: 10,
+        birthday,
+        name: "John",
+      });
 
-  test("Construction with an Account", () => {
-    const map = TestMap.create(
-      { color: "red", _height: 10, birthday: birthday },
-      me,
-    );
+      expect(john.color).toEqual("red");
+      expect(john.roughColor).toEqual("redish");
+      expect(john._height).toEqual(10);
+      expect(john.birthday).toEqual(birthday);
+      expect(john._raw.get("birthday")).toEqual(birthday.toISOString());
+      expect(Object.keys(john)).toEqual([
+        "color",
+        "_height",
+        "birthday",
+        "name",
+      ]);
+    });
 
-    expect(map.color).toEqual("red");
-  });
+    test("property existence", () => {
+      class Person extends CoMap {
+        name = co.string;
+      }
 
-  test("Construction with a Group", () => {
-    const group = Group.create(me);
-    const map = TestMap.create(
-      { color: "red", _height: 10, birthday: birthday },
-      group,
-    );
+      const john = Person.create({ name: "John" });
 
-    expect(map.color).toEqual("red");
-  });
+      expect("name" in john).toEqual(true);
+      expect("age" in john).toEqual(false);
+    });
 
-  test("Construction with too many things provided", () => {
-    const mapWithExtra = TestMap.create(
-      {
-        color: "red",
-        _height: 10,
-        birthday: birthday,
-        name: "Hermes",
-        extra: "extra",
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      } as any,
-      { owner: me },
-    );
+    test("create a CoMap with an account as owner", () => {
+      class Person extends CoMap {
+        name = co.string;
+      }
 
-    expect(mapWithExtra.color).toEqual("red");
-  });
+      const john = Person.create({ name: "John" }, Account.getMe());
 
-  test("Empty schema", () => {
-    const emptyMap = CoMap.create({}, { owner: me });
+      expect(john.name).toEqual("John");
+      expect(john._raw.get("name")).toEqual("John");
+    });
 
-    // @ts-expect-error
-    expect(emptyMap.color).toEqual(undefined);
-  });
+    test("create a CoMap with a group as owner", () => {
+      class Person extends CoMap {
+        name = co.string;
+      }
 
-  test("setting date as undefined should throw", () => {
-    expect(() =>
-      TestMap.create(
-        {
+      const john = Person.create({ name: "John" }, Group.create());
+
+      expect(john.name).toEqual("John");
+      expect(john._raw.get("name")).toEqual("John");
+    });
+
+    test("Empty schema", () => {
+      const emptyMap = CoMap.create({});
+
+      // @ts-expect-error
+      expect(emptyMap.color).toEqual(undefined);
+    });
+
+    test("setting date as undefined should throw", () => {
+      class Person extends CoMap {
+        color = co.string;
+        _height = co.number;
+        birthday = co.Date;
+        name = co.string;
+        nullable = co.optional.encoded<string | undefined>({
+          encode: (value: string | undefined) => value || null,
+          decode: (value: unknown) => (value as string) || undefined,
+        });
+        optionalDate = co.optional.Date;
+
+        get roughColor() {
+          return this.color + "ish";
+        }
+      }
+
+      expect(() =>
+        Person.create({
           color: "red",
           _height: 10,
+          name: "John",
           birthday: undefined!,
-        },
-        { owner: me },
-      ),
-    ).toThrow();
-  });
+        }),
+      ).toThrow();
+    });
 
-  test("toJSON should not fail when there is a key in the raw value not represented in the schema", () => {
-    class TestMap extends CoMap {
-      color = co.string;
-      height = co.number;
-    }
+    test("CoMap with reference", () => {
+      class Dog extends CoMap {
+        name = co.string;
+        breed = co.string;
+      }
+
+      class Person extends CoMap {
+        name = co.string;
+        age = co.number;
+        dog = co.ref(Dog);
+      }
+
+      const person = Person.create({
+        name: "John",
+        age: 20,
+        dog: Dog.create({ name: "Rex", breed: "Labrador" }),
+      });
 
-    const map = TestMap.create({ color: "red", height: 10 }, { owner: me });
+      expect(person.dog?.name).toEqual("Rex");
+      expect(person.dog?.breed).toEqual("Labrador");
+    });
 
-    map._raw.set("extra", "extra");
+    test("CoMap with self reference", () => {
+      class Person extends CoMap {
+        name = co.string;
+        age = co.number;
+        friend = co.optional.ref(Person);
+      }
+
+      const person = Person.create({
+        name: "John",
+        age: 20,
+        friend: Person.create({ name: "Jane", age: 21 }),
+      });
 
-    expect(map.toJSON()).toEqual({
-      _type: "CoMap",
-      id: map.id,
-      color: "red",
-      height: 10,
+      expect(person.friend?.name).toEqual("Jane");
+      expect(person.friend?.age).toEqual(21);
     });
-  });
 
-  test("toJSON should handle references", () => {
-    class TestMap extends CoMap {
-      color = co.string;
-      height = co.number;
-      nested = co.optional.ref(TestMap);
-    }
+    test("toJSON should not fail when there is a key in the raw value not represented in the schema", () => {
+      class Person extends CoMap {
+        name = co.string;
+        age = co.number;
+      }
 
-    const map = TestMap.create({ color: "red", height: 10 }, { owner: me });
+      const person = Person.create({ name: "John", age: 20 });
 
-    map.nested = TestMap.create({ color: "blue", height: 20 }, { owner: me });
+      person._raw.set("extra", "extra");
 
-    expect(map.toJSON()).toEqual({
-      _type: "CoMap",
-      id: map.id,
-      color: "red",
-      height: 10,
-      nested: {
+      expect(person.toJSON()).toEqual({
         _type: "CoMap",
-        id: map.nested?.id,
-        color: "blue",
-        height: 20,
-      },
+        id: person.id,
+        name: "John",
+        age: 20,
+      });
     });
-  });
 
-  test("toJSON should handle circular references", () => {
-    class TestMap extends CoMap {
-      color = co.string;
-      height = co.number;
-      nested = co.optional.ref(TestMap);
-    }
+    test("toJSON should handle references", () => {
+      class Person extends CoMap {
+        name = co.string;
+        age = co.number;
+        friend = co.optional.ref(Person);
+      }
+
+      const person = Person.create({
+        name: "John",
+        age: 20,
+        friend: Person.create({ name: "Jane", age: 21 }),
+      });
 
-    const map = TestMap.create({ color: "red", height: 10 }, { owner: me });
+      expect(person.toJSON()).toEqual({
+        _type: "CoMap",
+        id: person.id,
+        name: "John",
+        age: 20,
+        friend: {
+          _type: "CoMap",
+          id: person.friend?.id,
+          name: "Jane",
+          age: 21,
+        },
+      });
+    });
 
-    map.nested = map;
+    test("toJSON should handle circular references", () => {
+      class Person extends CoMap {
+        name = co.string;
+        age = co.number;
+        friend = co.optional.ref(Person);
+      }
 
-    expect(map.toJSON()).toEqual({
-      _type: "CoMap",
-      id: map.id,
-      color: "red",
-      height: 10,
-      nested: {
-        _circular: map.id,
-      },
-    });
-  });
+      const person = Person.create({
+        name: "John",
+        age: 20,
+      });
 
-  test("testing toJSON on a CoMap with a Date field", () => {
-    const map = TestMap.create(
-      {
-        color: "red",
-        _height: 10,
-        birthday: new Date(),
-      },
-      { owner: me },
-    );
+      person.friend = person;
 
-    expect(map.toJSON()).toMatchObject({
-      color: "red",
-      _height: 10,
-      birthday: expect.any(String),
-      _type: "CoMap",
-      id: expect.any(String),
+      expect(person.toJSON()).toEqual({
+        _type: "CoMap",
+        id: person.id,
+        name: "John",
+        age: 20,
+        friend: {
+          _circular: person.id,
+        },
+      });
     });
-  });
 
-  test("setting optional date as undefined should not throw", () => {
-    const map = TestMap.create(
-      {
-        color: "red",
-        _height: 10,
+    test("testing toJSON on a CoMap with a Date field", () => {
+      class Person extends CoMap {
+        name = co.string;
+        age = co.number;
+        birthday = co.Date;
+      }
+
+      const birthday = new Date();
+
+      const john = Person.create({
+        name: "John",
+        age: 20,
         birthday,
-        optionalDate: undefined,
-      },
-      { owner: me },
-    );
-    expect(map.optionalDate).toBeUndefined();
-  });
+      });
 
-  describe("Mutation", () => {
-    test("assignment & deletion", () => {
-      map.color = "blue";
-      expect(map.color).toEqual("blue");
-      expect(map._raw.get("color")).toEqual("blue");
-      const newBirthday = new Date();
-      map.birthday = newBirthday;
-      expect(map.birthday).toEqual(newBirthday);
-      expect(map._raw.get("birthday")).toEqual(newBirthday.toISOString());
-
-      Object.assign(map, { color: "green", _height: 20 });
-      expect(map.color).toEqual("green");
-      expect(map._raw.get("color")).toEqual("green");
-      expect(map._height).toEqual(20);
-      expect(map._raw.get("_height")).toEqual(20);
-
-      map.nullable = "not null";
-      map.nullable = undefined;
-      delete map.nullable;
-      map.nullable = undefined;
-
-      map.name = "Secret name";
-      expect(map.name).toEqual("Secret name");
-      map.name = undefined;
-      expect(map.name).toEqual(undefined);
-      expect(Object.keys(map)).toContain("name");
-      delete map.name;
-      expect(map.name).toEqual(undefined);
-      expect(Object.keys(map)).not.toContain("name");
-
-      expect(map._edits).toMatchObject({
-        _height: {
-          by: { id: me.id },
-          value: 20,
-        },
-        birthday: {
-          by: { id: me.id },
-          value: newBirthday,
-        },
-        color: {
-          by: { id: me.id },
-          value: "green",
-          all: [
-            expect.objectContaining({
-              by: { _type: "Account", id: me.id },
-              value: "red",
-            }),
-            expect.objectContaining({
-              by: { _type: "Account", id: me.id },
-              value: "blue",
-            }),
-            expect.objectContaining({
-              by: { _type: "Account", id: me.id },
-              value: "green",
-            }),
-          ],
-        },
-        nullable: {
-          by: { id: me.id },
-          value: null,
-          all: [
-            expect.objectContaining({
-              by: { _type: "Account", id: me.id },
-              value: null,
-            }),
-            expect.objectContaining({
-              by: { _type: "Account", id: me.id },
-              value: "not null",
-            }),
-            expect.objectContaining({
-              by: { _type: "Account", id: me.id },
-              value: null,
-            }),
-            expect.objectContaining({
-              by: { _type: "Account", id: me.id },
-              value: undefined,
-            }),
-            expect.objectContaining({
-              by: { _type: "Account", id: me.id },
-              value: null,
-            }),
-          ],
-        },
+      expect(john.toJSON()).toMatchObject({
+        name: "John",
+        age: 20,
+        birthday: birthday.toISOString(),
+        _type: "CoMap",
+        id: john.id,
       });
+    });
 
-      expect(JSON.parse(JSON.stringify(map._edits))).toMatchObject({
-        _height: {
-          by: { id: me.id },
-          value: 20,
-        },
-        birthday: {
-          by: { id: me.id },
-          value: newBirthday.toISOString(),
-        },
-        color: {
-          by: { id: me.id },
-          value: "green",
-          all: [
-            expect.objectContaining({
-              by: { _type: "Account", id: me.id },
-              value: "red",
-            }),
-            expect.objectContaining({
-              by: { _type: "Account", id: me.id },
-              value: "blue",
-            }),
-            expect.objectContaining({
-              by: { _type: "Account", id: me.id },
-              value: "green",
-            }),
-          ],
-        },
-        nullable: {
-          by: { id: me.id },
-          value: null,
-        },
+    test("setting optional date as undefined should not throw", () => {
+      class Person extends CoMap {
+        name = co.string;
+        age = co.number;
+        birthday = co.optional.Date;
+      }
+
+      const john = Person.create({
+        name: "John",
+        age: 20,
+      });
+
+      expect(john.toJSON()).toMatchObject({
+        name: "John",
+        age: 20,
       });
     });
-  });
 
-  describe("property existence", () => {
-    class TestMap extends CoMap.Record(co.string) {}
-    test("CoMap", () => {
-      const map = TestMap.create(
-        { name: "test" },
-        {
-          owner: me,
-        },
-      );
+    it("should disallow extra properties", () => {
+      class Person extends CoMap {
+        name = co.string;
+        age = co.number;
+      }
 
-      expect("name" in map).toBe(true);
-      expect("something" in map).toBe(false);
+      // @ts-expect-error - x is not a valid property
+      const john = Person.create({ name: "John", age: 30, x: 1 });
+
+      expect(john.toJSON()).toEqual({
+        _type: "CoMap",
+        id: john.id,
+        name: "John",
+        age: 30,
+      });
     });
   });
 
-  class RecursiveMap extends CoMap {
-    name = co.string;
-    next?: co<RecursiveMap | null> = co.ref(RecursiveMap);
-  }
+  describe("Mutation", () => {
+    test("change a primitive value", () => {
+      class Person extends CoMap {
+        name = co.string;
+        age = co.number;
+      }
+
+      const john = Person.create({ name: "John", age: 20 });
+
+      john.name = "Jane";
+
+      expect(john.name).toEqual("Jane");
+      expect(john.age).toEqual(20);
+    });
+
+    test("delete an optional value", () => {
+      class Person extends CoMap {
+        name = co.string;
+        age = co.optional.number;
+      }
+
+      const john = Person.create({ name: "John", age: 20 });
+
+      delete john.age;
+
+      expect(john.name).toEqual("John");
+      expect(john.age).toEqual(undefined);
 
-  const recursiveMap = RecursiveMap.create(
-    {
-      name: "first",
-      next: RecursiveMap.create(
+      expect(john.toJSON()).toEqual({
+        _type: "CoMap",
+        id: john.id,
+        name: "John",
+      });
+    });
+
+    test("update a reference", () => {
+      class Dog extends CoMap {
+        name = co.string;
+      }
+
+      class Person extends CoMap {
+        name = co.string;
+        age = co.number;
+        dog = co.ref(Dog);
+      }
+
+      const john = Person.create({
+        name: "John",
+        age: 20,
+        dog: Dog.create({ name: "Rex" }),
+      });
+
+      john.dog = Dog.create({ name: "Fido" });
+
+      expect(john.dog?.name).toEqual("Fido");
+    });
+
+    test("changes should be listed in _edits", () => {
+      class Person extends CoMap {
+        name = co.string;
+        age = co.number;
+      }
+
+      const john = Person.create({ name: "John", age: 20 });
+
+      const me = Account.getMe();
+
+      john.age = 21;
+
+      expect(john._edits.age.all).toEqual([
+        {
+          by: expect.objectContaining({ _type: "Account", id: me.id }),
+          value: 20,
+          key: "age",
+          ref: undefined,
+          madeAt: expect.any(Date),
+        },
         {
-          name: "second",
-          next: RecursiveMap.create(
-            {
-              name: "third",
-            },
-            { owner: me },
-          ),
+          by: expect.objectContaining({ _type: "Account", id: me.id }),
+          value: 21,
+          key: "age",
+          ref: undefined,
+          madeAt: expect.any(Date),
         },
-        { owner: me },
-      ),
-    },
-    { owner: me },
-  );
-
-  describe("Recursive CoMap", () => {
-    test("Construction", () => {
-      expect(recursiveMap.name).toEqual("first");
-      expect(recursiveMap.next?.name).toEqual("second");
-      expect(recursiveMap.next?.next?.name).toEqual("third");
+      ]);
     });
   });
 
-  class MapWithEnumOfMaps extends CoMap {
-    name = co.string;
-    child = co.ref<typeof ChildA | typeof ChildB>((raw) =>
-      raw.get("type") === "a" ? ChildA : ChildB,
-    );
-  }
+  test("Enum of maps", () => {
+    class MapWithEnumOfMaps extends CoMap {
+      name = co.string;
+      child = co.ref<typeof ChildA | typeof ChildB>((raw) =>
+        raw.get("type") === "a" ? ChildA : ChildB,
+      );
+    }
 
-  class ChildA extends CoMap {
-    type = co.literal("a");
-    value = co.number;
-  }
+    class ChildA extends CoMap {
+      type = co.literal("a");
+      value = co.number;
+    }
 
-  class ChildB extends CoMap {
-    type = co.literal("b");
-    value = co.string;
-  }
+    class ChildB extends CoMap {
+      type = co.literal("b");
+      value = co.string;
+    }
 
-  const mapWithEnum = MapWithEnumOfMaps.create(
-    {
+    const mapWithEnum = MapWithEnumOfMaps.create({
       name: "enum",
-      child: ChildA.create(
-        {
-          type: "a",
-          value: 5,
-        },
-        { owner: me },
-      ),
-    },
-    { owner: me },
-  );
+      child: ChildA.create({
+        type: "a",
+        value: 5,
+      }),
+    });
 
-  test("Enum of maps", () => {
     expect(mapWithEnum.name).toEqual("enum");
     expect(mapWithEnum.child?.type).toEqual("a");
     expect(mapWithEnum.child?.value).toEqual(5);
@@ -423,393 +426,464 @@ describe("Simple CoMap operations", async () => {
 });
 
 describe("CoMap resolution", async () => {
-  class TwiceNestedMap extends CoMap {
-    taste = co.string;
-  }
-
-  class NestedMap extends CoMap {
-    name = co.string;
-    twiceNested = co.ref(TwiceNestedMap);
+  test("loading a locally available map with deep resolve", async () => {
+    class Dog extends CoMap {
+      name = co.string;
+      breed = co.string;
+    }
 
-    get _fancyName() {
-      return "Sir " + this.name;
+    class Person extends CoMap {
+      name = co.string;
+      age = co.number;
+      dog = co.ref(Dog);
     }
-  }
 
-  class TestMap extends CoMap {
-    color = co.string;
-    height = co.number;
-    nested = co.ref(NestedMap);
+    const person = Person.create({
+      name: "John",
+      age: 20,
+      dog: Dog.create({ name: "Rex", breed: "Labrador" }),
+    });
+
+    const loadedPerson = await Person.load(person.id, {
+      resolve: {
+        dog: true,
+      },
+    });
+
+    assert(loadedPerson);
+    expect(loadedPerson.dog.name).toEqual("Rex");
+  });
+
+  test("loading a locally available map using autoload for the refs", async () => {
+    class Dog extends CoMap {
+      name = co.string;
+      breed = co.string;
+    }
 
-    get _roughColor() {
-      return this.color + "ish";
+    class Person extends CoMap {
+      name = co.string;
+      age = co.number;
+      dog = co.ref(Dog);
     }
-  }
 
-  const initNodeAndMap = async () => {
-    const me = await Account.create({
-      creationProps: { name: "Hermes Puggington" },
-      crypto: Crypto,
+    const person = Person.create({
+      name: "John",
+      age: 20,
+      dog: Dog.create({ name: "Rex", breed: "Labrador" }),
     });
 
-    const map = TestMap.create(
+    const loadedPerson = await Person.load(person.id);
+
+    assert(loadedPerson);
+    expect(loadedPerson.dog?.name).toEqual("Rex");
+  });
+
+  test("loading a remotely available map with deep resolve", async () => {
+    class Dog extends CoMap {
+      name = co.string;
+      breed = co.string;
+    }
+
+    class Person extends CoMap {
+      name = co.string;
+      age = co.number;
+      dog = co.ref(Dog);
+    }
+
+    const group = Group.create();
+    group.addMember("everyone", "writer");
+
+    const person = Person.create(
       {
-        color: "red",
-        height: 10,
-        nested: NestedMap.create(
-          {
-            name: "nested",
-            twiceNested: TwiceNestedMap.create(
-              { taste: "sour" },
-              { owner: me },
-            ),
-          },
-          { owner: me },
-        ),
+        name: "John",
+        age: 20,
+        dog: Dog.create({ name: "Rex", breed: "Labrador" }, group),
       },
-      { owner: me },
+      group,
     );
 
-    return { me, map };
-  };
+    const userB = await createJazzTestAccount();
 
-  test("Construction", async () => {
-    const { map } = await initNodeAndMap();
-
-    // const test: Schema.Schema.To<typeof NestedMap>
+    const loadedPerson = await Person.load(person.id, {
+      resolve: {
+        dog: true,
+      },
+      loadAs: userB,
+    });
 
-    expect(map.color).toEqual("red");
-    expect(map._roughColor).toEqual("redish");
-    expect(map.height).toEqual(10);
-    expect(map.nested?.name).toEqual("nested");
-    expect(map.nested?._fancyName).toEqual("Sir nested");
-    expect(map.nested?.id).toBeDefined();
-    expect(map.nested?.twiceNested?.taste).toEqual("sour");
+    assert(loadedPerson);
+    expect(loadedPerson.dog.name).toEqual("Rex");
   });
 
-  test("Loading and availability", async () => {
-    const { me, map } = await initNodeAndMap();
-    const [initialAsPeer, secondPeer] = connectedPeers("initial", "second", {
-      peer1role: "server",
-      peer2role: "client",
-    });
+  test("loading a remotely available map using autoload for the refs", async () => {
+    class Dog extends CoMap {
+      name = co.string;
+      breed = co.string;
+    }
 
-    if (!isControlledAccount(me)) {
-      throw "me is not a controlled account";
+    class Person extends CoMap {
+      name = co.string;
+      age = co.number;
+      dog = co.ref(Dog);
     }
-    me._raw.core.node.syncManager.addPeer(secondPeer);
-    const { account: meOnSecondPeer } =
-      await createJazzContextFromExistingCredentials({
-        credentials: {
-          accountID: me.id,
-          secret: me._raw.agentSecret,
-        },
-        sessionProvider: randomSessionProvider,
-        peersToLoadFrom: [initialAsPeer],
-        crypto: Crypto,
-      });
 
-    const loadedMap = await TestMap.load(map.id, { loadAs: meOnSecondPeer });
+    const group = Group.create();
+    group.addMember("everyone", "writer");
 
-    expect(loadedMap?.color).toEqual("red");
-    expect(loadedMap?.height).toEqual(10);
-    expect(loadedMap?.nested).toEqual(null);
-    expect(loadedMap?._refs.nested?.id).toEqual(map.nested?.id);
-    expect(loadedMap?._refs.nested?.value).toEqual(null);
+    const person = Person.create(
+      {
+        name: "John",
+        age: 20,
+        dog: Dog.create({ name: "Rex", breed: "Labrador" }, group),
+      },
+      group,
+    );
 
-    const loadedNestedMap = await NestedMap.load(map.nested!.id, {
-      loadAs: meOnSecondPeer,
+    const userB = await createJazzTestAccount();
+    const loadedPerson = await Person.load(person.id, {
+      loadAs: userB,
     });
 
-    expect(loadedMap?.nested?.name).toEqual("nested");
-    expect(loadedMap?.nested?._fancyName).toEqual("Sir nested");
-    expect(loadedMap?._refs.nested?.value).toEqual(loadedNestedMap);
-    expect(loadedMap?.nested?.twiceNested?.taste).toEqual(undefined);
+    assert(loadedPerson);
+    expect(loadedPerson.dog).toBe(null);
 
-    const loadedTwiceNestedMap = await TwiceNestedMap.load(
-      map.nested!.twiceNested!.id,
-      { loadAs: meOnSecondPeer },
-    );
+    await waitFor(() => expect(loadedPerson.dog).toBeTruthy());
 
-    expect(loadedMap?.nested?.twiceNested?.taste).toEqual("sour");
-    expect(loadedMap?.nested?._refs.twiceNested?.value).toEqual(
-      loadedTwiceNestedMap,
-    );
+    expect(loadedPerson.dog?.name).toEqual("Rex");
+  });
+
+  test("accessing the value refs", async () => {
+    class Dog extends CoMap {
+      name = co.string;
+      breed = co.string;
+    }
+
+    class Person extends CoMap {
+      name = co.string;
+      age = co.number;
+      dog = co.ref(Dog);
+    }
 
-    const otherNestedMap = NestedMap.create(
+    const group = Group.create();
+    group.addMember("everyone", "writer");
+
+    const person = Person.create(
       {
-        name: "otherNested",
-        twiceNested: TwiceNestedMap.create(
-          { taste: "sweet" },
-          { owner: meOnSecondPeer },
-        ),
+        name: "John",
+        age: 20,
+        dog: Dog.create({ name: "Rex", breed: "Labrador" }, group),
       },
-      { owner: meOnSecondPeer },
+      group,
     );
 
-    loadedMap!.nested = otherNestedMap;
-    expect(loadedMap?.nested?.name).toEqual("otherNested");
-    expect(loadedMap?._refs.nested?.id).toEqual(otherNestedMap.id);
-    expect(loadedMap?._refs.nested?.value).toEqual(otherNestedMap);
-    expect(loadedMap?.nested?.twiceNested?.taste).toEqual("sweet");
-    expect(loadedMap?.nested?._refs.twiceNested?.value).toBeDefined();
+    const userB = await createJazzTestAccount();
+    const loadedPerson = await Person.load(person.id, {
+      loadAs: userB,
+    });
+
+    assert(loadedPerson);
+
+    expect(loadedPerson._refs.dog.id).toBe(person.dog!.id);
+
+    const dog = await loadedPerson._refs.dog.load();
+
+    assert(dog);
+
+    expect(dog.name).toEqual("Rex");
   });
 
-  async function setupTest() {
-    const { me, map } = await initNodeAndMap();
+  test("subscription on a locally available map with deep resolve", async () => {
+    class Dog extends CoMap {
+      name = co.string;
+      breed = co.string;
+    }
+
+    class Person extends CoMap {
+      name = co.string;
+      age = co.number;
+      dog = co.ref(Dog);
+    }
 
-    const [initialAsPeer, secondAsPeer] = connectedPeers("initial", "second", {
-      peer1role: "server",
-      peer2role: "client",
+    const person = Person.create({
+      name: "John",
+      age: 20,
+      dog: Dog.create({ name: "Rex", breed: "Labrador" }),
     });
 
-    if (!isControlledAccount(me)) {
-      throw "me is not a controlled account";
-    }
-    me._raw.core.node.syncManager.addPeer(secondAsPeer);
-    const { account: meOnSecondPeer } =
-      await createJazzContextFromExistingCredentials({
-        credentials: {
-          accountID: me.id,
-          secret: me._raw.agentSecret,
+    const updates: Resolved<Person, { dog: true }>[] = [];
+    const spy = vi.fn((person) => updates.push(person));
+
+    Person.subscribe(
+      person.id,
+      {
+        resolve: {
+          dog: true,
         },
-        sessionProvider: randomSessionProvider,
-        peersToLoadFrom: [initialAsPeer],
-        crypto: Crypto,
-      });
+      },
+      spy,
+    );
 
-    const queue = new cojsonInternals.Channel<TestMap>();
+    expect(spy).not.toHaveBeenCalled();
 
-    await meOnSecondPeer.waitForAllCoValuesSync();
+    await waitFor(() => expect(spy).toHaveBeenCalled());
 
-    TestMap.subscribe(map.id, { loadAs: meOnSecondPeer }, (subscribedMap) => {
-      // Read to property to trigger loading
-      subscribedMap.nested?.twiceNested?.taste;
-      void queue.push(subscribedMap);
-    });
+    expect(spy).toHaveBeenCalledTimes(1);
 
-    return { me, map, meOnSecondPeer, queue };
-  }
+    expect(updates[0]?.dog.name).toEqual("Rex");
+
+    person.dog!.name = "Fido";
 
-  test("initial subscription loads nested data progressively", async () => {
-    const { queue } = await setupTest();
+    await waitFor(() => expect(spy).toHaveBeenCalledTimes(2));
 
-    const update1 = (await queue.next()).value;
-    expect(update1.nested).toEqual(null);
+    expect(updates[1]?.dog.name).toEqual("Fido");
 
-    const update2 = (await queue.next()).value;
-    expect(update2.nested?.name).toEqual("nested");
+    expect(spy).toHaveBeenCalledTimes(2);
   });
 
-  test("updates to nested properties are received", async () => {
-    const { map, queue } = await setupTest();
+  test("subscription on a locally available map with autoload", async () => {
+    class Dog extends CoMap {
+      name = co.string;
+      breed = co.string;
+    }
 
-    // Skip initial updates
-    await queue.next();
-    await queue.next();
+    class Person extends CoMap {
+      name = co.string;
+      age = co.number;
+      dog = co.ref(Dog);
+    }
 
-    map.nested!.name = "nestedUpdated";
+    const person = Person.create({
+      name: "John",
+      age: 20,
+      dog: Dog.create({ name: "Rex", breed: "Labrador" }),
+    });
 
-    await queue.next(); // Skip intermediate update
-    const update3 = (await queue.next()).value;
-    expect(update3.nested?.name).toEqual("nestedUpdated");
+    const updates: Person[] = [];
+    const spy = vi.fn((person) => updates.push(person));
 
-    const oldTwiceNested = update3.nested!.twiceNested;
-    expect(oldTwiceNested?.taste).toEqual("sour");
-  });
+    Person.subscribe(person.id, {}, spy);
 
-  test("replacing nested object triggers updates", async () => {
-    const { meOnSecondPeer, queue } = await setupTest();
+    expect(spy).not.toHaveBeenCalled();
 
-    // Skip initial updates
-    await queue.next();
-    await queue.next();
+    await waitFor(() => expect(spy).toHaveBeenCalled());
 
-    const update3 = (await queue.next()).value;
+    expect(spy).toHaveBeenCalledTimes(1);
 
-    const newTwiceNested = TwiceNestedMap.create(
-      {
-        taste: "sweet",
-      },
-      { owner: meOnSecondPeer },
-    );
+    expect(updates[0]?.dog?.name).toEqual("Rex");
 
-    const newNested = NestedMap.create(
-      {
-        name: "newNested",
-        twiceNested: newTwiceNested,
-      },
-      { owner: meOnSecondPeer },
-    );
+    person.dog!.name = "Fido";
 
-    update3.nested = newNested;
+    await waitFor(() => expect(spy).toHaveBeenCalledTimes(2));
 
-    await queue.next(); // Skip intermediate update
-    const update4 = (await queue.next()).value;
+    expect(updates[1]?.dog?.name).toEqual("Fido");
 
-    expect(update4.nested?.name).toEqual("newNested");
-    expect(update4.nested?.twiceNested?.taste).toEqual("sweet");
+    expect(spy).toHaveBeenCalledTimes(2);
   });
 
-  test("updates to deeply nested properties are received", async () => {
-    const { queue } = await setupTest();
+  test("subscription on a locally available map with syncResolution", async () => {
+    class Dog extends CoMap {
+      name = co.string;
+      breed = co.string;
+    }
 
-    // Skip to the point where we have the nested object
-    await queue.next();
-    await queue.next();
-    const update3 = (await queue.next()).value;
+    class Person extends CoMap {
+      name = co.string;
+      age = co.number;
+      dog = co.ref(Dog);
+    }
 
-    const newTwiceNested = TwiceNestedMap.create(
-      { taste: "sweet" },
-      { owner: update3.nested!._raw.owner },
-    );
+    const person = Person.create({
+      name: "John",
+      age: 20,
+      dog: Dog.create({ name: "Rex", breed: "Labrador" }),
+    });
+
+    const updates: Person[] = [];
+    const spy = vi.fn((person) => updates.push(person));
 
-    const newNested = NestedMap.create(
+    subscribeToCoValue(
+      Person,
+      person.id,
       {
-        name: "newNested",
-        twiceNested: newTwiceNested,
+        syncResolution: true,
+        loadAs: Account.getMe(),
       },
-      { owner: update3.nested!._raw.owner },
+      spy,
     );
 
-    update3.nested = newNested;
+    expect(spy).toHaveBeenCalled();
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    expect(updates[0]?.dog?.name).toEqual("Rex");
+
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    person.dog!.name = "Fido";
 
-    // Skip intermediate updates
-    await queue.next();
-    await queue.next();
+    expect(spy).toHaveBeenCalledTimes(2);
 
-    newTwiceNested.taste = "salty";
-    const update5 = (await queue.next()).value;
-    expect(update5.nested?.twiceNested?.taste).toEqual("salty");
+    expect(updates[1]?.dog?.name).toEqual("Fido");
 
-    newTwiceNested.taste = "umami";
-    const update6 = (await queue.next()).value;
-    expect(update6.nested?.twiceNested?.taste).toEqual("umami");
+    expect(spy).toHaveBeenCalledTimes(2);
   });
 
-  class TestMapWithOptionalRef extends CoMap {
-    color = co.string;
-    nested = co.optional.ref(NestedMap);
-  }
+  test("subscription on a remotely available map with deep resolve", async () => {
+    class Dog extends CoMap {
+      name = co.string;
+      breed = co.string;
+    }
 
-  test("Construction with optional", async () => {
-    const me = await Account.create({
-      creationProps: { name: "Hermes Puggington" },
-      crypto: Crypto,
-    });
+    class Person extends CoMap {
+      name = co.string;
+      age = co.number;
+      dog = co.ref(Dog);
+    }
+
+    const group = Group.create();
+    group.addMember("everyone", "writer");
 
-    const mapWithout = TestMapWithOptionalRef.create(
+    const person = Person.create(
       {
-        color: "red",
+        name: "John",
+        age: 20,
+        dog: Dog.create({ name: "Rex", breed: "Labrador" }, group),
       },
-      { owner: me },
+      group,
     );
 
-    expect(mapWithout.color).toEqual("red");
-    expect(mapWithout.nested).toEqual(undefined);
+    const userB = await createJazzTestAccount();
 
-    const mapWith = TestMapWithOptionalRef.create(
+    const updates: Resolved<Person, { dog: true }>[] = [];
+    const spy = vi.fn((person) => updates.push(person));
+
+    Person.subscribe(
+      person.id,
       {
-        color: "red",
-        nested: NestedMap.create(
-          {
-            name: "wow!",
-            twiceNested: TwiceNestedMap.create(
-              { taste: "sour" },
-              { owner: me },
-            ),
-          },
-          { owner: me },
-        ),
+        resolve: {
+          dog: true,
+        },
+        loadAs: userB,
       },
-      { owner: me },
+      spy,
     );
 
-    expect(mapWith.color).toEqual("red");
-    expect(mapWith.nested?.name).toEqual("wow!");
-    expect(mapWith.nested?._fancyName).toEqual("Sir wow!");
-    expect(mapWith.nested?._raw).toBeDefined();
+    expect(spy).not.toHaveBeenCalled();
+
+    await waitFor(() => expect(spy).toHaveBeenCalled());
+
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    expect(updates[0]?.dog.name).toEqual("Rex");
+
+    person.dog!.name = "Fido";
+
+    await waitFor(() => expect(spy).toHaveBeenCalledTimes(2));
+
+    expect(updates[1]?.dog.name).toEqual("Fido");
+
+    expect(spy).toHaveBeenCalledTimes(2);
   });
 
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-  class TestRecord extends CoMap {
-    [co.items] = co.number;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-  interface TestRecord extends Record<string, number> {}
+  test("subscription on a remotely available map with autoload", async () => {
+    class Dog extends CoMap {
+      name = co.string;
+      breed = co.string;
+    }
 
-  test("Construction with index signature", async () => {
-    const me = await Account.create({
-      creationProps: { name: "Hermes Puggington" },
-      crypto: Crypto,
-    });
+    class Person extends CoMap {
+      name = co.string;
+      age = co.number;
+      dog = co.ref(Dog);
+    }
+
+    const group = Group.create();
+    group.addMember("everyone", "writer");
 
-    const record = TestRecord.create(
+    const person = Person.create(
       {
-        height: 5,
-        other: 3,
+        name: "John",
+        age: 20,
+        dog: Dog.create({ name: "Rex", breed: "Labrador" }, group),
       },
-      { owner: me },
+      group,
     );
 
-    expect(record.height).toEqual(5);
-    expect(record._raw.get("height")).toEqual(5);
-    expect(record.other).toEqual(3);
-    expect(record._raw.get("other")).toEqual(3);
-    expect(Object.keys(record)).toEqual(["height", "other"]);
-    expect(record.toJSON()).toMatchObject({
-      _type: "CoMap",
-      height: 5,
-      id: expect.any(String),
-      other: 3,
-    });
-  });
+    const updates: Person[] = [];
+    const spy = vi.fn((person) => updates.push(person));
 
-  class TestRecord2 extends CoMap.Record(co.number) {}
+    const userB = await createJazzTestAccount();
 
-  test("Construction with index signature (shorthand)", async () => {
-    const me = await Account.create({
-      creationProps: { name: "Hermes Puggington" },
-      crypto: Crypto,
-    });
-
-    const record = TestRecord2.create(
+    Person.subscribe(
+      person.id,
       {
-        height: 5,
-        other: 3,
+        loadAs: userB,
       },
-      { owner: me },
+      spy,
     );
 
-    expect(record.height).toEqual(5);
-    expect(record._raw.get("height")).toEqual(5);
-    expect(record.other).toEqual(3);
-    expect(record._raw.get("other")).toEqual(3);
-    expect(Object.keys(record)).toEqual(["height", "other"]);
+    expect(spy).not.toHaveBeenCalled();
+
+    await waitFor(() => expect(spy).toHaveBeenCalled());
+
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    expect(updates[0]?.dog?.name).toEqual("Rex");
+
+    person.dog!.name = "Fido";
+
+    await waitFor(() => expect(spy).toHaveBeenCalledTimes(2));
+
+    expect(updates[1]?.dog?.name).toEqual("Fido");
+
+    expect(spy).toHaveBeenCalledTimes(2);
   });
 
-  class TestRecordRef extends CoMap.Record(co.ref(TwiceNestedMap)) {}
+  test("replacing nested object triggers updates", async () => {
+    class Dog extends CoMap {
+      name = co.string;
+      breed = co.string;
+    }
 
-  test("Construction with index signature ref", async () => {
-    const me = await Account.create({
-      creationProps: { name: "Hermes Puggington" },
-      crypto: Crypto,
+    class Person extends CoMap {
+      name = co.string;
+      age = co.number;
+      dog = co.ref(Dog);
+    }
+
+    const person = Person.create({
+      name: "John",
+      age: 20,
+      dog: Dog.create({ name: "Rex", breed: "Labrador" }),
     });
 
-    const record = TestRecordRef.create(
+    const updates: Resolved<Person, { dog: true }>[] = [];
+    const spy = vi.fn((person) => updates.push(person));
+
+    Person.subscribe(
+      person.id,
       {
-        firstNested: TwiceNestedMap.create({ taste: "sour" }, { owner: me }),
-        secondNested: TwiceNestedMap.create({ taste: "sweet" }, { owner: me }),
+        resolve: {
+          dog: true,
+        },
       },
-      { owner: me },
+      spy,
     );
 
-    expect(record.firstNested?.taste).toEqual("sour");
-    expect(record.firstNested?.id).toBeDefined();
-    expect(record.secondNested?.taste).toEqual("sweet");
-    expect(record.secondNested?.id).toBeDefined();
-    expect(Object.keys(record)).toEqual(["firstNested", "secondNested"]);
-    expect(Object.keys(record._refs)).toEqual(["firstNested", "secondNested"]);
+    expect(spy).not.toHaveBeenCalled();
+
+    await waitFor(() => expect(spy).toHaveBeenCalled());
+
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    expect(updates[0]?.dog.name).toEqual("Rex");
+
+    person.dog!.name = "Fido";
+
+    await waitFor(() => expect(spy).toHaveBeenCalledTimes(2));
+
+    expect(updates[1]?.dog.name).toEqual("Fido");
+
+    expect(spy).toHaveBeenCalledTimes(2);
   });
 });
 
@@ -1134,16 +1208,16 @@ describe("CoMap Typescript validation", async () => {
 
 describe("Creating and finding unique CoMaps", async () => {
   test("Creating and finding unique CoMaps", async () => {
-    const me = await Account.create({
-      creationProps: { name: "Tester McTesterson" },
-      crypto: Crypto,
-    });
+    const group = Group.create();
 
-    const group = await Group.create({
-      owner: me,
-    });
+    class Person extends CoMap {
+      name = co.string;
+      _height = co.number;
+      birthday = co.Date;
+      color = co.string;
+    }
 
-    const alice = TestMap.create(
+    const alice = Person.create(
       {
         name: "Alice",
         _height: 100,
@@ -1153,8 +1227,7 @@ describe("Creating and finding unique CoMaps", async () => {
       { owner: group, unique: { name: "Alice" } },
     );
 
-    const foundAlice = TestMap.findUnique({ name: "Alice" }, group.id, me);
-
+    const foundAlice = Person.findUnique({ name: "Alice" }, group.id);
     expect(foundAlice).toEqual(alice.id);
   });
 });