cojson 0.20.7 → 0.20.8

package/src/tests/coValueCore.test.ts

@@ -403,7 +403,8 @@ test("(smoke test) records transactions from local node", async () => {
   });
 
   assert(typeof value !== "number" && !!value?.count);
-  expect(value.count).toBe(3);
+  // Creating a group now creates 4 transactions: admin member, key revelation, readKey, and groupSealer
+  expect(value.count).toBe(4);
 });
 
 test("creating a coValue with a group should't trigger automatically a content creation (performance)", () => {
@@ -866,42 +867,30 @@ describe("markErrored and isErroredInPeer", () => {
   });
 });
 
-test("knownState should return the same object until the CoValue is modified", () => {
+test("knownState should reflect modifications", () => {
   const [agent, sessionID] = randomAgentAndSessionID();
   const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
 
   const group = node.createGroup();
   const map = group.createMap();
 
-  // Get the knownState for the first time
+  // Get the knownState before any modification
   const knownState1 = map.core.knownState();
 
-  // Get the knownState again - should be the same object
-  const knownState2 = map.core.knownState();
-  expect(knownState2).toBe(knownState1);
-
-  // Call it multiple times to ensure it's always the same object
-  const knownState3 = map.core.knownState();
-  expect(knownState3).toBe(knownState1);
-
   // Now modify the CoValue by making a transaction
   map.set("hello", "world");
 
-  // Get the knownState after modification - should be a different object
-  const knownState4 = map.core.knownState();
-  expect(knownState4).not.toBe(knownState1);
-
-  // Verify that subsequent calls still return the same (new) object
-  const knownState5 = map.core.knownState();
-  expect(knownState5).toBe(knownState4);
+  // Get the knownState after modification - should have updated sessions
+  const knownState2 = map.core.knownState();
+  expect(knownState2).not.toEqual(knownState1);
 
   // Make another modification
   map.set("foo", "bar");
 
-  // Get the knownState after second modification - should be yet another different object
-  const knownState6 = map.core.knownState();
-  expect(knownState6).not.toBe(knownState4);
-  expect(knownState6).not.toBe(knownState1);
+  // Get the knownState after second modification - should have updated sessions again
+  const knownState3 = map.core.knownState();
+  expect(knownState3).not.toEqual(knownState2);
+  expect(knownState3).not.toEqual(knownState1);
 });
 
 describe("provideHeader uniqueness validation", () => {

package/src/tests/crypto.test.ts

@@ -3,9 +3,11 @@ import { x25519 } from "@noble/curves/ed25519";
 import { blake3 } from "@noble/hashes/blake3";
 import { base58, base64url } from "@scure/base";
 import { expect, test, vi } from "vitest";
+import { shortHashLength } from "../crypto/crypto.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { SessionID } from "../ids.js";
 import { stableStringify } from "../jsonStringify.js";
+import { JsonValue } from "../jsonValue.js";
 
 const crypto = await WasmCrypto.create();
 
@@ -167,3 +169,108 @@ test(`Unsealing malformed JSON logs error [${name}]`, () => {
     "Failed to decrypt/parse sealed message",
   );
 });
+
+// ============================================================================
+// shortHash implementation consistency tests
+// ============================================================================
+
+/**
+ * Compute shortHash using the base TypeScript implementation (reference).
+ * This mirrors the CryptoProvider.shortHash method exactly.
+ */
+function referenceShortHash(value: JsonValue): string {
+  const textEncoder = new TextEncoder();
+  return `shortHash_z${base58.encode(
+    blake3(textEncoder.encode(stableStringify(value))).slice(
+      0,
+      shortHashLength,
+    ),
+  )}`;
+}
+
+test(`shortHash WASM implementation matches TypeScript reference [${name}]`, () => {
+  // Test with simple object
+  const simpleObj = { hello: "world" };
+  expect(crypto.shortHash(simpleObj)).toBe(referenceShortHash(simpleObj));
+
+  // Test with object where key order differs (should produce same hash due to stableStringify)
+  const objA = { b: "world", a: "hello" };
+  const objB = { a: "hello", b: "world" };
+  expect(crypto.shortHash(objA)).toBe(referenceShortHash(objA));
+  expect(crypto.shortHash(objB)).toBe(referenceShortHash(objB));
+  expect(crypto.shortHash(objA)).toBe(crypto.shortHash(objB));
+
+  // Test with nested objects
+  const nestedObj = { outer: { inner: { deep: "value" } }, top: 123 };
+  expect(crypto.shortHash(nestedObj)).toBe(referenceShortHash(nestedObj));
+
+  // Test with arrays
+  const arrayValue = [1, 2, 3, "four", { five: 5 }];
+  expect(crypto.shortHash(arrayValue)).toBe(referenceShortHash(arrayValue));
+
+  // Test with primitives
+  expect(crypto.shortHash("string")).toBe(referenceShortHash("string"));
+  expect(crypto.shortHash(42)).toBe(referenceShortHash(42));
+  expect(crypto.shortHash(true)).toBe(referenceShortHash(true));
+  expect(crypto.shortHash(null)).toBe(referenceShortHash(null));
+
+  // Test with empty structures
+  expect(crypto.shortHash({})).toBe(referenceShortHash({}));
+  expect(crypto.shortHash([])).toBe(referenceShortHash([]));
+});
+
+test(`shortHash produces correct format [${name}]`, () => {
+  const value = { test: "data" };
+  const hash = crypto.shortHash(value);
+
+  // Should start with "shortHash_z" prefix
+  expect(hash).toMatch(/^shortHash_z/);
+
+  // The base58 encoded part should be reasonable length (19 bytes base58 encoded)
+  const base58Part = hash.substring("shortHash_z".length);
+  expect(base58Part.length).toBeGreaterThan(0);
+
+  // Should only contain valid base58 characters
+  expect(base58Part).toMatch(
+    /^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]+$/,
+  );
+});
+
+test(`shortHash with complex nested structure matches reference [${name}]`, () => {
+  const complexValue = {
+    users: [
+      { id: 1, name: "Alice", active: true },
+      { id: 2, name: "Bob", active: false },
+    ],
+    metadata: {
+      created: 1234567890,
+      tags: ["important", "test"],
+      config: {
+        nested: {
+          deeply: {
+            value: "found",
+          },
+        },
+      },
+    },
+    nullField: null,
+    emptyArray: [],
+    emptyObject: {},
+  };
+
+  expect(crypto.shortHash(complexValue)).toBe(referenceShortHash(complexValue));
+});
+
+test(`shortHash with special characters matches reference [${name}]`, () => {
+  // Test with unicode
+  const unicodeValue = { emoji: "🎉", chinese: "你好", arabic: "مرحبا" };
+  expect(crypto.shortHash(unicodeValue)).toBe(referenceShortHash(unicodeValue));
+
+  // Test with escape sequences
+  const escapeValue = {
+    quote: 'has "quotes"',
+    newline: "has\nnewline",
+    tab: "has\ttab",
+  };
+  expect(crypto.shortHash(escapeValue)).toBe(referenceShortHash(escapeValue));
+});

package/src/tests/deleteCoValue.test.ts

@@ -22,7 +22,7 @@ function makeDeleteMarkerTransaction(core: CoValueCore, madeAt?: number) {
     (sessionID) => isDeleteSessionID(sessionID as SessionID),
   ) as SessionID;
   assert(deleteSessionID);
-  const log = core.verified?.sessions.get(deleteSessionID);
+  const log = core.verified?.getSession(deleteSessionID);
   assert(log?.lastSignature);
   const tx = log.transactions.at(-1);
   assert(tx);
@@ -123,7 +123,7 @@ test("rejects delete marker ingestion from non-admin (ownedByGroup, skipVerify=f
     reason: "NotAdmin",
   });
   expect(map.core.isDeleted).toBe(false);
-  expect(map.core.verified?.sessions.get(deleteSessionID)).toBeUndefined();
+  expect(map.core.verified?.getSession(deleteSessionID)).toBeUndefined();
 });
 
 test("accepts delete marker ingestion from admin (ownedByGroup, skipVerify=false) and marks deleted", async () => {
@@ -187,7 +187,7 @@ test("rejects delete session ingestion when attempting to append a second transa
   expect(first).toBeUndefined();
   expect(mapOnBob.core.isDeleted).toBe(true);
   expect(
-    mapOnBob.core.verified?.sessions.get(deleteSessionID)?.transactions,
+    mapOnBob.core.verified?.getSession(deleteSessionID)?.transactions,
   ).toHaveLength(1);
 
   const second = mapOnBob.core.tryAddTransactions(
@@ -210,7 +210,7 @@ test("rejects delete session ingestion when attempting to append a second transa
     );
   }
   expect(
-    mapOnBob.core.verified?.sessions.get(deleteSessionID)?.transactions,
+    mapOnBob.core.verified?.getSession(deleteSessionID)?.transactions,
   ).toHaveLength(1);
 });
 
@@ -253,7 +253,7 @@ test("rejects delete session ingestion when attempting to add multiple delete tr
       /Delete transaction must be the only transaction in the session/,
     );
   }
-  expect(mapOnBob.core.verified?.sessions.get(deleteSessionID)).toBeUndefined();
+  expect(mapOnBob.core.verified?.getSession(deleteSessionID)).toBeUndefined();
 });
 
 test("skipVerify=true ingestion marks deleted even for non-admin delete marker", async () => {

package/src/tests/group.inheritance.test.ts

@@ -468,6 +468,9 @@ describe("extend", () => {
     const childGroup = node1.node.createGroup();
     childGroup.extend(parentGroup, "admin");
 
+    // Wait for childGroup to sync so node3 sees the groupSealer field
+    await childGroup.core.waitForSync();
+
     const sharedGroup = node3.node.createGroup();
 
     // Account3 does not have permissions over the childGroup being extended
@@ -485,6 +488,9 @@ describe("extend", () => {
     const testMap = sharedGroup.createMap();
     testMap.set("name", "Test");
 
+    // Wait for sharedGroup to sync so other nodes can resolve keys via groupSealer
+    await sharedGroup.core.waitForSync();
+
     // node1 should be able to access the map because it is admin of the childGroup
     const testMapOnNode1 = expectMap(
       await loadCoValueOrFail(node1.node, testMap.id),
@@ -520,6 +526,9 @@ describe("extend", () => {
     const childGroup = node1.node.createGroup();
     childGroup.extend(parentGroup, "admin");
 
+    // Wait for childGroup to sync so node3 sees the groupSealer field
+    await childGroup.core.waitForSync();
+
     const sharedGroup = node3.node.createGroup();
 
     // Account3 does not have permissions over the childGroup being extended
@@ -538,10 +547,17 @@ describe("extend", () => {
     newParentGroup.addMember(account4OnNode1, "admin");
     childGroup.extend(newParentGroup);
 
+    // Wait for sharedGroup and childGroup updates to sync
+    await sharedGroup.core.waitForSync();
+    await childGroup.core.waitForSync();
+
     // Create a map owned by sharedGroup
     const testMap = sharedGroup.createMap();
     testMap.set("name", "Test");
 
+    // Wait for map to sync
+    await testMap.core.waitForSync();
+
     // Account4 should be able to access the map because it is admin of newParentGroup
     const testMapOnNode4 = expectMap(
       await loadCoValueOrFail(node4.node, testMap.id),

package/src/tests/group.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "vitest";
 import { RawCoList } from "../coValues/coList.js";
 import { RawCoMap } from "../coValues/coMap.js";
 import { RawCoStream } from "../coValues/coStream.js";
-import { RawBinaryCoStream } from "../coValues/coStream.js";
+import { RawBinaryCoStream } from "../coValues/binaryCoStream.js";
 import type { RawCoValue, RawGroup } from "../exports.js";
 import type { NewContentMessage } from "../sync.js";
 import {
@@ -70,6 +70,34 @@ test("Can create a FileStream in a group", () => {
   expect(stream instanceof RawBinaryCoStream).toEqual(true);
 });
 
+test("Group without name has name undefined", () => {
+  const node = nodeWithRandomAgentAndSessionID();
+  const group = node.createGroup();
+  expect(group.name).toBeUndefined();
+});
+
+test("Group created with name returns that name", () => {
+  const node = nodeWithRandomAgentAndSessionID();
+  const group = node.createGroup(undefined, { name: "My Group" });
+  expect(group.name).toBe("My Group");
+});
+
+test("Group created with empty name has name undefined (meta not set)", () => {
+  const node = nodeWithRandomAgentAndSessionID();
+  const group = node.createGroup(undefined, { name: "" });
+  expect(group.name).toBeUndefined();
+});
+
+test("Group with name persists after sync and load", async () => {
+  const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+  const group = node1.node.createGroup(undefined, { name: "Synced Group" });
+  expect(group.name).toBe("Synced Group");
+  await group.core.waitForSync();
+
+  const loaded = expectGroup(await loadCoValueOrFail(node2.node, group.id));
+  expect(loaded.name).toBe("Synced Group");
+});
+
 test("Remove a member from a group where the admin role is inherited", async () => {
   const { node1, node2, node3 } = await createThreeConnectedNodes(
     "server",