cojson 0.6.7 → 0.7.0-alpha.0

package/src/tests/permissions.test.ts

@@ -1,6 +1,7 @@
+import { expect, test, beforeEach } from "vitest";
 import { newRandomSessionID } from "../coValueCore.js";
 import { expectMap } from "../coValue.js";
-import { Group } from "../coValues/group.js";
+import { RawGroup } from "../coValues/group.js";
 import {
     createdNowUnique,
     newRandomKeySecret,
@@ -20,6 +21,12 @@ import {
 import { ControlledAgent, cojsonReady } from "../index.js";
 import { expectGroup } from "../typeUtils/expectGroup.js";
 
+import { webcrypto } from "node:crypto";
+if (!("crypto" in globalThis)) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (globalThis as any).crypto = webcrypto;
+}
+
 beforeEach(async () => {
     await cojsonReady;
 });
@@ -35,7 +42,7 @@ test("Initial admin can add another admin to a group (high level)", () => {
 test("Added admin can add a third admin to a group", () => {
     const { groupCore, otherAdmin, node } = groupWithTwoAdmins();
 
-    let groupAsOtherAdmin = expectGroup(
+    const groupAsOtherAdmin = expectGroup(
         groupCore
             .testWithDifferentAccount(
                 otherAdmin,
@@ -48,18 +55,14 @@ test("Added admin can add a third admin to a group", () => {
 
     const thirdAdmin = node.createAccount("thirdAdmin");
 
-    groupAsOtherAdmin = groupAsOtherAdmin.edit((editable) => {
-        editable.set(thirdAdmin.id, "admin", "trusting");
-        expect(editable.get(thirdAdmin.id)).toEqual("admin");
-    });
-
+    groupAsOtherAdmin.set(thirdAdmin.id, "admin", "trusting");
     expect(groupAsOtherAdmin.get(thirdAdmin.id)).toEqual("admin");
 });
 
 test("Added adming can add a third admin to a group (high level)", () => {
     const { group, otherAdmin, node } = groupWithTwoAdminsHighLevel();
 
-    let groupAsOtherAdmin = expectGroup(
+    const groupAsOtherAdmin = expectGroup(
         group.core
             .testWithDifferentAccount(
                 otherAdmin,
@@ -70,7 +73,7 @@ test("Added adming can add a third admin to a group (high level)", () => {
 
     const thirdAdmin = groupAsOtherAdmin.core.node.createAccount("thirdAdmin");
 
-    groupAsOtherAdmin = groupAsOtherAdmin.addMember(thirdAdmin, "admin");
+    groupAsOtherAdmin.addMember(thirdAdmin, "admin");
 
     expect(groupAsOtherAdmin.get(thirdAdmin.id)).toEqual("admin");
 });
@@ -78,16 +81,14 @@ test("Added adming can add a third admin to a group (high level)", () => {
 test("Admins can't demote other admins in a group", () => {
     const { groupCore, admin, otherAdmin } = groupWithTwoAdmins();
 
-    let groupContent = expectGroup(groupCore.getCurrentContent());
+    const groupContent = expectGroup(groupCore.getCurrentContent());
 
-    groupContent = groupContent.edit((editable) => {
-        editable.set(otherAdmin.id, "writer", "trusting");
-        expect(editable.get(otherAdmin.id)).toEqual("admin");
-    });
+    groupContent.set(otherAdmin.id, "writer", "trusting");
+    expect(groupContent.get(otherAdmin.id)).toEqual("admin");
 
     expect(groupContent.get(otherAdmin.id)).toEqual("admin");
 
-    let groupAsOtherAdmin = expectGroup(
+    const groupAsOtherAdmin = expectGroup(
         groupCore
             .testWithDifferentAccount(
                 otherAdmin,
@@ -96,11 +97,7 @@ test("Admins can't demote other admins in a group", () => {
             .getCurrentContent()
     );
 
-    groupAsOtherAdmin = groupAsOtherAdmin.edit((editable) => {
-        editable.set(admin.id, "writer", "trusting");
-        expect(editable.get(admin.id)).toEqual("admin");
-    });
-
+    groupAsOtherAdmin.set(admin.id, "writer", "trusting");
     expect(groupAsOtherAdmin.get(admin.id)).toEqual("admin");
 });
 
@@ -127,17 +124,14 @@ test("Admins an add writers to a group, who can't add admins, writers, or reader
     const { groupCore, node } = newGroup();
     const writer = node.createAccount("writer");
 
-    let groupContent = expectGroup(groupCore.getCurrentContent());
+    const groupContent = expectGroup(groupCore.getCurrentContent());
 
-    groupContent.edit((editable) => {
-        editable.set(writer.id, "writer", "trusting");
-        expect(editable.get(writer.id)).toEqual("writer");
-    });
+    groupContent.set(writer.id, "writer", "trusting");
+    expect(groupContent.get(writer.id)).toEqual("writer");
 
-    groupContent = expectGroup(groupCore.getCurrentContent());
     expect(groupContent.get(writer.id)).toEqual("writer");
 
-    let groupAsWriter = expectGroup(
+    const groupAsWriter = expectGroup(
         groupCore
             .testWithDifferentAccount(writer, newRandomSessionID(writer.id))
             .getCurrentContent()
@@ -147,26 +141,22 @@ test("Admins an add writers to a group, who can't add admins, writers, or reader
 
     const otherAgent = node.createAccount("otherAgent");
 
-    groupAsWriter = groupAsWriter.edit((editable) => {
-        editable.set(otherAgent.id, "admin", "trusting");
-        expect(editable.get(otherAgent.id)).toBeUndefined();
-
-        editable.set(otherAgent.id, "writer", "trusting");
-        expect(editable.get(otherAgent.id)).toBeUndefined();
+    groupAsWriter.set(otherAgent.id, "admin", "trusting");
+    expect(groupAsWriter.get(otherAgent.id)).toBeUndefined();
 
-        editable.set(otherAgent.id, "reader", "trusting");
-        expect(editable.get(otherAgent.id)).toBeUndefined();
-    });
+    groupAsWriter.set(otherAgent.id, "writer", "trusting");
+    expect(groupAsWriter.get(otherAgent.id)).toBeUndefined();
 
+    groupAsWriter.set(otherAgent.id, "reader", "trusting");
     expect(groupAsWriter.get(otherAgent.id)).toBeUndefined();
 });
 
 test("Admins an add writers to a group, who can't add admins, writers, or readers (high level)", () => {
-    let { group, node } = newGroupHighLevel();
+    const { group, node } = newGroupHighLevel();
 
     const writer = node.createAccount("writer");
 
-    group = group.addMember(writer, "writer");
+    group.addMember(writer, "writer");
     expect(group.get(writer.id)).toEqual("writer");
 
     const groupAsWriter = expectGroup(
@@ -196,17 +186,12 @@ test("Admins can add readers to a group, who can't add admins, writers, or reade
     const { groupCore, node } = newGroup();
     const reader = node.createAccount("reader");
 
-    let groupContent = expectGroup(groupCore.getCurrentContent());
-
-    groupContent.edit((editable) => {
-        editable.set(reader.id, "reader", "trusting");
-        expect(editable.get(reader.id)).toEqual("reader");
-    });
+    const groupContent = expectGroup(groupCore.getCurrentContent());
 
-    groupContent = expectGroup(groupCore.getCurrentContent());
+    groupContent.set(reader.id, "reader", "trusting");
     expect(groupContent.get(reader.id)).toEqual("reader");
 
-    let groupAsReader = expectGroup(
+    const groupAsReader = expectGroup(
         groupCore
             .testWithDifferentAccount(reader, newRandomSessionID(reader.id))
             .getCurrentContent()
@@ -216,26 +201,23 @@ test("Admins can add readers to a group, who can't add admins, writers, or reade
 
     const otherAgent = node.createAccount("otherAgent");
 
-    groupAsReader = groupAsReader.edit((editable) => {
-        editable.set(otherAgent.id, "admin", "trusting");
-        expect(editable.get(otherAgent.id)).toBeUndefined();
+    groupAsReader.set(otherAgent.id, "admin", "trusting");
+    expect(groupAsReader.get(otherAgent.id)).toBeUndefined();
 
-        editable.set(otherAgent.id, "writer", "trusting");
-        expect(editable.get(otherAgent.id)).toBeUndefined();
+    groupAsReader.set(otherAgent.id, "writer", "trusting");
+    expect(groupAsReader.get(otherAgent.id)).toBeUndefined();
 
-        editable.set(otherAgent.id, "reader", "trusting");
-        expect(editable.get(otherAgent.id)).toBeUndefined();
-    });
+    groupAsReader.set(otherAgent.id, "reader", "trusting");
 
     expect(groupAsReader.get(otherAgent.id)).toBeUndefined();
 });
 
 test("Admins can add readers to a group, who can't add admins, writers, or readers (high level)", () => {
-    let { group, node } = newGroupHighLevel();
+    const { group, node } = newGroupHighLevel();
 
     const reader = node.createAccount("reader");
 
-    group = group.addMember(reader, "reader");
+    group.addMember(reader, "reader");
     expect(group.get(reader.id)).toEqual("reader");
 
     const groupAsReader = expectGroup(
@@ -273,26 +255,16 @@ test("Admins can write to an object that is owned by their group", () => {
 
     let childContent = expectMap(childObject.getCurrentContent());
 
-    childContent.edit((editable) => {
-        editable.set("foo", "bar", "trusting");
-        expect(editable.get("foo")).toEqual("bar");
-    });
-
-    childContent = expectMap(childObject.getCurrentContent());
-
+    childContent.set("foo", "bar", "trusting");
     expect(childContent.get("foo")).toEqual("bar");
 });
 
 test("Admins can write to an object that is owned by their group (high level)", () => {
     const { node, group } = newGroupHighLevel();
 
-    let childObject = group.createMap();
-
-    childObject = childObject.edit((editable) => {
-        editable.set("foo", "bar", "trusting");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    const childObject = group.createMap();
 
+    childObject.set("foo", "bar", "trusting");
     expect(childObject.get("foo")).toEqual("bar");
 });
 
@@ -301,10 +273,9 @@ test("Writers can write to an object that is owned by their group", () => {
 
     const writer = node.createAccount("writer");
 
-    expectGroup(groupCore.getCurrentContent()).edit((editable) => {
-        editable.set(writer.id, "writer", "trusting");
-        expect(editable.get(writer.id)).toEqual("writer");
-    });
+    const group = expectGroup(groupCore.getCurrentContent());
+    group.set(writer.id, "writer", "trusting");
+    expect(group.get(writer.id)).toEqual("writer");
 
     const childObject = node.createCoValue({
         type: "comap",
@@ -318,17 +289,11 @@ test("Writers can write to an object that is owned by their group", () => {
         newRandomSessionID(writer.id)
     );
 
-    let childContentAsWriter = expectMap(
+    const childContentAsWriter = expectMap(
         childObjectAsWriter.getCurrentContent()
     );
 
-    childContentAsWriter.edit((editable) => {
-        editable.set("foo", "bar", "trusting");
-        expect(editable.get("foo")).toEqual("bar");
-    });
-
-    childContentAsWriter = expectMap(childObjectAsWriter.getCurrentContent());
-
+    childContentAsWriter.set("foo", "bar", "trusting");
     expect(childContentAsWriter.get("foo")).toEqual("bar");
 });
 
@@ -341,17 +306,13 @@ test("Writers can write to an object that is owned by their group (high level)",
 
     const childObject = group.createMap();
 
-    let childObjectAsWriter = expectMap(
+    const childObjectAsWriter = expectMap(
         childObject.core
             .testWithDifferentAccount(writer, newRandomSessionID(writer.id))
             .getCurrentContent()
     );
 
-    childObjectAsWriter = childObjectAsWriter.edit((editable) => {
-        editable.set("foo", "bar", "trusting");
-        expect(editable.get("foo")).toEqual("bar");
-    });
-
+    childObjectAsWriter.set("foo", "bar", "trusting");
     expect(childObjectAsWriter.get("foo")).toEqual("bar");
 });
 
@@ -360,10 +321,9 @@ test("Readers can not write to an object that is owned by their group", () => {
 
     const reader = node.createAccount("reader");
 
-    expectGroup(groupCore.getCurrentContent()).edit((editable) => {
-        editable.set(reader.id, "reader", "trusting");
-        expect(editable.get(reader.id)).toEqual("reader");
-    });
+    const group = expectGroup(groupCore.getCurrentContent());
+    group.set(reader.id, "reader", "trusting");
+    expect(group.get(reader.id)).toEqual("reader");
 
     const childObject = node.createCoValue({
         type: "comap",
@@ -377,17 +337,11 @@ test("Readers can not write to an object that is owned by their group", () => {
         newRandomSessionID(reader.id)
     );
 
-    let childContentAsReader = expectMap(
+    const childContentAsReader = expectMap(
         childObjectAsReader.getCurrentContent()
     );
 
-    childContentAsReader.edit((editable) => {
-        editable.set("foo", "bar", "trusting");
-        expect(editable.get("foo")).toBeUndefined();
-    });
-
-    childContentAsReader = expectMap(childObjectAsReader.getCurrentContent());
-
+    childContentAsReader.set("foo", "bar", "trusting");
     expect(childContentAsReader.get("foo")).toBeUndefined();
 });
 
@@ -400,17 +354,13 @@ test("Readers can not write to an object that is owned by their group (high leve
 
     const childObject = group.createMap();
 
-    let childObjectAsReader = expectMap(
+    const childObjectAsReader = expectMap(
         childObject.core
             .testWithDifferentAccount(reader, newRandomSessionID(reader.id))
             .getCurrentContent()
     );
 
-    childObjectAsReader = childObjectAsReader.edit((editable) => {
-        editable.set("foo", "bar", "trusting");
-        expect(editable.get("foo")).toBeUndefined();
-    });
-
+    childObjectAsReader.set("foo", "bar", "trusting");
     expect(childObjectAsReader.get("foo")).toBeUndefined();
 });
 
@@ -419,30 +369,28 @@ test("Admins can set group read key and then use it to create and read private t
 
     const groupContent = expectGroup(groupCore.getCurrentContent());
 
-    groupContent.edit((editable) => {
-        const { secret: readKey, id: readKeyID } = newRandomKeySecret();
-        const revelation = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
+    const { secret: readKey, id: readKeyID } = newRandomKeySecret();
+    const revelation = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
 
-        editable.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
+    groupContent.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
 
-        expect(editable.get(`${readKeyID}_for_${admin.id}`)).toEqual(
-            revelation
-        );
+    expect(groupContent.get(`${readKeyID}_for_${admin.id}`)).toEqual(
+        revelation
+    );
 
-        editable.set("readKey", readKeyID, "trusting");
+    groupContent.set("readKey", readKeyID, "trusting");
 
-        expect(editable.get("readKey")).toEqual(readKeyID);
+    expect(groupContent.get("readKey")).toEqual(readKeyID);
 
-        expect(groupCore.getCurrentReadKey().secret).toEqual(readKey);
-    });
+    expect(groupCore.getCurrentReadKey().secret).toEqual(readKey);
 
     const childObject = node.createCoValue({
         type: "comap",
@@ -451,27 +399,18 @@ test("Admins can set group read key and then use it to create and read private t
         ...createdNowUnique(),
     });
 
-    let childContent = expectMap(childObject.getCurrentContent());
-
-    childContent.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    const childContent = expectMap(childObject.getCurrentContent());
 
-    childContent = expectMap(childObject.getCurrentContent());
+    childContent.set("foo", "bar", "private");
     expect(childContent.get("foo")).toEqual("bar");
 });
 
 test("Admins can set group read key and then use it to create and read private transactions in owned objects (high level)", () => {
     const { node, group, admin } = newGroupHighLevel();
 
-    let childObject = group.createMap();
-
-    childObject = childObject.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    const childObject = group.createMap();
 
+    childObject.set("foo", "bar", "private");
     expect(childObject.get("foo")).toEqual("bar");
 });
 
@@ -484,37 +423,35 @@ test("Admins can set group read key and then writers can use it to create and re
 
     const groupContent = expectGroup(groupCore.getCurrentContent());
 
-    groupContent.edit((editable) => {
-        editable.set(writer.id, "writer", "trusting");
-        expect(editable.get(writer.id)).toEqual("writer");
-
-        const revelation1 = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${admin.id}`, revelation1, "trusting");
-
-        const revelation2 = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: writer.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${writer.id}`, revelation2, "trusting");
-
-        editable.set("readKey", readKeyID, "trusting");
+    groupContent.set(writer.id, "writer", "trusting");
+    expect(groupContent.get(writer.id)).toEqual("writer");
+
+    const revelation1 = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
+
+    groupContent.set(`${readKeyID}_for_${admin.id}`, revelation1, "trusting");
+
+    const revelation2 = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: writer.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
+    groupContent.set(`${readKeyID}_for_${writer.id}`, revelation2, "trusting");
+
+    groupContent.set("readKey", readKeyID, "trusting");
+
     const childObject = node.createCoValue({
         type: "comap",
         ruleset: { type: "ownedByGroup", group: groupCore.id },
@@ -529,17 +466,11 @@ test("Admins can set group read key and then writers can use it to create and re
 
     expect(childObject.getCurrentReadKey().secret).toEqual(readKey);
 
-    let childContentAsWriter = expectMap(
+    const childContentAsWriter = expectMap(
         childObjectAsWriter.getCurrentContent()
     );
 
-    childContentAsWriter.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
-
-    childContentAsWriter = expectMap(childObjectAsWriter.getCurrentContent());
-
+    childContentAsWriter.set("foo", "bar", "private");
     expect(childContentAsWriter.get("foo")).toEqual("bar");
 });
 
@@ -552,17 +483,13 @@ test("Admins can set group read key and then writers can use it to create and re
 
     const childObject = group.createMap();
 
-    let childObjectAsWriter = expectMap(
+    const childObjectAsWriter = expectMap(
         childObject.core
             .testWithDifferentAccount(writer, newRandomSessionID(writer.id))
             .getCurrentContent()
     );
 
-    childObjectAsWriter = childObjectAsWriter.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
-
+    childObjectAsWriter.set("foo", "bar", "private");
     expect(childObjectAsWriter.get("foo")).toEqual("bar");
 });
 
@@ -575,37 +502,35 @@ test("Admins can set group read key and then use it to create private transactio
 
     const groupContent = expectGroup(groupCore.getCurrentContent());
 
-    groupContent.edit((editable) => {
-        editable.set(reader.id, "reader", "trusting");
-        expect(editable.get(reader.id)).toEqual("reader");
-
-        const revelation1 = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${admin.id}`, revelation1, "trusting");
-
-        const revelation2 = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: reader.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${reader.id}`, revelation2, "trusting");
-
-        editable.set("readKey", readKeyID, "trusting");
+    groupContent.set(reader.id, "reader", "trusting");
+    expect(groupContent.get(reader.id)).toEqual("reader");
+
+    const revelation1 = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
+
+    groupContent.set(`${readKeyID}_for_${admin.id}`, revelation1, "trusting");
+
+    const revelation2 = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: reader.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
+    groupContent.set(`${readKeyID}_for_${reader.id}`, revelation2, "trusting");
+
+    groupContent.set("readKey", readKeyID, "trusting");
+
     const childObject = node.createCoValue({
         type: "comap",
         ruleset: { type: "ownedByGroup", group: groupCore.id },
@@ -613,10 +538,10 @@ test("Admins can set group read key and then use it to create private transactio
         ...createdNowUnique(),
     });
 
-    expectMap(childObject.getCurrentContent()).edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    const childContent = expectMap(childObject.getCurrentContent());
+
+    childContent.set("foo", "bar", "private");
+    expect(childContent.get("foo")).toEqual("bar");
 
     const childObjectAsReader = childObject.testWithDifferentAccount(
         reader,
@@ -639,12 +564,10 @@ test("Admins can set group read key and then use it to create private transactio
 
     group.addMember(reader, "reader");
 
-    let childObject = group.createMap();
+    const childObject = group.createMap();
 
-    childObject = childObject.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    childObject.set("foo", "bar", "private");
+    expect(childObject.get("foo")).toEqual("bar");
 
     const childContentAsReader = expectMap(
         childObject.core
@@ -666,37 +589,35 @@ test("Admins can set group read key and then use it to create private transactio
 
     const groupContent = expectGroup(groupCore.getCurrentContent());
 
-    groupContent.edit((editable) => {
-        editable.set(reader1.id, "reader", "trusting");
-        expect(editable.get(reader1.id)).toEqual("reader");
-
-        const revelation1 = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${admin.id}`, revelation1, "trusting");
-
-        const revelation2 = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: reader1.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${reader1.id}`, revelation2, "trusting");
-
-        editable.set("readKey", readKeyID, "trusting");
+    groupContent.set(reader1.id, "reader", "trusting");
+    expect(groupContent.get(reader1.id)).toEqual("reader");
+
+    const revelation1 = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
+    groupContent.set(`${readKeyID}_for_${admin.id}`, revelation1, "trusting");
+
+    const revelation2 = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: reader1.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
+
+    groupContent.set(`${readKeyID}_for_${reader1.id}`, revelation2, "trusting");
+
+    groupContent.set("readKey", readKeyID, "trusting");
+
     const childObject = node.createCoValue({
         type: "comap",
         ruleset: { type: "ownedByGroup", group: groupCore.id },
@@ -704,10 +625,10 @@ test("Admins can set group read key and then use it to create private transactio
         ...createdNowUnique(),
     });
 
-    expectMap(childObject.getCurrentContent()).edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    const childContent = expectMap(childObject.getCurrentContent());
+
+    childContent.set("foo", "bar", "private");
+    expect(childContent.get("foo")).toEqual("bar");
 
     const childObjectAsReader1 = childObject.testWithDifferentAccount(
         reader1,
@@ -722,20 +643,18 @@ test("Admins can set group read key and then use it to create private transactio
 
     expect(childContentAsReader1.get("foo")).toEqual("bar");
 
-    groupContent.edit((editable) => {
-        const revelation3 = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: reader2.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${reader2.id}`, revelation3, "trusting");
+    const revelation3 = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: reader2.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
+    groupContent.set(`${readKeyID}_for_${reader2.id}`, revelation3, "trusting");
+
     const childObjectAsReader2 = childObject.testWithDifferentAccount(
         reader2,
         newRandomSessionID(reader2.id)
@@ -759,12 +678,10 @@ test("Admins can set group read key and then use it to create private transactio
 
     group.addMember(reader1, "reader");
 
-    let childObject = group.createMap();
+    const childObject = group.createMap();
 
-    childObject = childObject.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    childObject.set("foo", "bar", "private");
+    expect(childObject.get("foo")).toEqual("bar");
 
     const childContentAsReader1 = expectMap(
         childObject.core
@@ -790,25 +707,23 @@ test("Admins can set group read key, make a private transaction in an owned obje
 
     const groupContent = expectGroup(groupCore.getCurrentContent());
 
-    groupContent.edit((editable) => {
-        const { secret: readKey, id: readKeyID } = newRandomKeySecret();
-        const revelation = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
-
-        editable.set("readKey", readKeyID, "trusting");
-        expect(editable.get("readKey")).toEqual(readKeyID);
-        expect(groupCore.getCurrentReadKey().secret).toEqual(readKey);
+    const { secret: readKey, id: readKeyID } = newRandomKeySecret();
+    const revelation1 = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
+    groupContent.set(`${readKeyID}_for_${admin.id}`, revelation1, "trusting");
+
+    groupContent.set("readKey", readKeyID, "trusting");
+    expect(groupContent.get("readKey")).toEqual(readKeyID);
+    expect(groupCore.getCurrentReadKey().secret).toEqual(readKey);
+
     const childObject = node.createCoValue({
         type: "comap",
         ruleset: { type: "ownedByGroup", group: groupCore.id },
@@ -816,72 +731,50 @@ test("Admins can set group read key, make a private transaction in an owned obje
         ...createdNowUnique(),
     });
 
-    let childContent = expectMap(childObject.getCurrentContent());
-
-    childContent.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    const childContent = expectMap(childObject.getCurrentContent());
 
-    childContent = expectMap(childObject.getCurrentContent());
+    childContent.set("foo", "bar", "private");
     expect(childContent.get("foo")).toEqual("bar");
 
-    groupContent.edit((editable) => {
-        const { secret: readKey2, id: readKeyID2 } = newRandomKeySecret();
+    const { secret: readKey2, id: readKeyID2 } = newRandomKeySecret();
 
-        const revelation = seal({
-            message: readKey2,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
+    const revelation2 = seal({
+        message: readKey2,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
 
-        editable.set(`${readKeyID2}_for_${admin.id}`, revelation, "trusting");
+    groupContent.set(`${readKeyID2}_for_${admin.id}`, revelation2, "trusting");
 
-        editable.set("readKey", readKeyID2, "trusting");
-        expect(editable.get("readKey")).toEqual(readKeyID2);
-        expect(groupCore.getCurrentReadKey().secret).toEqual(readKey2);
-    });
+    groupContent.set("readKey", readKeyID2, "trusting");
+    expect(groupContent.get("readKey")).toEqual(readKeyID2);
+    expect(groupCore.getCurrentReadKey().secret).toEqual(readKey2);
 
-    childContent = expectMap(childObject.getCurrentContent());
     expect(childContent.get("foo")).toEqual("bar");
 
-    childContent.edit((editable) => {
-        editable.set("foo2", "bar2", "private");
-        expect(editable.get("foo2")).toEqual("bar2");
-    });
-    childContent = expectMap(childObject.getCurrentContent());
-    expect(childContent.get("foo")).toEqual("bar");
+    childContent.set("foo2", "bar2", "private");
     expect(childContent.get("foo2")).toEqual("bar2");
 });
 
 test("Admins can set group read key, make a private transaction in an owned object, rotate the read key, make another private transaction, and both can be read by the admin (high level)", () => {
     const { group } = newGroupHighLevel();
 
-    let childObject = group.createMap();
+    const childObject = group.createMap();
 
     const firstReadKey = childObject.core.getCurrentReadKey();
 
-    childObject = childObject.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
-
+    childObject.set("foo", "bar", "private");
     expect(childObject.get("foo")).toEqual("bar");
 
     group.rotateReadKey();
 
     expect(childObject.core.getCurrentReadKey()).not.toEqual(firstReadKey);
 
-    childObject = childObject.edit((editable) => {
-        editable.set("foo2", "bar2", "private");
-        expect(editable.get("foo2")).toEqual("bar2");
-    });
-
-    expect(childObject.get("foo")).toEqual("bar");
+    childObject.set("foo2", "bar2", "private");
     expect(childObject.get("foo2")).toEqual("bar2");
 });
 
@@ -898,85 +791,76 @@ test("Admins can set group read key, make a private transaction in an owned obje
     const groupContent = expectGroup(groupCore.getCurrentContent());
     const { secret: readKey, id: readKeyID } = newRandomKeySecret();
 
-    groupContent.edit((editable) => {
-        const revelation = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
-
-        editable.set("readKey", readKeyID, "trusting");
-        expect(editable.get("readKey")).toEqual(readKeyID);
-        expect(groupCore.getCurrentReadKey().secret).toEqual(readKey);
+    const revelation = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
-    let childContent = expectMap(childObject.getCurrentContent());
+    groupContent.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
 
-    childContent.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    groupContent.set("readKey", readKeyID, "trusting");
+    expect(groupContent.get("readKey")).toEqual(readKeyID);
+    expect(groupCore.getCurrentReadKey().secret).toEqual(readKey);
+
+    const childContent = expectMap(childObject.getCurrentContent());
+
+    childContent.set("foo", "bar", "private");
+    expect(childContent.get("foo")).toEqual("bar");
 
-    childContent = expectMap(childObject.getCurrentContent());
     expect(childContent.get("foo")).toEqual("bar");
 
     const reader = node.createAccount("reader");
 
     const { secret: readKey2, id: readKeyID2 } = newRandomKeySecret();
 
-    groupContent.edit((editable) => {
-        const revelation2 = seal({
-            message: readKey2,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID2}_for_${admin.id}`, revelation2, "trusting");
-
-        const revelation3 = seal({
-            message: readKey2,
-            from: admin.currentSealerSecret(),
-            to: reader.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID2}_for_${reader.id}`, revelation3, "trusting");
-
-        editable.set(
-            `${readKeyID}_for_${readKeyID2}`,
-            encryptKeySecret({
-                toEncrypt: { id: readKeyID, secret: readKey },
-                encrypting: { id: readKeyID2, secret: readKey2 },
-            }).encrypted,
-            "trusting"
-        );
-
-        editable.set("readKey", readKeyID2, "trusting");
-
-        expect(editable.get("readKey")).toEqual(readKeyID2);
-        expect(groupCore.getCurrentReadKey().secret).toEqual(readKey2);
-
-        editable.set(reader.id, "reader", "trusting");
-        expect(editable.get(reader.id)).toEqual("reader");
-    });
+    const revelation2 = seal({
+        message: readKey2,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
+
+    groupContent.set(`${readKeyID2}_for_${admin.id}`, revelation2, "trusting");
+
+    const revelation3 = seal({
+        message: readKey2,
+        from: admin.currentSealerSecret(),
+        to: reader.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
+
+    groupContent.set(`${readKeyID2}_for_${reader.id}`, revelation3, "trusting");
+
+    groupContent.set(
+        `${readKeyID}_for_${readKeyID2}`,
+        encryptKeySecret({
+            toEncrypt: { id: readKeyID, secret: readKey },
+            encrypting: { id: readKeyID2, secret: readKey2 },
+        }).encrypted,
+        "trusting"
+    );
 
-    childContent.edit((editable) => {
-        editable.set("foo2", "bar2", "private");
-        expect(editable.get("foo2")).toEqual("bar2");
-    });
+    groupContent.set("readKey", readKeyID2, "trusting");
+
+    expect(groupContent.get("readKey")).toEqual(readKeyID2);
+    expect(groupCore.getCurrentReadKey().secret).toEqual(readKey2);
+
+    groupContent.set(reader.id, "reader", "trusting");
+    expect(groupContent.get(reader.id)).toEqual("reader");
+
+    childContent.set("foo2", "bar2", "private");
+    expect(childContent.get("foo2")).toEqual("bar2");
 
     const childObjectAsReader = childObject.testWithDifferentAccount(
         reader,
@@ -996,14 +880,12 @@ test("Admins can set group read key, make a private transaction in an owned obje
 test("Admins can set group read key, make a private transaction in an owned object, rotate the read key, add a reader, make another private transaction in the owned object, and both can be read by the reader (high level)", () => {
     const { node, group } = newGroupHighLevel();
 
-    let childObject = group.createMap();
+    const childObject = group.createMap();
 
     const firstReadKey = childObject.core.getCurrentReadKey();
 
-    childObject = childObject.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    childObject.set("foo", "bar", "private");
+    expect(childObject.get("foo")).toEqual("bar");
 
     expect(childObject.get("foo")).toEqual("bar");
 
@@ -1015,10 +897,8 @@ test("Admins can set group read key, make a private transaction in an owned obje
 
     group.addMember(reader, "reader");
 
-    childObject = childObject.edit((editable) => {
-        editable.set("foo2", "bar2", "private");
-        expect(editable.get("foo2")).toEqual("bar2");
-    });
+    childObject.set("foo2", "bar2", "private");
+    expect(childObject.get("foo2")).toEqual("bar2");
 
     const childContentAsReader = expectMap(
         childObject.core
@@ -1046,61 +926,54 @@ test("Admins can set group read rey, make a private transaction in an owned obje
 
     const reader2 = node.createAccount("reader2");
 
-    groupContent.edit((editable) => {
-        const revelation1 = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${admin.id}`, revelation1, "trusting");
-
-        const revelation2 = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: reader.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${reader.id}`, revelation2, "trusting");
-
-        const revelation3 = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: reader2.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${reader2.id}`, revelation3, "trusting");
-
-        editable.set("readKey", readKeyID, "trusting");
-        expect(editable.get("readKey")).toEqual(readKeyID);
-        expect(groupCore.getCurrentReadKey().secret).toEqual(readKey);
-
-        editable.set(reader.id, "reader", "trusting");
-        expect(editable.get(reader.id)).toEqual("reader");
-        editable.set(reader2.id, "reader", "trusting");
-        expect(editable.get(reader2.id)).toEqual("reader");
+    const revelation1 = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
-    let childContent = expectMap(childObject.getCurrentContent());
+    groupContent.set(`${readKeyID}_for_${admin.id}`, revelation1, "trusting");
 
-    childContent.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
+    const revelation2 = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: reader.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
-    childContent = expectMap(childObject.getCurrentContent());
+    groupContent.set(`${readKeyID}_for_${reader.id}`, revelation2, "trusting");
+
+    const revelation3 = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: reader2.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
+
+    groupContent.set(`${readKeyID}_for_${reader2.id}`, revelation3, "trusting");
+
+    groupContent.set("readKey", readKeyID, "trusting");
+    expect(groupContent.get("readKey")).toEqual(readKeyID);
+    expect(groupCore.getCurrentReadKey().secret).toEqual(readKey);
+
+    groupContent.set(reader.id, "reader", "trusting");
+    expect(groupContent.get(reader.id)).toEqual("reader");
+    groupContent.set(reader2.id, "reader", "trusting");
+    expect(groupContent.get(reader2.id)).toEqual("reader");
+
+    const childContent = expectMap(childObject.getCurrentContent());
+
+    childContent.set("foo", "bar", "private");
     expect(childContent.get("foo")).toEqual("bar");
 
     let childObjectAsReader = childObject.testWithDifferentAccount(
@@ -1123,55 +996,50 @@ test("Admins can set group read rey, make a private transaction in an owned obje
 
     const { secret: readKey2, id: readKeyID2 } = newRandomKeySecret();
 
-    groupContent.edit((editable) => {
-        const newRevelation1 = seal({
-            message: readKey2,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(
-            `${readKeyID2}_for_${admin.id}`,
-            newRevelation1,
-            "trusting"
-        );
-
-        const newRevelation2 = seal({
-            message: readKey2,
-            from: admin.currentSealerSecret(),
-            to: reader2.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(
-            `${readKeyID2}_for_${reader2.id}`,
-            newRevelation2,
-            "trusting"
-        );
-
-        editable.set("readKey", readKeyID2, "trusting");
-        expect(editable.get("readKey")).toEqual(readKeyID2);
-        expect(groupCore.getCurrentReadKey().secret).toEqual(readKey2);
-
-        editable.set(reader.id, "revoked", "trusting");
-        // expect(editable.get(reader.id)).toEqual("revoked");
+    const newRevelation1 = seal({
+        message: readKey2,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
-    expect(childObject.getCurrentReadKey().secret).toEqual(readKey2);
+    groupContent.set(
+        `${readKeyID2}_for_${admin.id}`,
+        newRevelation1,
+        "trusting"
+    );
 
-    childContent = expectMap(childObject.getCurrentContent());
-    childContent.edit((editable) => {
-        editable.set("foo2", "bar2", "private");
-        expect(editable.get("foo2")).toEqual("bar2");
+    const newRevelation2 = seal({
+        message: readKey2,
+        from: admin.currentSealerSecret(),
+        to: reader2.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
+    groupContent.set(
+        `${readKeyID2}_for_${reader2.id}`,
+        newRevelation2,
+        "trusting"
+    );
+
+    groupContent.set("readKey", readKeyID2, "trusting");
+    expect(groupContent.get("readKey")).toEqual(readKeyID2);
+    expect(groupCore.getCurrentReadKey().secret).toEqual(readKey2);
+
+    groupContent.set(reader.id, "revoked", "trusting");
+    // expect(editable.get(reader.id)).toEqual("revoked");
+
+    expect(childObject.getCurrentReadKey().secret).toEqual(readKey2);
+
+    childContent.set("foo2", "bar2", "private");
+    expect(childContent.get("foo2")).toEqual("bar2");
+
     // TODO: make sure these instances of coValues sync between each other so this isn't necessary?
     childObjectAsReader = childObject.testWithDifferentAccount(
         reader,
@@ -1193,12 +1061,10 @@ test("Admins can set group read rey, make a private transaction in an owned obje
 test("Admins can set group read rey, make a private transaction in an owned object, rotate the read key, add two readers, rotate the read key again to kick out one reader, make another private transaction in the owned object, and only the remaining reader can read both transactions (high level)", () => {
     const { node, group } = newGroupHighLevel();
 
-    let childObject = group.createMap();
+    const childObject = group.createMap();
 
-    childObject = childObject.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    childObject.set("foo", "bar", "private");
+    expect(childObject.get("foo")).toEqual("bar");
 
     expect(childObject.get("foo")).toEqual("bar");
 
@@ -1213,22 +1079,15 @@ test("Admins can set group read rey, make a private transaction in an owned obje
     group.addMember(reader, "reader");
     group.addMember(reader2, "reader");
 
-    childObject = childObject.edit((editable) => {
-        editable.set("foo2", "bar2", "private");
-        expect(editable.get("foo2")).toEqual("bar2");
-    });
-
-    expect(childObject.get("foo")).toEqual("bar");
+    childObject.set("foo2", "bar2", "private");
     expect(childObject.get("foo2")).toEqual("bar2");
 
-    group.removeMember(reader.id);
+    group.removeMember(reader);
 
     expect(childObject.core.getCurrentReadKey()).not.toEqual(secondReadKey);
 
-    childObject = childObject.edit((editable) => {
-        editable.set("foo3", "bar3", "private");
-        expect(editable.get("foo3")).toEqual("bar3");
-    });
+    childObject.set("foo3", "bar3", "private");
+    expect(childObject.get("foo3")).toEqual("bar3");
 
     const childContentAsReader2 = expectMap(
         childObject.core
@@ -1275,42 +1134,38 @@ test("Admins can create an adminInvite, which can add an admin", () => {
     const inviteSecret = newRandomAgentSecret();
     const inviteID = getAgentID(inviteSecret);
 
-    expectGroup(groupCore.getCurrentContent()).edit((editable) => {
-        const { secret: readKey, id: readKeyID } = newRandomKeySecret();
-        const revelation = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
-        editable.set("readKey", readKeyID, "trusting");
-
-        editable.set(inviteID, "adminInvite", "trusting");
-
-        expect(editable.get(inviteID)).toEqual("adminInvite");
-
-        const revelationForInvite = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: getAgentSealerID(inviteID),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(
-            `${readKeyID}_for_${inviteID}`,
-            revelationForInvite,
-            "trusting"
-        );
+    const group = expectGroup(groupCore.getCurrentContent());
+
+    const { secret: readKey, id: readKeyID } = newRandomKeySecret();
+    const revelation = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
+
+    group.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
+    group.set("readKey", readKeyID, "trusting");
+
+    group.set(inviteID, "adminInvite", "trusting");
+
+    expect(group.get(inviteID)).toEqual("adminInvite");
+
+    const revelationForInvite = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: getAgentSealerID(inviteID),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
+    group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
+
     const groupAsInvite = expectGroup(
         groupCore
             .testWithDifferentAccount(
@@ -1323,35 +1178,33 @@ test("Admins can create an adminInvite, which can add an admin", () => {
     const invitedAdminSecret = newRandomAgentSecret();
     const invitedAdminID = getAgentID(invitedAdminSecret);
 
-    groupAsInvite.edit((editable) => {
-        editable.set(invitedAdminID, "admin", "trusting");
+    groupAsInvite.set(invitedAdminID, "admin", "trusting");
 
-        expect(editable.get(invitedAdminID)).toEqual("admin");
+    expect(groupAsInvite.get(invitedAdminID)).toEqual("admin");
 
-        const readKey = groupAsInvite.core.getCurrentReadKey();
+    const readKeyAsInvite = groupAsInvite.core.getCurrentReadKey();
 
-        expect(readKey.secret).toBeDefined();
+    expect(readKeyAsInvite.secret).toBeDefined();
 
-        const revelation = seal({
-            message: readKey.secret!,
-            from: getAgentSealerSecret(invitedAdminSecret),
-            to: getAgentSealerID(invitedAdminID),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
+    const revelation2 = seal({
+        message: readKeyAsInvite.secret!,
+        from: getAgentSealerSecret(invitedAdminSecret),
+        to: getAgentSealerID(invitedAdminID),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
 
-        editable.set(
-            `${readKey.id}_for_${invitedAdminID}`,
-            revelation,
-            "trusting"
-        );
+    groupAsInvite.set(
+        `${readKeyAsInvite.id}_for_${invitedAdminID}`,
+        revelation2,
+        "trusting"
+    );
 
-        expect(editable.get(`${readKey.id}_for_${invitedAdminID}`)).toEqual(
-            revelation
-        );
-    });
+    expect(
+        groupAsInvite.get(`${readKeyAsInvite.id}_for_${invitedAdminID}`)
+    ).toEqual(revelation2);
 });
 
 test("Admins can create an adminInvite, which can add an admin (high-level)", async () => {
@@ -1380,10 +1233,7 @@ test("Admins can create an adminInvite, which can add an admin (high-level)", as
     expect(groupAsInvitedAdmin.get(invitedAdminID)).toEqual("admin");
     expect(groupAsInvitedAdmin.core.getCurrentReadKey().secret).toBeDefined();
 
-    groupAsInvitedAdmin = groupAsInvitedAdmin.addMemberInternal(
-        thirdAdminID,
-        "admin"
-    );
+    groupAsInvitedAdmin.addMemberInternal(thirdAdminID, "admin");
 
     expect(groupAsInvitedAdmin.get(thirdAdminID)).toEqual("admin");
 });
@@ -1394,42 +1244,38 @@ test("Admins can create a writerInvite, which can add a writer", () => {
     const inviteSecret = newRandomAgentSecret();
     const inviteID = getAgentID(inviteSecret);
 
-    expectGroup(groupCore.getCurrentContent()).edit((editable) => {
-        const { secret: readKey, id: readKeyID } = newRandomKeySecret();
-        const revelation = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
-        editable.set("readKey", readKeyID, "trusting");
-
-        editable.set(inviteID, "writerInvite", "trusting");
-
-        expect(editable.get(inviteID)).toEqual("writerInvite");
-
-        const revelationForInvite = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: getAgentSealerID(inviteID),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(
-            `${readKeyID}_for_${inviteID}`,
-            revelationForInvite,
-            "trusting"
-        );
+    const group = expectGroup(groupCore.getCurrentContent());
+
+    const { secret: readKey, id: readKeyID } = newRandomKeySecret();
+    const revelation = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
+
+    group.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
+    group.set("readKey", readKeyID, "trusting");
+
+    group.set(inviteID, "writerInvite", "trusting");
+
+    expect(group.get(inviteID)).toEqual("writerInvite");
+
+    const revelationForInvite = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: getAgentSealerID(inviteID),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
+    group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
+
     const groupAsInvite = expectGroup(
         groupCore
             .testWithDifferentAccount(
@@ -1442,35 +1288,33 @@ test("Admins can create a writerInvite, which can add a writer", () => {
     const invitedWriterSecret = newRandomAgentSecret();
     const invitedWriterID = getAgentID(invitedWriterSecret);
 
-    groupAsInvite.edit((editable) => {
-        editable.set(invitedWriterID, "writer", "trusting");
+    groupAsInvite.set(invitedWriterID, "writer", "trusting");
 
-        expect(editable.get(invitedWriterID)).toEqual("writer");
+    expect(groupAsInvite.get(invitedWriterID)).toEqual("writer");
 
-        const readKey = groupAsInvite.core.getCurrentReadKey();
+    const readKeyAsInvite = groupAsInvite.core.getCurrentReadKey();
 
-        expect(readKey.secret).toBeDefined();
+    expect(readKeyAsInvite.secret).toBeDefined();
 
-        const revelation = seal({
-            message: readKey.secret!,
-            from: getAgentSealerSecret(invitedWriterSecret),
-            to: getAgentSealerID(invitedWriterID),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
+    const revelation2 = seal({
+        message: readKeyAsInvite.secret!,
+        from: getAgentSealerSecret(invitedWriterSecret),
+        to: getAgentSealerID(invitedWriterID),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
 
-        editable.set(
-            `${readKey.id}_for_${invitedWriterID}`,
-            revelation,
-            "trusting"
-        );
+    groupAsInvite.set(
+        `${readKeyAsInvite.id}_for_${invitedWriterID}`,
+        revelation2,
+        "trusting"
+    );
 
-        expect(editable.get(`${readKey.id}_for_${invitedWriterID}`)).toEqual(
-            revelation
-        );
-    });
+    expect(
+        groupAsInvite.get(`${readKeyAsInvite.id}_for_${invitedWriterID}`)
+    ).toEqual(revelation2);
 });
 
 test("Admins can create a writerInvite, which can add a writer (high-level)", async () => {
@@ -1503,42 +1347,38 @@ test("Admins can create a readerInvite, which can add a reader", () => {
     const inviteSecret = newRandomAgentSecret();
     const inviteID = getAgentID(inviteSecret);
 
-    expectGroup(groupCore.getCurrentContent()).edit((editable) => {
-        const { secret: readKey, id: readKeyID } = newRandomKeySecret();
-        const revelation = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
-        editable.set("readKey", readKeyID, "trusting");
-
-        editable.set(inviteID, "readerInvite", "trusting");
-
-        expect(editable.get(inviteID)).toEqual("readerInvite");
-
-        const revelationForInvite = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: getAgentSealerID(inviteID),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(
-            `${readKeyID}_for_${inviteID}`,
-            revelationForInvite,
-            "trusting"
-        );
+    const group = expectGroup(groupCore.getCurrentContent());
+
+    const { secret: readKey, id: readKeyID } = newRandomKeySecret();
+    const revelation = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
+
+    group.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
+    group.set("readKey", readKeyID, "trusting");
+
+    group.set(inviteID, "readerInvite", "trusting");
+
+    expect(group.get(inviteID)).toEqual("readerInvite");
+
+    const revelationForInvite = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: getAgentSealerID(inviteID),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
+    group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
+
     const groupAsInvite = expectGroup(
         groupCore
             .testWithDifferentAccount(
@@ -1551,35 +1391,33 @@ test("Admins can create a readerInvite, which can add a reader", () => {
     const invitedReaderSecret = newRandomAgentSecret();
     const invitedReaderID = getAgentID(invitedReaderSecret);
 
-    groupAsInvite.edit((editable) => {
-        editable.set(invitedReaderID, "reader", "trusting");
+    groupAsInvite.set(invitedReaderID, "reader", "trusting");
 
-        expect(editable.get(invitedReaderID)).toEqual("reader");
+    expect(groupAsInvite.get(invitedReaderID)).toEqual("reader");
 
-        const readKey = groupAsInvite.core.getCurrentReadKey();
+    const readKeyAsInvite = groupAsInvite.core.getCurrentReadKey();
 
-        expect(readKey.secret).toBeDefined();
+    expect(readKeyAsInvite.secret).toBeDefined();
 
-        const revelation = seal({
-            message: readKey.secret!,
-            from: getAgentSealerSecret(invitedReaderSecret),
-            to: getAgentSealerID(invitedReaderID),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
+    const revelation2 = seal({
+        message: readKeyAsInvite.secret!,
+        from: getAgentSealerSecret(invitedReaderSecret),
+        to: getAgentSealerID(invitedReaderID),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
 
-        editable.set(
-            `${readKey.id}_for_${invitedReaderID}`,
-            revelation,
-            "trusting"
-        );
+    groupAsInvite.set(
+        `${readKeyAsInvite.id}_for_${invitedReaderID}`,
+        revelation,
+        "trusting"
+    );
 
-        expect(editable.get(`${readKey.id}_for_${invitedReaderID}`)).toEqual(
-            revelation
-        );
-    });
+    expect(
+        groupAsInvite.get(`${readKeyAsInvite.id}_for_${invitedReaderID}`)
+    ).toEqual(revelation);
 });
 
 test("Admins can create a readerInvite, which can add a reader (high-level)", async () => {
@@ -1612,42 +1450,38 @@ test("WriterInvites can not invite admins", () => {
     const inviteSecret = newRandomAgentSecret();
     const inviteID = getAgentID(inviteSecret);
 
-    expectGroup(groupCore.getCurrentContent()).edit((editable) => {
-        const { secret: readKey, id: readKeyID } = newRandomKeySecret();
-        const revelation = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
-        editable.set("readKey", readKeyID, "trusting");
-
-        editable.set(inviteID, "writerInvite", "trusting");
-
-        expect(editable.get(inviteID)).toEqual("writerInvite");
-
-        const revelationForInvite = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: getAgentSealerID(inviteID),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(
-            `${readKeyID}_for_${inviteID}`,
-            revelationForInvite,
-            "trusting"
-        );
+    const group = expectGroup(groupCore.getCurrentContent());
+
+    const { secret: readKey, id: readKeyID } = newRandomKeySecret();
+    const revelation = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
+    group.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
+    group.set("readKey", readKeyID, "trusting");
+
+    group.set(inviteID, "writerInvite", "trusting");
+
+    expect(group.get(inviteID)).toEqual("writerInvite");
+
+    const revelationForInvite = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: getAgentSealerID(inviteID),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
+
+    group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
+
     const groupAsInvite = expectGroup(
         groupCore
             .testWithDifferentAccount(
@@ -1660,10 +1494,8 @@ test("WriterInvites can not invite admins", () => {
     const invitedAdminSecret = newRandomAgentSecret();
     const invitedAdminID = getAgentID(invitedAdminSecret);
 
-    groupAsInvite.edit((editable) => {
-        editable.set(invitedAdminID, "admin", "trusting");
-        expect(editable.get(invitedAdminID)).toBeUndefined();
-    });
+    groupAsInvite.set(invitedAdminID, "admin", "trusting");
+    expect(groupAsInvite.get(invitedAdminID)).toBeUndefined();
 });
 
 test("ReaderInvites can not invite admins", () => {
@@ -1672,42 +1504,38 @@ test("ReaderInvites can not invite admins", () => {
     const inviteSecret = newRandomAgentSecret();
     const inviteID = getAgentID(inviteSecret);
 
-    expectGroup(groupCore.getCurrentContent()).edit((editable) => {
-        const { secret: readKey, id: readKeyID } = newRandomKeySecret();
-        const revelation = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
-        editable.set("readKey", readKeyID, "trusting");
-
-        editable.set(inviteID, "readerInvite", "trusting");
-
-        expect(editable.get(inviteID)).toEqual("readerInvite");
-
-        const revelationForInvite = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: getAgentSealerID(inviteID),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(
-            `${readKeyID}_for_${inviteID}`,
-            revelationForInvite,
-            "trusting"
-        );
+    const group = expectGroup(groupCore.getCurrentContent());
+
+    const { secret: readKey, id: readKeyID } = newRandomKeySecret();
+    const revelation = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
+    group.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
+    group.set("readKey", readKeyID, "trusting");
+
+    group.set(inviteID, "readerInvite", "trusting");
+
+    expect(group.get(inviteID)).toEqual("readerInvite");
+
+    const revelationForInvite = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: getAgentSealerID(inviteID),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
+
+    group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
+
     const groupAsInvite = expectGroup(
         groupCore
             .testWithDifferentAccount(
@@ -1720,10 +1548,8 @@ test("ReaderInvites can not invite admins", () => {
     const invitedAdminSecret = newRandomAgentSecret();
     const invitedAdminID = getAgentID(invitedAdminSecret);
 
-    groupAsInvite.edit((editable) => {
-        editable.set(invitedAdminID, "admin", "trusting");
-        expect(editable.get(invitedAdminID)).toBeUndefined();
-    });
+    groupAsInvite.set(invitedAdminID, "admin", "trusting");
+    expect(groupAsInvite.get(invitedAdminID)).toBeUndefined();
 });
 
 test("ReaderInvites can not invite writers", () => {
@@ -1732,42 +1558,38 @@ test("ReaderInvites can not invite writers", () => {
     const inviteSecret = newRandomAgentSecret();
     const inviteID = getAgentID(inviteSecret);
 
-    expectGroup(groupCore.getCurrentContent()).edit((editable) => {
-        const { secret: readKey, id: readKeyID } = newRandomKeySecret();
-        const revelation = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: admin.currentSealerID(),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
-        editable.set("readKey", readKeyID, "trusting");
-
-        editable.set(inviteID, "readerInvite", "trusting");
-
-        expect(editable.get(inviteID)).toEqual("readerInvite");
-
-        const revelationForInvite = seal({
-            message: readKey,
-            from: admin.currentSealerSecret(),
-            to: getAgentSealerID(inviteID),
-            nOnceMaterial: {
-                in: groupCore.id,
-                tx: groupCore.nextTransactionID(),
-            },
-        });
-
-        editable.set(
-            `${readKeyID}_for_${inviteID}`,
-            revelationForInvite,
-            "trusting"
-        );
+    const group = expectGroup(groupCore.getCurrentContent());
+
+    const { secret: readKey, id: readKeyID } = newRandomKeySecret();
+    const revelation = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: admin.currentSealerID(),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
     });
 
+    group.set(`${readKeyID}_for_${admin.id}`, revelation, "trusting");
+    group.set("readKey", readKeyID, "trusting");
+
+    group.set(inviteID, "readerInvite", "trusting");
+
+    expect(group.get(inviteID)).toEqual("readerInvite");
+
+    const revelationForInvite = seal({
+        message: readKey,
+        from: admin.currentSealerSecret(),
+        to: getAgentSealerID(inviteID),
+        nOnceMaterial: {
+            in: groupCore.id,
+            tx: groupCore.nextTransactionID(),
+        },
+    });
+
+    group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
+
     const groupAsInvite = expectGroup(
         groupCore
             .testWithDifferentAccount(
@@ -1780,10 +1602,8 @@ test("ReaderInvites can not invite writers", () => {
     const invitedWriterSecret = newRandomAgentSecret();
     const invitedWriterID = getAgentID(invitedWriterSecret);
 
-    groupAsInvite.edit((editable) => {
-        editable.set(invitedWriterID, "writer", "trusting");
-        expect(editable.get(invitedWriterID)).toBeUndefined();
-    });
+    groupAsInvite.set(invitedWriterID, "writer", "trusting");
+    expect(groupAsInvite.get(invitedWriterID)).toBeUndefined();
 });
 
 test("Can give read permission to 'everyone'", () => {
@@ -1796,21 +1616,19 @@ test("Can give read permission to 'everyone'", () => {
         ...createdNowUnique(),
     });
 
-    expectGroup(groupCore.getCurrentContent()).edit((editable) => {
-        const { secret: readKey, id: readKeyID } = newRandomKeySecret();
-        editable.set("everyone", "reader", "trusting");
-        editable.set("readKey", readKeyID, "trusting");
-        editable.set(`${readKeyID}_for_everyone`, readKey, "trusting");
-    });
+    const group = expectGroup(groupCore.getCurrentContent());
+
+    const { secret: readKey, id: readKeyID } = newRandomKeySecret();
+    group.set("everyone", "reader", "trusting");
+    group.set("readKey", readKeyID, "trusting");
+    group.set(`${readKeyID}_for_everyone`, readKey, "trusting");
 
     const childContent = expectMap(childObject.getCurrentContent());
 
     expect(childContent.get("foo")).toBeUndefined();
 
-    childContent.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    childContent.set("foo", "bar", "private");
+    expect(childContent.get("foo")).toEqual("bar");
 
     const newAccount = new ControlledAgent(newRandomAgentSecret());
 
@@ -1835,10 +1653,8 @@ test("Can give read permissions to 'everyone' (high-level)", async () => {
 
     group.addMember("everyone", "reader");
 
-    childObject.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    childObject.set("foo", "bar", "private");
+    expect(childObject.get("foo")).toEqual("bar");
 
     const newAccount = new ControlledAgent(newRandomAgentSecret());
 
@@ -1864,21 +1680,19 @@ test("Can give write permission to 'everyone'", () => {
         ...createdNowUnique(),
     });
 
-    expectGroup(groupCore.getCurrentContent()).edit((editable) => {
-        const { secret: readKey, id: readKeyID } = newRandomKeySecret();
-        editable.set("everyone", "writer", "trusting");
-        editable.set("readKey", readKeyID, "trusting");
-        editable.set(`${readKeyID}_for_everyone`, readKey, "trusting");
-    });
+    const group = expectGroup(groupCore.getCurrentContent());
+
+    const { secret: readKey, id: readKeyID } = newRandomKeySecret();
+    group.set("everyone", "writer", "trusting");
+    group.set("readKey", readKeyID, "trusting");
+    group.set(`${readKeyID}_for_everyone`, readKey, "trusting");
 
     const childContent = expectMap(childObject.getCurrentContent());
 
     expect(childContent.get("foo")).toBeUndefined();
 
-    childContent.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    childContent.set("foo", "bar", "private");
+    expect(childContent.get("foo")).toEqual("bar");
 
     const newAccount = new ControlledAgent(newRandomAgentSecret());
 
@@ -1893,10 +1707,8 @@ test("Can give write permission to 'everyone'", () => {
 
     expect(childContent2.get("foo")).toEqual("bar");
 
-    childContent2.edit((editable) => {
-        editable.set("foo", "bar2", "private");
-        expect(editable.get("foo")).toEqual("bar2");
-    });
+    childContent2.set("foo", "bar2", "private");
+    expect(childContent2.get("foo")).toEqual("bar2");
 });
 
 test("Can give write permissions to 'everyone' (high-level)", async () => {
@@ -1908,10 +1720,8 @@ test("Can give write permissions to 'everyone' (high-level)", async () => {
 
     group.addMember("everyone", "writer");
 
-    childObject.edit((editable) => {
-        editable.set("foo", "bar", "private");
-        expect(editable.get("foo")).toEqual("bar");
-    });
+    childObject.set("foo", "bar", "private");
+    expect(childObject.get("foo")).toEqual("bar");
 
     const newAccount = new ControlledAgent(newRandomAgentSecret());
 
@@ -1926,9 +1736,7 @@ test("Can give write permissions to 'everyone' (high-level)", async () => {
 
     expect(childContent2.get("foo")).toEqual("bar");
 
-    childContent2.edit((editable) => {
-        console.log("Before anon set");
-        editable.set("foo", "bar2", "private");
-        expect(editable.get("foo")).toEqual("bar2");
-    });
+    console.log("Before anon set");
+    childContent2.set("foo", "bar2", "private");
+    expect(childContent2.get("foo")).toEqual("bar2");
 });