jazz-tools 0.18.25 → 0.18.26

package/src/tools/tests/coVector.test.ts

@@ -0,0 +1,891 @@
+import { assert, beforeEach, describe, expect, test, vi } from "vitest";
+import { cojsonInternals, Group, isControlledAccount, z } from "../index.js";
+import {
+  CoVector,
+  CoVectorSchema,
+  ControlledAccount,
+  Loaded,
+  co,
+} from "../internal.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+import { setupTwoNodes, waitFor } from "./utils.js";
+
+let me: ControlledAccount;
+
+beforeEach(async () => {
+  await setupJazzTestSync();
+  const account = await createJazzTestAccount({
+    isCurrentActiveAccount: true,
+    creationProps: { name: "Hermes Puggington" },
+  });
+  if (!isControlledAccount(account)) {
+    throw new Error("account is not a controlled account");
+  }
+  me = account;
+});
+
+const initNodeAndVector = async (
+  coVectorSchema: CoVectorSchema,
+  vectorInput: number[] | Float32Array = [1, 2, 3],
+) => {
+  const me = await createJazzTestAccount({
+    isCurrentActiveAccount: true,
+  });
+
+  const group = Group.create(me);
+  group.addMember("everyone", "reader");
+
+  const coVector = coVectorSchema.create(vectorInput, {
+    owner: group,
+  });
+
+  return { me, coVector };
+};
+
+const kbToBytes = (kb: number) => kb * 1024;
+const elementsForKb = (kb: number) => kbToBytes(kb) / 4;
+
+describe("Defining a co.vector()", () => {
+  test("given a non-positive dimensions count • throws an error", () => {
+    expect(() => co.vector(-1)).toThrow(
+      "co.vector() expects the vector dimensions count to be a positive integer",
+    );
+    expect(() => co.vector(0)).toThrow(
+      "co.vector() expects the vector dimensions count to be a positive integer",
+    );
+  });
+
+  test("given a non-integer dimensions count • throws an error", () => {
+    expect(() => co.vector(384.5)).toThrow(
+      "co.vector() expects the vector dimensions count to be a positive integer",
+    );
+  });
+
+  test("given a valid dimensions count • creates a CoVector schema", () => {
+    const EmbeddingSchema = co.vector(384);
+    expect(EmbeddingSchema.builtin).toBe("CoVector");
+    expect(EmbeddingSchema.dimensions).toBe(384);
+    expect(EmbeddingSchema.create).toBeDefined();
+  });
+});
+
+describe("Creating a CoVector", async () => {
+  const EmbeddingSchema = co.vector(3);
+  const { me } = await initNodeAndVector(EmbeddingSchema);
+
+  test("given a vector of mismatched dimensions count • throws an error", () => {
+    expect(() => EmbeddingSchema.create([1, 2, 3, 4, 5])).toThrow(
+      "Vector dimension mismatch! Expected 3 dimensions, got 5",
+    );
+  });
+
+  test("directly instantiating CoVector.create • throws an error", () => {
+    expect(() => CoVector.create([1, 2, 3])).toThrow(
+      "Instantiating CoVector without a dimensions count is not allowed. Use co.vector(...).create() instead.",
+    );
+  });
+
+  test("given a Array<number> with valid dimensions count • creates a CoVector", () => {
+    const embedding = EmbeddingSchema.create([1, 2, 3]);
+    expect(embedding).toBeInstanceOf(CoVector);
+    expect(embedding[0]).toBe(1);
+    expect(embedding[1]).toBe(2);
+    expect(embedding[2]).toBe(3);
+  });
+
+  test("given a Float32Array with valid dimensions count • creates a CoVector", () => {
+    const embedding = EmbeddingSchema.create(new Float32Array([1, 2, 3]));
+    expect(embedding).toBeInstanceOf(CoVector);
+    expect(embedding[0]).toBe(1);
+    expect(embedding[1]).toBe(2);
+    expect(embedding[2]).toBe(3);
+  });
+
+  test("given Account as owner • creates a CoVector", () => {
+    const embedding = EmbeddingSchema.create([1, 2, 3], me);
+    expect(embedding.$jazz.owner.myRole()).toEqual("admin");
+  });
+
+  test("given Group as owner • creates a CoVector", () => {
+    const group = Group.create(me);
+    const embedding = EmbeddingSchema.create([1, 2, 3], group);
+
+    expect(embedding.$jazz.owner).toEqual(group);
+  });
+});
+
+describe("CoVector structure", async () => {
+  const EmbeddingSchema = co.vector(5);
+  const vector = new Float32Array([1, 2, 3, 4, 5]);
+  const coVector = EmbeddingSchema.create(vector);
+
+  test("CoVector keys can be iterated over just like an Float32Array's", () => {
+    const keys = [];
+
+    for (const key in coVector) {
+      keys.push(key);
+    }
+
+    expect(keys).toEqual(Object.keys(vector));
+    expect(Object.keys(coVector)).toEqual(Object.keys(vector));
+  });
+
+  test("Float32Array can be constructed from a CoVector", () => {
+    expect(new Float32Array(coVector)).toEqual(vector);
+  });
+
+  test("a CoVector is structurally equal to a Float32Array", () => {
+    expect([...coVector]).toEqual([...vector]);
+  });
+
+  test("a CoVector identity is NOT equal to a Float32Array", () => {
+    expect(coVector).not.toEqual(vector);
+  });
+});
+
+describe("CoVector reader methods & properties (Float32Array-like)", async () => {
+  const EmbeddingSchema = co.vector(5);
+
+  const { me, coVector } = await initNodeAndVector(
+    EmbeddingSchema,
+    new Float32Array([1, 2, 3, 4, 5]),
+  );
+
+  // Properties
+  test("has .length", () => {
+    expect(coVector.length).toBe(5);
+  });
+  test("has .buffer", () => {
+    expect(coVector.buffer).toEqual(new Float32Array([1, 2, 3, 4, 5]).buffer);
+  });
+  test("has .byteLength", () => {
+    expect(coVector.byteLength).toBe(20);
+  });
+  test("has .byteOffset", () => {
+    expect(coVector.byteOffset).toBe(0);
+  });
+
+  test("has index access", () => {
+    expect(coVector[0]).toBe(1);
+    expect(coVector[1]).toBe(2);
+    expect(coVector[2]).toBe(3);
+    expect(coVector[3]).toBe(4);
+    expect(coVector[4]).toBe(5);
+  });
+
+  // Methods
+  test("supports .at", () => {
+    expect(coVector.at(0)).toBe(1);
+    expect(coVector.at(1)).toBe(2);
+    expect(coVector.at(2)).toBe(3);
+    expect(coVector.at(3)).toBe(4);
+    expect(coVector.at(4)).toBe(5);
+  });
+
+  test("supports .entries", () => {
+    expect(Array.from(coVector.entries())).toEqual([
+      [0, 1],
+      [1, 2],
+      [2, 3],
+      [3, 4],
+      [4, 5],
+    ]);
+  });
+
+  test("supports .every", () => {
+    expect(coVector.every((item) => item > 0)).toEqual(true);
+    expect(coVector.every((item) => item > 3)).toEqual(false);
+  });
+
+  test("supports .filter", () => {
+    expect(coVector.filter((item) => item > 3)).toEqual(
+      new Float32Array([4, 5]),
+    );
+  });
+
+  test("supports .find", () => {
+    expect(coVector.find((item) => item > 3)).toEqual(4);
+  });
+
+  test("supports .findIndex", () => {
+    expect(coVector.findIndex((item) => item > 3)).toEqual(3);
+  });
+
+  test("supports .findLast", () => {
+    expect(coVector.findLast((item) => item > 3)).toEqual(5);
+  });
+
+  test("supports .findLastIndex", () => {
+    expect(coVector.findLastIndex((item) => item > 3)).toEqual(4);
+  });
+
+  test("supports .forEach", () => {
+    const iterationFn = vi.fn();
+    coVector.forEach(iterationFn);
+
+    expect(iterationFn).toHaveBeenCalledTimes(5);
+
+    const f32 = new Float32Array([1, 2, 3, 4, 5]);
+    const calls = iterationFn.mock.calls;
+    expect(calls.length).toBe(5);
+    const expectedValue = [1, 2, 3, 4, 5];
+    for (let i = 0; i < 5; i++) {
+      const [value, index, arrayArg] = calls[i]!;
+      expect(value).toBe(expectedValue[i]);
+      expect(index).toBe(i);
+      expect(Array.from(arrayArg as any)).toEqual(Array.from(f32));
+    }
+  });
+
+  test("supports .includes", () => {
+    expect(coVector.includes(3)).toBe(true);
+    expect(coVector.includes(6)).toBe(false);
+  });
+
+  test("supports .indexOf", () => {
+    expect(coVector.indexOf(3)).toBe(2);
+    expect(coVector.indexOf(6)).toBe(-1);
+  });
+
+  test("supports .join", () => {
+    expect(coVector.join(":")).toEqual("1:2:3:4:5");
+  });
+
+  test("supports .keys", () => {
+    expect(Array.from(coVector.keys())).toEqual([0, 1, 2, 3, 4]);
+  });
+
+  test("supports .lastIndexOf", () => {
+    const coVector = EmbeddingSchema.create([1, 2, 3, 4, 3]);
+    expect(coVector.lastIndexOf(3)).toBe(4);
+    expect(coVector.lastIndexOf(6)).toBe(-1);
+  });
+
+  test("supports .map", () => {
+    expect(coVector.map((item) => item * 2)).toEqual(
+      new Float32Array([2, 4, 6, 8, 10]),
+    );
+  });
+
+  test("supports .reduce", () => {
+    const reducerFn = vi.fn((acc, item) => acc + item);
+
+    expect(coVector.reduce(reducerFn, 0)).toEqual(15);
+
+    const f32 = new Float32Array([1, 2, 3, 4, 5]);
+    const calls = (reducerFn as any).mock.calls as any[];
+    expect(calls.length).toBe(5);
+    const expectedAcc = [0, 1, 3, 6, 10];
+    const expectedVal = [1, 2, 3, 4, 5];
+    const expectedIdx = [0, 1, 2, 3, 4];
+    for (let i = 0; i < 5; i++) {
+      const call = calls[i] as any[];
+      expect(call[0]).toBe(expectedAcc[i]);
+      expect(call[1]).toBe(expectedVal[i]);
+      expect(call[2]).toBe(expectedIdx[i]);
+      expect(Array.from(call[3] as any)).toEqual(Array.from(f32));
+    }
+  });
+
+  test("supports .reduceRight", () => {
+    const reducerFn = vi.fn((acc, item) => acc + item);
+
+    expect(coVector.reduceRight(reducerFn, 0)).toEqual(15);
+
+    const f32 = new Float32Array([1, 2, 3, 4, 5]);
+    const calls = (reducerFn as any).mock.calls as any[];
+    expect(calls.length).toBe(5);
+    const expectedAcc = [0, 5, 9, 12, 14];
+    const expectedVal = [5, 4, 3, 2, 1];
+    const expectedIdx = [4, 3, 2, 1, 0];
+    for (let i = 0; i < 5; i++) {
+      const call = calls[i] as any[];
+      expect(call[0]).toBe(expectedAcc[i]);
+      expect(call[1]).toBe(expectedVal[i]);
+      expect(call[2]).toBe(expectedIdx[i]);
+      expect(Array.from(call[3] as any)).toEqual(Array.from(f32));
+    }
+  });
+
+  test("supports .slice", () => {
+    expect(coVector.slice()).toEqual(new Float32Array([1, 2, 3, 4, 5]));
+    expect(coVector.slice(2)).toEqual(new Float32Array([3, 4, 5]));
+    expect(coVector.slice(2, 4)).toEqual(new Float32Array([3, 4]));
+  });
+
+  test("supports .some", () => {
+    expect(coVector.some((item) => item > 3)).toBe(true);
+    expect(coVector.some((item) => item > 5)).toBe(false);
+  });
+
+  test("supports .subarray", () => {
+    expect(coVector.subarray().toString()).toEqual("1,2,3,4,5");
+    expect(coVector.subarray(2).toString()).toEqual("3,4,5");
+    expect(coVector.subarray(2, 4).toString()).toEqual("3,4");
+  });
+
+  test("supports .toJSON (JSON.stringify)", () => {
+    expect(JSON.stringify(coVector)).toEqual(`[1,2,3,4,5]`);
+  });
+
+  test("supports .toLocaleString", () => {
+    expect(coVector.toLocaleString()).toEqual("1,2,3,4,5");
+    expect(
+      coVector.toLocaleString("ja-JP", { style: "currency", currency: "JPY" }),
+    ).toEqual("￥1,￥2,￥3,￥4,￥5");
+  });
+
+  test("supports .toReversed", () => {
+    expect(coVector.toReversed()).toEqual(new Float32Array([5, 4, 3, 2, 1]));
+  });
+
+  test("supports .toSorted", () => {
+    const coVector = EmbeddingSchema.create([2, 3, 4, 5, 1]);
+    expect(coVector.toSorted()).toEqual(new Float32Array([1, 2, 3, 4, 5]));
+  });
+
+  test("supports .toString", () => {
+    expect(coVector.toString()).toEqual("1,2,3,4,5");
+  });
+
+  test("supports .values", () => {
+    expect(Array.from(coVector.values())).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  test("supports .with", () => {
+    expect(coVector.with(4, 2).toString()).toEqual("1,2,3,4,2");
+  });
+});
+
+describe("CoVector mutation methods", async () => {
+  const EmbeddingSchema = co.vector(5);
+  const { coVector } = await initNodeAndVector(
+    EmbeddingSchema,
+    new Float32Array([1, 2, 3, 4, 5]),
+  );
+
+  const expectedErrorMessage = /Cannot mutate a CoVector/i;
+
+  test("calling .copyWithin • throws an error", () => {
+    expect(() => coVector.copyWithin(1, 2)).toThrow(expectedErrorMessage);
+  });
+  test("calling .fill • throws an error", () => {
+    expect(() => coVector.fill(1)).toThrow(expectedErrorMessage);
+  });
+  test("calling .reverse • throws an error", () => {
+    expect(() => coVector.reverse()).toThrow(expectedErrorMessage);
+  });
+  test("calling .set • throws an error", () => {
+    expect(() => coVector.set(new Float32Array([6, 7, 8]))).toThrow(
+      expectedErrorMessage,
+    );
+  });
+  test("calling .sort • throws an error", () => {
+    expect(() => coVector.sort()).toThrow(expectedErrorMessage);
+  });
+});
+
+describe("Vector calculations on .$jazz", async () => {
+  const VectorSchema = co.vector(5);
+
+  const vecA = new Float32Array([1, 2, 3, 4, 5]);
+  const vecB = new Float32Array([5, 4, 3, 2, 1]);
+  const arrB = [5, 4, 3, 2, 1];
+
+  const coVectorA = VectorSchema.create(vecA);
+  const coVectorB = VectorSchema.create(vecB);
+
+  describe("magnitude", () => {
+    const magnitudeApprox: [number, number] = [7.4162, 4];
+
+    test("returns the magnitude of the vector", () => {
+      expect(coVectorA.$jazz.magnitude()).toBeCloseTo(...magnitudeApprox);
+    });
+  });
+
+  describe("normalize", () => {
+    const normalized = new Float32Array([
+      0.1348399668931961, 0.2696799337863922, 0.4045199155807495,
+      0.5393598675727844, 0.6741998791694641,
+    ]);
+
+    test("returns the normalized vector", () => {
+      expect(coVectorA.$jazz.normalize()).toEqual(normalized);
+    });
+  });
+
+  describe("dot product", () => {
+    const dotProduct = 35;
+
+    test("returns the dot product of the 2 vectors", () => {
+      expect(coVectorA.$jazz.dotProduct(arrB)).toBe(dotProduct);
+      expect(coVectorA.$jazz.dotProduct(vecB)).toBe(dotProduct);
+      expect(coVectorA.$jazz.dotProduct(coVectorB)).toBe(dotProduct);
+    });
+  });
+
+  describe("cosine similarity", () => {
+    const similarityApprox: [number, number] = [0.6364, 4];
+
+    test("returns the cosine similarity of the 2 vectors", () => {
+      expect(coVectorA.$jazz.cosineSimilarity(arrB)).toBeCloseTo(
+        ...similarityApprox,
+      );
+      expect(coVectorA.$jazz.cosineSimilarity(vecB)).toBeCloseTo(
+        ...similarityApprox,
+      );
+      expect(coVectorA.$jazz.cosineSimilarity(coVectorB)).toBeCloseTo(
+        ...similarityApprox,
+      );
+    });
+  });
+});
+
+describe("CoVector loading & availability", async () => {
+  const EmbeddingSchema = co.vector(3);
+
+  test("when .waitForSync is called • the entire vector is uploaded", async () => {
+    const { clientNode, serverNode, clientAccount } = await setupTwoNodes();
+
+    const embedding = EmbeddingSchema.create([1, 2, 3], {
+      owner: clientAccount,
+    });
+    await embedding.$jazz.waitForSync({ timeout: 1000 });
+
+    // Killing the client node so the serverNode can't load the vector from it
+    clientNode.gracefulShutdown();
+
+    const loadedEmbedding = await serverNode.load(embedding.$jazz.raw.id);
+
+    expect(loadedEmbedding).not.toBe("unavailable");
+
+    if (loadedEmbedding !== "unavailable") {
+      // check that the data was uploaded (3 transactions for smaller vectors: start, data, end)
+      expect(loadedEmbedding?.core?.verifiedTransactions.length).toBe(3);
+    }
+  });
+
+  test("when .waitForSync is called on 1024 kB vector • the entire vector is uploaded", async () => {
+    const { clientNode, serverNode, clientAccount } = await setupTwoNodes();
+
+    const kB = 1024;
+
+    const EmbeddingSchema = co.vector(elementsForKb(kB));
+    const embedding = EmbeddingSchema.create(
+      new Float32Array(elementsForKb(kB)).fill(0.5),
+      { owner: clientAccount },
+    );
+    await embedding.$jazz.waitForSync({ timeout: 1000 });
+
+    // Killing the client node so the serverNode can't load the vector from it
+    clientNode.gracefulShutdown();
+
+    const loadedEmbedding = await serverNode.load(embedding.$jazz.raw.id);
+
+    expect(loadedEmbedding).not.toBe("unavailable");
+
+    // check that the data was uploaded
+    if (loadedEmbedding !== "unavailable") {
+      const expectedTransactionsCount = Math.ceil(
+        kbToBytes(kB) /
+          cojsonInternals.TRANSACTION_CONFIG.MAX_RECOMMENDED_TX_SIZE,
+      );
+      expect(loadedEmbedding?.core?.verifiedTransactions.length).toBe(
+        expectedTransactionsCount + 2, // +2 for the start and end transactions
+      );
+    }
+  });
+
+  test("when calling .load from different account • syncs across peers", async () => {
+    const { coVector } = await initNodeAndVector(
+      EmbeddingSchema,
+      new Float32Array([9, 8, 7]),
+    );
+
+    const alice = await createJazzTestAccount();
+
+    const loadedVector = await EmbeddingSchema.load(coVector.$jazz.id, {
+      loadAs: alice,
+    });
+
+    assert(loadedVector);
+    expect(loadedVector.length).toBe(3);
+    expect(loadedVector[0]).toBe(9);
+    expect(loadedVector[1]).toBe(8);
+    expect(loadedVector[2]).toBe(7);
+
+    // Check that the cores are not the same...
+    expect(loadedVector.$jazz.raw.core).not.toEqual(coVector.$jazz.raw.core);
+
+    // ...but the known states are the same
+    expect(loadedVector.$jazz.raw.core.knownState()).toEqual(
+      coVector.$jazz.raw.core.knownState(),
+    );
+    expect(loadedVector.$jazz.raw.core.verifiedTransactions.length).toBe(
+      coVector.$jazz.raw.core.verifiedTransactions.length,
+    );
+  });
+
+  test("when calling .load on a 1024 kB vector from different account • syncs across peers", async () => {
+    const kb = 1024;
+
+    const EmbeddingSchema = co.vector(elementsForKb(kb));
+    const { coVector } = await initNodeAndVector(
+      EmbeddingSchema,
+      new Float32Array(elementsForKb(kb)).fill(0.5),
+    );
+
+    const alice = await createJazzTestAccount();
+
+    const loadedVector = await EmbeddingSchema.load(coVector.$jazz.id, {
+      loadAs: alice,
+    });
+
+    assert(loadedVector);
+    expect(loadedVector).toBeInstanceOf(CoVector);
+    expect(loadedVector.length).toBe(elementsForKb(kb));
+    expect(loadedVector.every((item) => item === 0.5)).toBe(true);
+
+    // Check that the cores are not the same...
+    expect(loadedVector.$jazz.raw.core).not.toEqual(coVector.$jazz.raw.core);
+
+    // ...but the known states are the same
+    expect(loadedVector.$jazz.raw.core.knownState()).toEqual(
+      coVector.$jazz.raw.core.knownState(),
+    );
+    expect(loadedVector.$jazz.raw.core.verifiedTransactions.length).toBe(
+      coVector.$jazz.raw.core.verifiedTransactions.length,
+    );
+  });
+});
+
+describe("CoVector in subscription", async () => {
+  const EmbeddingSchema = co.vector(3);
+  const DocsChunk = co.map({
+    content: z.string(),
+    embedding: EmbeddingSchema,
+  });
+  const Docs = co.list(DocsChunk);
+
+  describe("standalone CoVector", async () => {
+    test("subscribing to locally available CoVector • sends update holding the CoVector", async () => {
+      const embedding = EmbeddingSchema.create(new Float32Array([10, 20, 30]));
+
+      const updates: Loaded<typeof EmbeddingSchema>[] = [];
+      const updatesCallback = vi.fn((embedding) => updates.push(embedding));
+
+      EmbeddingSchema.subscribe(
+        embedding.$jazz.id,
+        { loadAs: me },
+        updatesCallback,
+      );
+
+      expect(updatesCallback).not.toHaveBeenCalled();
+
+      await waitFor(() => expect(updatesCallback).toHaveBeenCalled());
+
+      expect(updatesCallback).toHaveBeenCalledTimes(1);
+
+      expect(updates[0]).toBeInstanceOf(CoVector);
+      expect(updates[0]?.toString()).toEqual("10,20,30");
+    });
+
+    test("subscribing to remotely available CoVector • sends update holding the CoVector", async () => {
+      const group = Group.create();
+      group.addMember("everyone", "writer");
+
+      const embedding = EmbeddingSchema.create(
+        new Float32Array([10, 20, 30]),
+        group,
+      );
+
+      const userB = await createJazzTestAccount();
+
+      const updates: Loaded<typeof EmbeddingSchema>[] = [];
+      const updatesCallback = vi.fn((embedding) => updates.push(embedding));
+
+      EmbeddingSchema.subscribe(
+        embedding.$jazz.id,
+        { loadAs: userB },
+        updatesCallback,
+      );
+
+      expect(updatesCallback).not.toHaveBeenCalled();
+
+      await waitFor(() => expect(updatesCallback).toHaveBeenCalled());
+
+      expect(updatesCallback).toHaveBeenCalledTimes(1);
+
+      expect(updates[0]).toBeInstanceOf(CoVector);
+      expect(updates[0]?.toString()).toEqual("10,20,30");
+    });
+  });
+
+  describe("CoVector in CoList[CoMap]", async () => {
+    describe("locally available list", async () => {
+      test("subscribing with deep resolve • sends update holding the CoVectors", async () => {
+        const docs = Docs.create([
+          DocsChunk.create({
+            content: "Call GET to retrieve document",
+            embedding: EmbeddingSchema.create(new Float32Array([1, 2, 3])),
+          }),
+          DocsChunk.create({
+            content: "Call POST to create a new document",
+            embedding: EmbeddingSchema.create(new Float32Array([4, 5, 6])),
+          }),
+        ]);
+
+        const updates: Loaded<typeof Docs, { $each: true }>[] = [];
+        const updatesCallback = vi.fn((docs) => updates.push(docs));
+
+        Docs.subscribe(
+          docs.$jazz.id,
+          { resolve: { $each: true } },
+          updatesCallback,
+        );
+
+        expect(updatesCallback).not.toHaveBeenCalled();
+
+        await waitFor(() => expect(updatesCallback).toHaveBeenCalled());
+
+        expect(updatesCallback).toHaveBeenCalledTimes(1);
+
+        expect(updates[0]?.[0]?.content).toEqual(
+          "Call GET to retrieve document",
+        );
+        expect(updates[0]?.[1]?.content).toEqual(
+          "Call POST to create a new document",
+        );
+        expect(updates[0]?.[0]?.embedding?.toString()).toBe("1,2,3");
+        expect(updates[0]?.[1]?.embedding?.toString()).toBe("4,5,6");
+
+        // Update the second document's embedding
+        docs[1]!.$jazz.set(
+          "embedding",
+          EmbeddingSchema.create(new Float32Array([7, 8, 9])),
+        );
+
+        await waitFor(() => expect(updatesCallback).toHaveBeenCalledTimes(2));
+
+        expect(updates[1]?.[0]?.embedding?.toString()).toBe("1,2,3");
+        expect(updates[1]?.[1]?.embedding?.toString()).toBe("7,8,9");
+
+        expect(updatesCallback).toHaveBeenCalledTimes(2);
+      });
+
+      test("subscribing with autoload • sends update holding the CoVectors", async () => {
+        const docs = Docs.create([
+          DocsChunk.create({
+            content: "Call GET to retrieve document",
+            embedding: EmbeddingSchema.create(new Float32Array([1, 2, 3])),
+          }),
+          DocsChunk.create({
+            content: "Call POST to create a new document",
+            embedding: EmbeddingSchema.create(new Float32Array([4, 5, 6])),
+          }),
+        ]);
+
+        const updates: Loaded<typeof Docs>[] = [];
+        const updatesCallback = vi.fn((docs) => updates.push(docs));
+
+        Docs.subscribe(docs.$jazz.id, {}, updatesCallback);
+
+        expect(updatesCallback).not.toHaveBeenCalled();
+
+        await waitFor(() => expect(updatesCallback).toHaveBeenCalled());
+
+        expect(updatesCallback).toHaveBeenCalledTimes(1);
+
+        expect(updates[0]?.[0]?.content).toEqual(
+          "Call GET to retrieve document",
+        );
+        expect(updates[0]?.[1]?.content).toEqual(
+          "Call POST to create a new document",
+        );
+        expect(updates[0]?.[0]?.embedding?.toString()).toBe("1,2,3");
+        expect(updates[0]?.[1]?.embedding?.toString()).toBe("4,5,6");
+
+        // Update the second document's embedding
+        docs[1]!.$jazz.set(
+          "embedding",
+          EmbeddingSchema.create(new Float32Array([7, 8, 9])),
+        );
+
+        await waitFor(() => expect(updatesCallback).toHaveBeenCalledTimes(2));
+
+        expect(updates[1]?.[0]?.embedding?.toString()).toBe("1,2,3");
+        expect(updates[1]?.[1]?.embedding?.toString()).toBe("7,8,9");
+
+        expect(updatesCallback).toHaveBeenCalledTimes(2);
+      });
+    });
+
+    describe("remotely available list", async () => {
+      test("subscribing with deep resolve • sends update holding the CoVectors", async () => {
+        const group = Group.create({ owner: me });
+        group.addMember("everyone", "writer");
+
+        const docs = Docs.create(
+          [
+            DocsChunk.create(
+              {
+                content: "Call GET to retrieve document",
+                embedding: EmbeddingSchema.create(
+                  new Float32Array([1, 2, 3]),
+                  group,
+                ),
+              },
+              group,
+            ),
+            DocsChunk.create(
+              {
+                content: "Call POST to create a new document",
+                embedding: EmbeddingSchema.create(
+                  new Float32Array([4, 5, 6]),
+                  group,
+                ),
+              },
+              group,
+            ),
+          ],
+          group,
+        );
+
+        const userB = await createJazzTestAccount();
+
+        const updates: Loaded<typeof Docs, { $each: true }>[] = [];
+        const updatesCallback = vi.fn((docs) => updates.push(docs));
+
+        Docs.subscribe(
+          docs.$jazz.id,
+          {
+            resolve: { $each: true },
+            loadAs: userB,
+          },
+          updatesCallback,
+        );
+
+        expect(updatesCallback).not.toHaveBeenCalled();
+
+        await waitFor(() => expect(updatesCallback).toHaveBeenCalled());
+
+        expect(updatesCallback).toHaveBeenCalledTimes(1);
+
+        await waitFor(() => {
+          expect(updates[0]?.[0]?.embedding?.toString()).toBe("1,2,3");
+          expect(updates[0]?.[1]?.embedding?.toString()).toBe("4,5,6");
+        });
+
+        // Update the second document's embedding
+        docs[1]!.$jazz.set(
+          "embedding",
+          EmbeddingSchema.create(new Float32Array([7, 8, 9]), group),
+        );
+
+        await waitFor(() => expect(updatesCallback).toHaveBeenCalledTimes(5));
+
+        expect(updates[1]?.[0]?.embedding?.toString()).toBe("1,2,3");
+        expect(updates[1]?.[1]?.embedding?.toString()).toBe("7,8,9");
+
+        expect(updatesCallback).toHaveBeenCalledTimes(5);
+      });
+
+      test("subscribing with autoload • sends update holding the CoVectors", async () => {
+        const group = Group.create({ owner: me });
+        group.addMember("everyone", "writer");
+
+        const docs = Docs.create(
+          [
+            DocsChunk.create(
+              {
+                content: "Call GET to retrieve document",
+                embedding: EmbeddingSchema.create(
+                  new Float32Array([1, 2, 3]),
+                  group,
+                ),
+              },
+              group,
+            ),
+            DocsChunk.create(
+              {
+                content: "Call POST to create a new document",
+                embedding: EmbeddingSchema.create(
+                  new Float32Array([4, 5, 6]),
+                  group,
+                ),
+              },
+              group,
+            ),
+          ],
+          group,
+        );
+
+        const userB = await createJazzTestAccount();
+
+        const updates: Loaded<typeof Docs>[] = [];
+        const updatesCallback = vi.fn((docs) => updates.push(docs));
+
+        Docs.subscribe(
+          docs.$jazz.id,
+          {
+            loadAs: userB,
+          },
+          updatesCallback,
+        );
+
+        expect(updatesCallback).not.toHaveBeenCalled();
+
+        await waitFor(() => expect(updatesCallback).toHaveBeenCalled());
+
+        await waitFor(() => {
+          expect(updates[0]?.[0]?.embedding?.toString()).toBe("1,2,3");
+          expect(updates[0]?.[1]?.embedding?.toString()).toBe("4,5,6");
+        });
+
+        // Update the second document's embedding
+        docs[1]!.$jazz.set(
+          "embedding",
+          EmbeddingSchema.create(new Float32Array([7, 8, 9]), group),
+        );
+
+        await waitFor(() => expect(updatesCallback).toHaveBeenCalledTimes(7));
+
+        expect(updates[1]?.[0]?.embedding?.toString()).toBe("1,2,3");
+        expect(updates[1]?.[1]?.embedding?.toString()).toBe("7,8,9");
+
+        expect(updatesCallback).toHaveBeenCalledTimes(7);
+      });
+    });
+  });
+});
+
+describe("CoVector dimension mismatch after loading", async () => {
+  test("loading a CoVector with an incompatible schema • throws an error", async () => {
+    const { coVector } = await initNodeAndVector(
+      co.vector(3),
+      new Float32Array([1, 2, 3]),
+    );
+
+    await expect(co.vector(9).load(coVector.$jazz.id)).rejects.toThrow(
+      /Vector dimension mismatch/,
+    );
+  });
+
+  test("subscribing to a CoVector with an incompatible schema • throws an error", async () => {
+    const EmbeddingSchema = co.vector(3);
+
+    const { coVector } = await initNodeAndVector(
+      EmbeddingSchema,
+      new Float32Array([1, 2, 3]),
+    );
+
+    const updates: Loaded<typeof EmbeddingSchema>[] = [];
+    const updatesCallback = vi.fn((embedding) => updates.push(embedding));
+
+    expect(() =>
+      co.vector(5).subscribe(coVector.$jazz.id, updatesCallback),
+    ).toThrow(/Vector dimension mismatch/);
+
+    expect(updatesCallback).not.toHaveBeenCalled();
+  });
+});