@roc-db/test-utils 0.2.0-pre.10 → 0.2.0-pre.100

package/dist/index.js

@@ -2,17 +2,12 @@
 import { entitySchemaGenerator } from "roc-db";
 import { z } from "zod";
 
-// src/schemas/BlockImageRefSchema.ts
-import { refSchemaGenerator } from "roc-db";
-var BlockImageRefSchema = refSchemaGenerator("BlockImage");
-
 // src/schemas/PostRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator2 } from "roc-db";
-var PostRefSchema = refSchemaGenerator2("Post");
+import { refSchemaGenerator } from "roc-db";
+var PostRefSchema = refSchemaGenerator("Post");
 
 // src/schemas/BlockImageSchema.ts
 var BlockImageSchema = entitySchemaGenerator("BlockImage", {
-  ref: BlockImageRefSchema,
   data: z.object({
     url: z.string().url()
   }),
@@ -24,14 +19,7 @@ var BlockImageSchema = entitySchemaGenerator("BlockImage", {
 // src/schemas/BlockParagraphSchema.ts
 import { entitySchemaGenerator as entitySchemaGenerator2 } from "roc-db";
 import { z as z2 } from "zod";
-
-// src/schemas/BlockParagraphRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator3 } from "roc-db";
-var BlockParagraphRefSchema = refSchemaGenerator3("BlockParagraph");
-
-// src/schemas/BlockParagraphSchema.ts
 var BlockParagraphSchema = entitySchemaGenerator2("BlockParagraph", {
-  ref: BlockParagraphRefSchema,
   data: z2.object({
     content: z2.string().optional()
   }),
@@ -43,14 +31,7 @@ var BlockParagraphSchema = entitySchemaGenerator2("BlockParagraph", {
 // src/schemas/BlockTitleSchema.ts
 import { entitySchemaGenerator as entitySchemaGenerator3 } from "roc-db";
 import { z as z3 } from "zod";
-
-// src/schemas/BlockTitleRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator4 } from "roc-db";
-var BlockTitleRefSchema = refSchemaGenerator4("BlockTitle");
-
-// src/schemas/BlockTitleSchema.ts
 var BlockTitleSchema = entitySchemaGenerator3("BlockTitle", {
-  ref: BlockTitleRefSchema,
   data: z3.object({
     content: z3.string()
   }),
@@ -62,16 +43,9 @@ var BlockTitleSchema = entitySchemaGenerator3("BlockTitle", {
 // src/schemas/DraftSchema.ts
 import { entitySchemaGenerator as entitySchemaGenerator4 } from "roc-db";
 import { z as z4 } from "zod";
-
-// src/schemas/DraftRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator5 } from "roc-db";
-var DraftRefSchema = refSchemaGenerator5("Draft");
-
-// src/schemas/DraftSchema.ts
 var DraftSchema = entitySchemaGenerator4("Draft", {
-  ref: DraftRefSchema,
-  data: z4.object({
-    postRef: PostRefSchema
+  parents: z4.object({
+    post: PostRefSchema
   })
 });
 
@@ -80,12 +54,11 @@ import { entitySchemaGenerator as entitySchemaGenerator5 } from "roc-db";
 import { z as z5 } from "zod";
 
 // src/schemas/UserRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator6 } from "roc-db";
-var UserRefSchema = refSchemaGenerator6("User");
+import { refSchemaGenerator as refSchemaGenerator2 } from "roc-db";
+var UserRefSchema = refSchemaGenerator2("User");
 
 // src/schemas/PostSchema.ts
 var PostSchema = entitySchemaGenerator5("Post", {
-  ref: PostRefSchema,
   data: z5.object({
     title: z5.string(),
     text: z5.string().optional(),
@@ -95,414 +68,1348 @@ var PostSchema = entitySchemaGenerator5("Post", {
   parents: z5.object({ author: UserRefSchema.optional() }),
   children: z5.object({ blocks: z5.array(z5.string()) })
 });
+
+// src/entities/Draft.ts
+import { Entity } from "roc-db";
+import { z as z6 } from "zod";
+
+// src/schemas/PostVersionRefSchema.ts
+import { refSchemaGenerator as refSchemaGenerator3 } from "roc-db";
+var PostVersionRefSchema = refSchemaGenerator3("PostVersion");
+
+// src/entities/Draft.ts
+var Draft = new Entity("Draft", {
+  changeSet: true,
+  data: z6.object({
+    appliedAt: z6.string().optional()
+  }),
+  parents: z6.object({
+    post: PostRefSchema,
+    version: PostVersionRefSchema.optional()
+  })
+});
+
+// src/schemas/DraftRefSchema.ts
+var DraftRefSchema = Draft.refSchema;
 // src/schemas/CreatePostMutationSchema.ts
 import { mutationSchemaGenerator } from "roc-db";
-import { z as z6 } from "zod";
-var CreatePostMutationSchema = mutationSchemaGenerator("createPost", z6.object({
-  title: z6.string(),
-  slug: z6.string().optional(),
-  tags: z6.array(z6.string()).default([])
+import { z as z7 } from "zod";
+var CreatePostMutationSchema = mutationSchemaGenerator("createPost", z7.object({
+  title: z7.string(),
+  slug: z7.string().optional(),
+  tags: z7.array(z7.string()).default([])
 }).strict());
 // src/schemas/CreateUserMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator2 } from "roc-db";
-import { z as z7 } from "zod";
-var CreateUserMutationSchema = mutationSchemaGenerator2("createUser", z7.object({ email: z7.string() }));
+import { z as z8 } from "zod";
+var CreateUserMutationSchema = mutationSchemaGenerator2("createUser", z8.object({ email: z8.string() }));
 // src/schemas/UpdatePostMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator3 } from "roc-db";
-import { z as z8 } from "zod";
-var UpdatePostMutationSchema = mutationSchemaGenerator3("updatePost", z8.object({
+import { z as z9 } from "zod";
+var UpdatePostMutationSchema = mutationSchemaGenerator3("updatePost", z9.object({
   ref: PostRefSchema,
-  title: z8.string().optional(),
-  tags: z8.array(z8.string()).optional().default([]),
-  authorRef: UserRefSchema.optional().optional()
+  title: z9.string().optional(),
+  tags: z9.array(z9.string()).optional().default([]),
+  authorRef: UserRefSchema.optional()
 }));
 // src/schemas/UpdatePostTitleMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator4 } from "roc-db";
-import { z as z9 } from "zod";
-var UpdatePostTitleMutationSchema = mutationSchemaGenerator4("updatePostTitle", z9.object({ ref: PostRefSchema, title: z9.string() }));
-// src/schemas/index.ts
-var entities = [
-  BlockImageSchema,
-  BlockParagraphSchema,
-  BlockTitleSchema,
-  DraftSchema,
-  PostSchema
-];
-// src/operations/createBlockImage.ts
-import { Query, writeOperation } from "roc-db";
-
-// src/schemas/CreateBlockImageMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator5 } from "roc-db";
 import { z as z10 } from "zod";
-var CreateBlockImageMutationSchema = mutationSchemaGenerator5("createBlockImage", z10.object({ postRef: PostRefSchema }).strict(), undefined, true);
+var UpdatePostTitleMutationSchema = mutationSchemaGenerator4("updatePostTitle", z10.object({ ref: PostRefSchema, title: z10.string() }));
+// src/entities/BlockImageEntity.ts
+import { Entity as Entity2 } from "roc-db";
+import { z as z11 } from "zod";
+var BlockImageEntity = new Entity2("BlockImage", {
+  data: z11.object({
+    url: z11.string().url()
+  }),
+  parents: z11.object({
+    parent: PostRefSchema
+  })
+});
 
-// src/operations/createBlockImage.ts
-var createBlockImage = writeOperation(CreateBlockImageMutationSchema, BlockImageSchema, (txn) => {
-  const ref = txn.createRef("BlockImage");
-  const { postRef } = txn.payload;
-  return Query(() => txn.createEntity(ref, { parents: { post: postRef } }));
-}, { changeSetOnly: true });
+// src/entities/BlockParagraph.ts
+import { Entity as Entity4 } from "roc-db";
+import { z as z14 } from "zod";
 
-// src/operations/createBlockParagraph.ts
-import { Query as Query2, QueryChain, writeOperation as writeOperation2 } from "roc-db";
+// src/entities/PostEntity.ts
+import { Entity as Entity3 } from "roc-db";
+import { z as z12 } from "zod";
+var PostEntity = new Entity3("Post", {
+  data: z12.object({
+    title: z12.string(),
+    text: z12.string().optional(),
+    tags: z12.array(z12.string()),
+    slug: z12.string().optional()
+  }),
+  parents: z12.object({ author: UserRefSchema.optional() }),
+  children: z12.object({ blocks: z12.array(z12.string()) }),
+  indexedDataKeys: ["tags", "slug"],
+  uniqueDataKeys: ["slug"]
+});
 
-// src/schemas/CreateBlockParagraphMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator6 } from "roc-db";
-import { z as z11 } from "zod";
+// src/schemas/BlockRefSchema.ts
+import { z as z13 } from "zod";
+
+// src/schemas/BlockParagraphRefSchema.ts
+import { refSchemaGenerator as refSchemaGenerator4 } from "roc-db";
+var BlockParagraphRefSchema = refSchemaGenerator4("BlockParagraph");
 
 // src/schemas/BlockRowRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator7 } from "roc-db";
-var BlockRowRefSchema = refSchemaGenerator7("BlockRow");
+import { refSchemaGenerator as refSchemaGenerator5 } from "roc-db";
+var BlockRowRefSchema = refSchemaGenerator5("BlockRow");
 
-// src/schemas/CreateBlockParagraphMutationSchema.ts
-var CreateBlockParagraphMutationSchema = mutationSchemaGenerator6("createBlockParagraph", z11.object({ parentRef: z11.union([PostRefSchema, BlockRowRefSchema]) }).strict(), undefined, true);
+// src/schemas/BlockRefSchema.ts
+var BlockRefSchema = z13.union([
+  BlockParagraphRefSchema,
+  BlockRowRefSchema
+]);
 
-// src/operations/createBlockParagraph.ts
-var createBlockParagrah = writeOperation2(CreateBlockParagraphMutationSchema, BlockParagraphSchema, (txn) => {
-  const ref = txn.createRef("BlockParagraph");
-  const { parentRef } = txn.payload;
-  return QueryChain(Query2(() => txn.readEntity(parentRef, true)), Query2((parent) => txn.patchEntity(parentRef, {
-    children: { blocks: [...parent.children.blocks, ref] }
-  })), Query2(() => txn.createEntity(ref, { parents: { parent: parentRef } })), Query2((block, updatedParent) => ({ block, updatedParent })));
+// src/entities/BlockParagraph.ts
+var BlockParagraph = new Entity4("BlockParagraph", {
+  data: z14.object({
+    content: z14.string().optional()
+  }),
+  parents: z14.object({
+    parent: z14.union([PostEntity.refSchema, BlockRefSchema])
+  })
+});
+
+// src/entities/BlockRow.ts
+import { Entity as Entity5 } from "roc-db";
+import { z as z15 } from "zod";
+var BlockRow = new Entity5("BlockRow", {
+  children: z15.object({
+    blocks: z15.array(BlockRefSchema)
+  }),
+  parents: z15.object({
+    parent: z15.union([PostEntity.refSchema, BlockRefSchema])
+  })
+});
+
+// src/entities/OrgSettingsEntity.ts
+import { Entity as Entity6 } from "roc-db";
+import { z as z16 } from "zod";
+var OrgSettingsEntity = new Entity6("OrgSettings", {
+  singleton: true,
+  data: z16.object({
+    name: z16.string(),
+    theme: z16.string().optional()
+  }),
+  parents: z16.object({ primaryAdmin: UserRefSchema.optional() }),
+  children: z16.object({ featuredPosts: z16.array(z16.string()) })
+});
+
+// src/entities/PostVersion.ts
+import { Entity as Entity7 } from "roc-db";
+import { z as z17 } from "zod";
+var PostVersion = new Entity7("PostVersion", {
+  version: true,
+  data: z17.object({
+    version: z17.number(),
+    snapshot: z17.array(z17.any())
+  }),
+  parents: z17.object({ post: PostRefSchema }),
+  indexedDataKeys: ["version"],
+  uniqueDataKeys: ["slug"]
+});
+
+// src/entities/UserEntity.ts
+import { Entity as Entity8 } from "roc-db";
+import { z as z18 } from "zod";
+var UserEntity = new Entity8("User", {
+  data: z18.object({
+    email: z18.string().email()
+  }),
+  uniqueDataKeys: ["email"]
+});
+
+// src/entities/index.ts
+var entities = [
+  BlockImageEntity,
+  BlockParagraph,
+  BlockRow,
+  Draft,
+  OrgSettingsEntity,
+  PostEntity,
+  PostVersion,
+  UserEntity
+];
+// src/operations/applyDraft.ts
+import { Query, QueryChain, writeOperation } from "roc-db";
+var applyDraft = writeOperation("applyDraft", DraftRefSchema, (txn) => {
+  const ref = txn.payload;
+  const versionRef = txn.createRef("PostVersion");
+  return QueryChain(Query(() => txn.applyChangeSet(ref)), Query(() => txn.patchEntity(ref, {
+    data: { appliedAt: txn.timestamp }
+  })), Query((draft) => txn.childRefsOf(draft.parents.post, true)), Query((childRefs, draft) => txn.batchReadEntities([draft.parents.post, ...childRefs])), Query((childEntities, _, draft) => txn.createEntity(versionRef, {
+    data: {
+      version: 1,
+      snapshot: childEntities
+    },
+    parents: {
+      post: draft.parents.post
+    }
+  })));
+});
+
+// src/operations/createBlockImage.ts
+import { Query as Query2, writeOperation as writeOperation2 } from "roc-db";
+import { z as z19 } from "zod";
+var createBlockImage = writeOperation2("createBlockImage", z19.object({ parentRef: PostRefSchema, url: z19.string().url() }).strict(), (txn) => {
+  const ref = txn.createRef("BlockImage");
+  const { parentRef, url } = txn.payload;
+  return Query2(() => txn.createEntity(ref, {
+    data: { url },
+    parents: { parent: parentRef }
+  }));
 }, { changeSetOnly: true });
 
-// src/operations/createBlockRow.ts
+// src/operations/createBlockParagraph.ts
 import { Query as Query3, QueryChain as QueryChain2, writeOperation as writeOperation3 } from "roc-db";
-
-// src/schemas/CreateBlockRowMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator7 } from "roc-db";
-import { z as z12 } from "zod";
-var CreateBlockRowMutationSchema = mutationSchemaGenerator7("createBlockRow", z12.object({ parentRef: z12.union([PostRefSchema, BlockRowRefSchema]) }).strict(), undefined, true);
+import { z as z20 } from "zod";
+var createBlockParagrah = writeOperation3("createBlockParagraph", z20.object({
+  parentRef: z20.union([PostRefSchema, BlockRowRefSchema]),
+  content: z20.string().optional()
+}).strict(), (txn) => {
+  const ref = txn.createRef("BlockParagraph");
+  const { parentRef, content } = txn.payload;
+  return QueryChain2(Query3(() => txn.readEntity(parentRef, true)), Query3((parent) => txn.patchEntity(parentRef, {
+    children: { blocks: [...parent.children.blocks, ref] }
+  })), Query3(() => txn.createEntity(ref, {
+    parents: { parent: parentRef },
+    data: { content }
+  })), Query3((block, updatedParent) => ({ block, updatedParent })));
+}, {
+  changeSetOnly: true,
+  outputSchema: z20.object({
+    block: z20.any(),
+    updatedParent: z20.any()
+  })
+});
 
 // src/operations/createBlockRow.ts
-var createBlockRow = writeOperation3(CreateBlockRowMutationSchema, BlockParagraphSchema, (txn) => {
+import { Query as Query4, QueryChain as QueryChain3, writeOperation as writeOperation4 } from "roc-db";
+import { z as z21 } from "zod";
+var createBlockRow = writeOperation4("createBlockRow", z21.object({ parentRef: z21.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
   const ref = txn.createRef("BlockRow");
   const { parentRef } = txn.payload;
-  return QueryChain2(Query3(() => txn.readEntity(parentRef)), Query3((parent) => {
+  return QueryChain3(Query4(() => txn.readEntity(parentRef)), Query4((parent) => {
     return txn.patchEntity(parentRef, {
       children: { blocks: [...parent.children.blocks, ref] }
     });
-  }), Query3(() => txn.createEntity(ref, {
+  }), Query4(() => txn.createEntity(ref, {
     children: { blocks: [] },
     parents: { parent: parentRef }
-  })), Query3((block, updatedParent) => ({ block, updatedParent })));
-}, { changeSetOnly: true });
-
-// src/operations/createBlockTitle.ts
-import { Query as Query4, writeOperation as writeOperation4 } from "roc-db";
+  })), Query4((block, updatedParent) => ({ block, updatedParent })));
+}, {
+  changeSetOnly: true,
+  outputSchema: z21.object({
+    block: z21.any(),
+    updatedParent: z21.any()
+  })
+});
 
-// src/schemas/CreateBlockTitleMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator8 } from "roc-db";
-import { z as z13 } from "zod";
-var CreateBlockTitleMutationSchema = mutationSchemaGenerator8("createBlockTitle", z13.object({ parentRef: z13.union([PostRefSchema, BlockRowRefSchema]) }).strict(), undefined, true);
+// src/operations/createBlockRowReadingRoot.ts
+import { Query as Query5, QueryChain as QueryChain4, writeOperation as writeOperation5 } from "roc-db";
+import { z as z22 } from "zod";
+var createBlockRowReadingRoot = writeOperation5("createBlockRowReadingRoot", z22.object({ parentRef: z22.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
+  const ref = txn.createRef("BlockRow");
+  const { parentRef } = txn.payload;
+  return QueryChain4(Query5(() => {
+    if (txn.changeSetRef)
+      txn.readEntity(txn.changeSetRef);
+  }), Query5(() => txn.readEntity(parentRef)), Query5((parent) => txn.patchEntity(parentRef, {
+    children: { blocks: [...parent.children.blocks, ref] }
+  })), Query5(() => txn.createEntity(ref, {
+    children: { blocks: [] },
+    parents: { parent: parentRef }
+  })), Query5((block) => ({ block })));
+}, {
+  changeSetOnly: true,
+  outputSchema: z22.object({ block: z22.any() })
+});
 
 // src/operations/createBlockTitle.ts
-var createBlockTitle = writeOperation4(CreateBlockTitleMutationSchema, BlockTitleSchema, (txn) => {
+import { Query as Query6, writeOperation as writeOperation6 } from "roc-db";
+import { z as z23 } from "zod";
+var PayloadSchema = z23.object({ parentRef: z23.union([PostRefSchema, BlockRowRefSchema]) }).strict();
+var createBlockTitle = writeOperation6("createBlockTitle", PayloadSchema, (txn) => {
   const ref = txn.createRef("BlockTitle");
-  const { postRef } = txn.payload;
-  return Query4(() => txn.createEntity(ref, { parents: { post: postRef } }));
-}, { changeSetOnly: true });
-
-// src/operations/createDraft.ts
-import { Query as Query5, writeOperation as writeOperation5 } from "roc-db";
-
-// src/schemas/CreateDraftMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator9 } from "roc-db";
-import { z as z14 } from "zod";
-var CreateDraftMutationSchema = mutationSchemaGenerator9("createDraft", z14.object({ postRef: PostRefSchema }).strict());
+  const { parentRef } = txn.payload;
+  return Query6(() => txn.createEntity(ref, { parents: { post: parentRef } }));
+}, { changeSetOnly: true, outputSchema: BlockTitleSchema });
 
 // src/operations/createDraft.ts
-var createDraft = writeOperation5(CreateDraftMutationSchema, DraftSchema, (txn) => {
+import { Query as Query7, writeOperation as writeOperation7 } from "roc-db";
+import { z as z24 } from "zod";
+var createDraft = writeOperation7("createDraft", z24.object({ postRef: PostRefSchema }).strict(), (txn) => {
   const ref = txn.createRef("Draft");
   const { postRef } = txn.payload;
-  return Query5(() => txn.createEntity(ref, {
+  return Query7(() => txn.createEntity(ref, {
     parents: {
       post: postRef
     }
   }));
+}, { outputSchema: DraftSchema });
+
+// src/operations/createOrgSettings.ts
+import { Query as Query8, writeOperation as writeOperation8 } from "roc-db";
+import { z as z25 } from "zod";
+var createOrgSettings = writeOperation8("createOrgSettings", z25.object({
+  name: z25.string(),
+  theme: z25.string().optional(),
+  primaryAdmin: UserRefSchema.optional()
+}), (txn) => {
+  const ref = txn.createRef("OrgSettings");
+  const { name, theme, primaryAdmin } = txn.payload;
+  return Query8(() => txn.createEntity(ref, {
+    data: { name, theme },
+    parents: { primaryAdmin },
+    children: { featuredPosts: [] }
+  }));
 });
 
 // src/operations/createPost.ts
-import { Query as Query6, writeOperation as writeOperation6 } from "roc-db";
-var createPost = writeOperation6(CreatePostMutationSchema, PostSchema, (txn) => {
+import { Query as Query9, writeOperation as writeOperation9 } from "roc-db";
+import { z as z26 } from "zod";
+var PayloadSchema2 = z26.object({
+  title: z26.string(),
+  slug: z26.string().optional(),
+  tags: z26.array(z26.string()).default([])
+}).strict();
+var createPost = writeOperation9("createPost", PayloadSchema2, (txn) => {
   const ref = txn.createRef("Post");
   const { title, slug, tags } = txn.payload;
-  return Query6(() => txn.createEntity(ref, {
+  return Query9(() => txn.createEntity(ref, {
     data: { title, tags, slug },
     children: { blocks: [] }
   }));
 });
 
-// src/operations/deleteBlock.ts
-import { Query as Query7, QueryChain as QueryChain3, writeOperation as writeOperation7 } from "roc-db";
+// src/operations/createUnknownRef.ts
+import { Query as Query10, writeOperation as writeOperation10 } from "roc-db";
+import { z as z27 } from "zod";
+var createUnknownRef = writeOperation10("createUnknownRef", z27.object({}).optional(), (txn) => Query10(() => txn.createRef("NotARegisteredEntity")));
 
-// src/schemas/DeleteBlockMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator10 } from "roc-db";
-import { z as z15 } from "zod";
-var DeleteBlockMutationSchema = mutationSchemaGenerator10("deleteBlock", z15.union([BlockParagraphRefSchema, BlockImageRefSchema]));
+// src/operations/createUser.ts
+import { Query as Query11, writeOperation as writeOperation11 } from "roc-db";
+import { z as z28 } from "zod";
+var createUser = writeOperation11("createUser", z28.object({ email: z28.string() }), (txn) => {
+  const ref = txn.createRef("User");
+  const { email } = txn.payload;
+  return Query11(() => txn.createEntity(ref, { data: { email } }));
+});
+
+// src/operations/deleteBlocks.ts
+import { Query as Query12, QueryChain as QueryChain5, writeOperation as writeOperation12 } from "roc-db";
+import { z as z29 } from "zod";
+
+// src/schemas/BlockImageRefSchema.ts
+import { refSchemaGenerator as refSchemaGenerator6 } from "roc-db";
+var BlockImageRefSchema = refSchemaGenerator6("BlockImage");
 
-// src/operations/deleteBlock.ts
-var deleteBlock = writeOperation7(DeleteBlockMutationSchema, PostSchema, (txn) => {
-  const blockRef = txn.payload;
-  return QueryChain3(Query7(() => txn.readEntity(blockRef, true)), Query7((block) => txn.readEntity(block.parents.post, true)), Query7((post) => {
+// src/operations/deleteBlocks.ts
+var DeleteBlockQuery = (txn, blockRef) => {
+  return QueryChain5(Query12(() => txn.readEntity(blockRef)), Query12((block) => {
+    return txn.readEntity(block.parents.parent, true);
+  }), Query12((post) => {
     return txn.patchEntity(post.ref, {
-      data: {
-        blockRefs: post.data.blockRefs.filter((ref) => ref !== blockRef)
+      children: {
+        blocks: post.children.blocks.filter((ref) => ref !== blockRef)
       }
     });
-  }), Query7(() => txn.deleteEntity(blockRef)), Query7((_, updatedPost) => {
-    return updatedPost;
-  }));
+  }), Query12(() => txn.deleteEntity(blockRef)));
+};
+var deleteBlocks = writeOperation12("deleteBlocks", z29.array(z29.union([
+  BlockParagraphRefSchema,
+  BlockImageRefSchema,
+  BlockRowRefSchema
+])), (txn) => {
+  const refs = txn.payload;
+  return QueryChain5(...refs.map((ref) => DeleteBlockQuery(txn, ref)));
 }, { changeSetOnly: true });
 
-// src/operations/deletePost.ts
-import { Query as Query8, writeOperation as writeOperation8 } from "roc-db";
+// src/operations/deleteDraft.ts
+import { Query as Query13, QueryChain as QueryChain6, writeOperation as writeOperation13 } from "roc-db";
+var deleteDraft = writeOperation13("deleteDraft", DraftRefSchema, (txn) => {
+  const ref = txn.payload;
+  return QueryChain6(Query13(() => txn.deleteEntity(ref, true)), Query13(() => txn.deleteChangeSet(ref)));
+});
 
-// src/schemas/DeletePostMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator11 } from "roc-db";
-var DeletePostMutationSchema = mutationSchemaGenerator11("deletePost", PostRefSchema);
+// src/operations/deleteOrgSettings.ts
+import { Query as Query14, writeOperation as writeOperation14 } from "roc-db";
+import { z as z30 } from "zod";
+var deleteOrgSettings = writeOperation14("deleteOrgSettings", z30.object({}).optional(), (txn) => Query14(() => txn.deleteEntity("OrgSettings")));
 
 // src/operations/deletePost.ts
-var deletePost = writeOperation8(DeletePostMutationSchema, undefined, (txn) => {
+import { Query as Query15, writeOperation as writeOperation15 } from "roc-db";
+var deletePost = writeOperation15("deletePost", PostRefSchema, (txn) => {
   const ref = txn.payload;
-  return Query8(() => txn.deleteEntity(ref, true));
+  return Query15(() => txn.deleteEntity(ref, true));
+});
+
+// src/operations/duplicateDraft.ts
+import {
+  Query as Query16,
+  QueryChain as QueryChain7,
+  writeOperation as writeOperation16
+} from "roc-db";
+import { z as z31 } from "zod";
+var duplicateDraft = writeOperation16("duplicateDraft", z31.object({ sourceRef: DraftRefSchema, postRef: PostRefSchema }).strict(), (txn) => {
+  const newDraftRef = txn.createRef("Draft");
+  const { sourceRef, postRef } = txn.payload;
+  return QueryChain7(Query16(() => txn.createEntity(newDraftRef, { parents: { post: postRef } })), Query16(() => txn.duplicateChangeSetMutations(sourceRef, newDraftRef)), Query16((dup) => {
+    const result = dup;
+    return {
+      draftRef: newDraftRef,
+      mutations: result.mutations,
+      refMap: result.refMap
+    };
+  }));
+});
+
+// src/operations/moveBlocks.ts
+import { Query as Query17, QueryChain as QueryChain8, writeOperation as writeOperation17 } from "roc-db";
+import { z as z32 } from "zod";
+var PayloadSchema3 = z32.object({
+  refs: z32.array(z32.union([BlockParagraphRefSchema, BlockRowRefSchema])),
+  targetPosition: z32.number().min(0)
+}).strict();
+var moveBlocks = writeOperation17("moveBlocks", PayloadSchema3, (txn) => {
+  const { refs } = txn.payload;
+  return QueryChain8(Query17(() => txn.batchReadEntities(refs)), Query17((items) => {
+    return "todo";
+  }));
+});
+
+// src/operations/pageBlocks.ts
+import { Query as Query18, readOperation } from "roc-db";
+import { z as z33 } from "zod";
+var pageBlocks = readOperation("pageBlocks", z33.object({
+  size: z33.number().default(100),
+  parentRef: z33.string().optional()
+}), (txn) => {
+  const { size, parentRef } = txn.payload;
+  return Query18(() => txn.pageEntities({
+    entities: ["BlockImage", "BlockParagraph"],
+    size,
+    childrenOf: parentRef ? [parentRef] : []
+  }));
+});
+
+// src/operations/pageEmptyEntitiesArray.ts
+import { Query as Query19, readOperation as readOperation2 } from "roc-db";
+import { z as z34 } from "zod";
+var pageEmptyEntitiesArray = readOperation2("pageEmptyEntitiesArray", z34.object({ size: z34.number().default(100) }), (txn) => {
+  const { size } = txn.payload;
+  return Query19(() => txn.pageEntities({ entities: [], size }));
+});
+
+// src/operations/pagePosts.ts
+import { Query as Query20, readOperation as readOperation3 } from "roc-db";
+import { z as z35 } from "zod";
+var pagePosts = readOperation3("pagePosts", z35.object({ size: z35.number().default(100) }).default({}), (txn) => {
+  const { size } = txn.payload;
+  return Query20(() => txn.pageEntities({ entities: ["Post"], size }));
+});
+
+// src/operations/pageSplat.ts
+import { Query as Query21, readOperation as readOperation4 } from "roc-db";
+import { z as z36 } from "zod";
+var pageSplat = readOperation4("pageSplat", z36.object({ size: z36.number().default(100) }), (txn) => {
+  const { size } = txn.payload;
+  return Query21(() => txn.pageEntities({ entities: "*", size }));
+});
+
+// src/operations/pagePostsByTag.ts
+import { Query as Query22, readOperation as readOperation5 } from "roc-db";
+import { z as z37 } from "zod";
+var pagePostsByTag = readOperation5("pagePostsByTag", z37.string(), (txn) => {
+  const tag = txn.payload;
+  return Query22(() => txn.pageEntitiesByIndex("Post", "tags", tag));
 });
 
 // src/operations/readEntity.ts
-import { NotFoundError, Query as Query9, QueryChain as QueryChain4, readOperation } from "roc-db";
-import { z as z16 } from "zod";
-var readEntity = readOperation("readEntity", z16.string(), z16.union([PostSchema, BlockImageSchema, BlockParagraphSchema]), (txn) => {
+import { NotFoundError, Query as Query23, QueryChain as QueryChain9, readOperation as readOperation6 } from "roc-db";
+import { z as z38 } from "zod";
+var readEntity = readOperation6("readEntity", z38.string(), (txn) => {
   const ref = txn.payload;
-  return QueryChain4(Query9(() => txn.readEntity(ref)), Query9((entity) => {
+  return QueryChain9(Query23(() => txn.readEntity(ref)), Query23((entity) => {
     if (!entity) {
       throw new NotFoundError(ref);
     }
     return entity;
   }));
+}, {
+  outputSchema: z38.union([
+    PostSchema,
+    BlockImageSchema,
+    BlockParagraphSchema
+  ])
 });
 
-// src/operations/readPost.ts
-import { Query as Query10, readOperation as readOperation2 } from "roc-db";
-var readPost = readOperation2("readPost", PostRefSchema, PostSchema, (txn) => {
+// src/operations/readMutation.ts
+import { NotFoundError as NotFoundError2, Query as Query24, QueryChain as QueryChain10, readOperation as readOperation7 } from "roc-db";
+import { z as z39 } from "zod";
+var readMutation = readOperation7("readMutation", z39.string(), (txn) => {
   const ref = txn.payload;
-  return Query10(() => txn.readEntity(ref));
+  return QueryChain10(Query24(() => txn.readMutation(ref)), Query24((entity) => {
+    if (!entity) {
+      throw new NotFoundError2(ref);
+    }
+    return entity;
+  }));
 });
 
-// src/operations/updateBlockParagraph.ts
-import { Query as Query11, writeOperation as writeOperation9 } from "roc-db";
+// src/operations/readOrgSettings.ts
+import { Query as Query25, readOperation as readOperation8 } from "roc-db";
+import { z as z40 } from "zod";
+var readOrgSettings = readOperation8("readOrgSettings", z40.object({}).optional(), (txn) => Query25(() => txn.readEntity("OrgSettings", true)));
 
-// src/schemas/UpdateBlockParagraphMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator12 } from "roc-db";
-import { z as z17 } from "zod";
-var UpdateBlockParagraphMutationSchema = mutationSchemaGenerator12("updateBlockParagraph", z17.object({
-  ref: BlockParagraphRefSchema,
-  content: z17.string()
-}));
+// src/operations/readPost.ts
+import { Query as Query26, readOperation as readOperation9 } from "roc-db";
+var readPost = readOperation9("readPost", PostRefSchema, (txn) => {
+  const ref = txn.payload;
+  return Query26(() => txn.readEntity(ref, true));
+}, { outputSchema: PostSchema });
+
+// src/operations/readPostBySlug.ts
+import { Query as Query27, readOperation as readOperation10 } from "roc-db";
+import { z as z41 } from "zod";
+var readPostBySlug = readOperation10("readPostBySlug", z41.string(), (txn) => {
+  const slug = txn.payload;
+  return Query27(() => txn.readEntityByUniqueField("Post", "slug", slug));
+}, { outputSchema: PostSchema });
+
+// src/operations/testTransactionalEdits.ts
+import { expect } from "bun:test";
+import { Query as Query28, QueryChain as QueryChain11, writeOperation as writeOperation18 } from "roc-db";
+import { z as z42 } from "zod";
+var TestCreatePatchDeleteInSameTransaction = (txn, title) => {
+  const postRef = txn.createRef("Post");
+  return QueryChain11(Query28(() => txn.createEntity(postRef, {
+    data: { title, tags: [] },
+    children: { blocks: [] }
+  })), Query28(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query28((post) => {
+    expect(post.data.title).toBe(title);
+    expect(post.data.foo).toBe("bar");
+  }), Query28(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query28((post) => {
+    expect(post.data.title).toBe(title);
+    expect(post.data.foo).toBeUndefined();
+    expect(post.data.bar).toBe("foo");
+    expect(txn.log).toHaveLength(1);
+    expect(txn.log.get(postRef)?.[0]).toBe("create");
+  }), Query28((post) => txn.deleteEntity(postRef)), Query28((res) => {
+    expect(res).toBe(1);
+    expect(txn.log).toHaveLength(0);
+  }));
+};
+var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
+  return QueryChain11(Query28(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query28((post) => {
+    expect(post.data.foo).toBe("bar");
+  }), Query28(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query28((post) => {
+    expect(post.data.foo).toBeUndefined();
+    expect(post.data.bar).toBe("foo");
+    expect(txn.log).toHaveLength(1);
+    expect(txn.log.get(ref)?.[0]).toBe("update");
+  }), Query28((post) => txn.deleteEntity(ref)), Query28((res) => {
+    expect(res).toBe(1);
+    expect(txn.log).toHaveLength(1);
+    expect(txn.log.get(ref)?.[0]).toBe("delete");
+  }));
+};
+var TestCreateOnExistingRef = (txn) => {
+  const ref = txn.createRef("Post");
+  return QueryChain11(Query28(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query28(() => txn.createEntity(ref, { data: { foo: "bar" } })));
+};
+var PayloadSchema4 = z42.object({
+  name: z42.string().optional(),
+  post1ref: PostRefSchema.optional(),
+  post2ref: PostRefSchema.optional()
+}).strict();
+var testTransactionalEdits = writeOperation18("testTransactionalEdits", PayloadSchema4, (txn) => {
+  const { name, post1ref, post2ref } = txn.payload;
+  if (name)
+    return TestCreatePatchDeleteInSameTransaction(txn, name);
+  if (post1ref)
+    return TestUpdateAndDeleteInSameTransaction(txn, post1ref);
+  if (post2ref)
+    return TestCreateOnExistingRef(txn);
+}, {});
 
 // src/operations/updateBlockParagraph.ts
-var updateBlockParagraph = writeOperation9(UpdateBlockParagraphMutationSchema, BlockParagraphRefSchema, (txn) => {
+import { Query as Query29, writeOperation as writeOperation19 } from "roc-db";
+import { z as z43 } from "zod";
+var updateBlockParagraph = writeOperation19("updateBlockParagraph", z43.object({
+  ref: BlockParagraphRefSchema,
+  content: z43.string()
+}), (txn) => {
   const { ref, content } = txn.payload;
-  return Query11(() => txn.patchEntity(ref, {
+  return Query29(() => txn.patchEntity(ref, {
     data: { content }
   }));
-});
+}, { outputSchema: BlockParagraphSchema });
+
+// src/operations/updateOrgSettingsName.ts
+import { Query as Query30, writeOperation as writeOperation20 } from "roc-db";
+import { z as z44 } from "zod";
+var updateOrgSettingsName = writeOperation20("updateOrgSettingsName", z44.object({ name: z44.string() }), (txn) => {
+  const { name } = txn.payload;
+  return Query30(() => txn.patchEntity("OrgSettings", { data: { name } }));
+}, { debounce: 10 });
 
 // src/operations/updatePost.ts
-import { Query as Query12, writeOperation as writeOperation10 } from "roc-db";
-var updatePost = writeOperation10(UpdatePostMutationSchema, PostSchema, (txn) => {
+import { Query as Query31, writeOperation as writeOperation21 } from "roc-db";
+import { z as z45 } from "zod";
+var PayloadSchema5 = z45.object({
+  ref: PostRefSchema,
+  title: z45.string().optional(),
+  tags: z45.array(z45.string()).optional().default([]),
+  authorRef: UserRefSchema.optional()
+});
+var updatePost = writeOperation21("updatePost", PayloadSchema5, (txn) => {
   const { ref, authorRef, ...data } = txn.payload;
-  return Query12(() => txn.updateEntity(ref, {
+  return Query31(() => txn.updateEntity(ref, {
     data,
     parents: { author: authorRef },
     children: { blocks: [] }
   }));
-});
+}, { outputSchema: PostSchema });
+
+// src/operations/updatePostDescription.ts
+import { Query as Query32, writeOperation as writeOperation22 } from "roc-db";
+import { z as z46 } from "zod";
+var updatePostDescription = writeOperation22("updatePostDescription", z46.object({ ref: PostRefSchema, description: z46.string() }), (txn) => {
+  const { ref, description } = txn.payload;
+  return Query32(() => txn.patchEntity(ref, { data: { description } }));
+}, { debounce: 10, changeSetOnly: true, outputSchema: PostSchema });
+
+// src/operations/updatePostSlug.ts
+import { Query as Query33, writeOperation as writeOperation23 } from "roc-db";
+import { z as z47 } from "zod";
+var updatePostSlug = writeOperation23("updatePostSlug", z47.object({ ref: PostRefSchema, slug: z47.string() }), (txn) => {
+  const { ref, slug } = txn.payload;
+  return Query33(() => txn.patchEntity(ref, { data: { slug } }));
+}, { debounce: 10, outputSchema: PostSchema });
+
+// src/operations/updatePostTags.ts
+import { Query as Query34, writeOperation as writeOperation24 } from "roc-db";
+import { z as z48 } from "zod";
+var updatePostTags = writeOperation24("updatePostTags", z48.object({ ref: PostRefSchema, tags: z48.array(z48.string()) }), (txn) => {
+  const { ref, tags } = txn.payload;
+  return Query34(() => txn.patchEntity(ref, { data: { tags } }));
+}, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/updatePostTitle.ts
-import { Query as Query13, writeOperation as writeOperation11 } from "roc-db";
-var updatePostTitle = writeOperation11(UpdatePostTitleMutationSchema, PostSchema, (txn) => {
+import { Query as Query35, writeOperation as writeOperation25 } from "roc-db";
+import { z as z49 } from "zod";
+var updatePostTitle = writeOperation25("updatePostTitle", z49.object({ ref: PostRefSchema, title: z49.string() }), (txn) => {
   const { ref, title } = txn.payload;
-  return Query13(() => txn.patchEntity(ref, { data: { title } }));
-}, { debounce: 10 });
+  return Query35(() => txn.patchEntity(ref, { data: { title } }));
+}, { debounce: 10, outputSchema: PostSchema });
+
+// src/operations/crudBySlug.ts
+import { Query as Query36, QueryChain as QueryChain12, writeOperation as writeOperation26 } from "roc-db";
+import { z as z50 } from "zod";
+var crudBySlug = writeOperation26("crudBySlug", z50.object({ slug: z50.string(), newSlug: z50.string() }), (txn) => {
+  const { slug, newSlug } = txn.payload;
+  return QueryChain12(Query36(() => txn.readEntityByUniqueField("Post", "slug", slug)), Query36((post) => txn.patchEntity(post.ref, { data: { slug: newSlug } })), Query36(() => txn.readEntityByUniqueField("Post", "slug", newSlug)), Query36((post) => txn.deleteEntity(post.ref)), Query36(() => {
+    return [
+      txn.readEntityByUniqueField("Post", "slug", slug, false),
+      txn.readEntityByUniqueField("Post", "slug", newSlug, false)
+    ];
+  }));
+});
 
 // src/operations/index.ts
 var operations = [
+  applyDraft,
   createBlockImage,
   createBlockTitle,
   createBlockParagrah,
   createBlockRow,
+  createBlockRowReadingRoot,
   createDraft,
+  createOrgSettings,
   createPost,
-  deleteBlock,
+  createUnknownRef,
+  createUser,
+  crudBySlug,
+  deleteBlocks,
+  deleteDraft,
+  deleteOrgSettings,
   deletePost,
+  duplicateDraft,
+  readPostBySlug,
+  moveBlocks,
+  pagePostsByTag,
+  pageBlocks,
   readEntity,
+  readMutation,
+  readOrgSettings,
   readPost,
+  pageEmptyEntitiesArray,
+  pagePosts,
+  pageSplat,
+  testTransactionalEdits,
   updateBlockParagraph,
+  updateOrgSettingsName,
   updatePost,
+  updatePostDescription,
+  updatePostSlug,
+  updatePostTags,
   updatePostTitle
 ];
 // src/testAdapterImplementation.ts
-import { beforeAll, describe, expect, test } from "bun:test";
-import { BadRequestError, NotFoundError as NotFoundError2 } from "roc-db";
-var prepareChangeSetTest = async (adapter) => {
-  const [post] = await adapter.createPost({
+import { beforeAll, describe, expect as expect2, test } from "bun:test";
+import {
+  BadRequestError,
+  ConflictError,
+  Entity as Entity9,
+  NotFoundError as NotFoundError3,
+  Snowflake
+} from "roc-db";
+import { z as z51 } from "zod";
+import { faker } from "@faker-js/faker";
+var snowflake = new Snowflake(10, 10);
+var prepareChangeSetTest = async (adapter, adapter2) => {
+  const [post, createPostMutation] = await adapter.createPost({
     title: "Title 1",
-    slug: "title-1",
+    slug: faker.lorem.slug(5),
     tags: ["Foo", "Bar"]
   });
-  const [draft] = await adapter.createDraft({
+  expect2(createPostMutation.log).toStrictEqual([[post.ref, "create"]]);
+  const [draft, createDraftMutation] = await adapter.createDraft({
     postRef: post.ref
   });
+  expect2(createDraftMutation.log).toStrictEqual([[draft.ref, "create"]]);
   const changeSetAdapter = adapter.changeSet(draft.ref);
-  const [{ block: blockParagraph1 }] = await changeSetAdapter.createBlockParagraph({
+  const [
+    { block: blockParagraph1, updatedParent: updatedPost },
+    createBlockParagraphMutation
+  ] = await changeSetAdapter.createBlockParagraph({
     parentRef: post.ref
   });
-  const [{ block: blockRow, updatedParent }] = await changeSetAdapter.createBlockRow({
+  expect2(updatedPost.children.blocks).toStrictEqual([blockParagraph1.ref]);
+  expect2(updatedPost.children.blocks).toHaveLength(1);
+  expect2(createBlockParagraphMutation.log[1][2].children.blocks).toStrictEqual([]);
+  const readPost1 = await changeSetAdapter.readEntity(post.ref);
+  expect2(readPost1.children.blocks).toHaveLength(1);
+  const [{ block: blockRow, updatedParent: updatedPost2 }, mutation] = await changeSetAdapter.createBlockRow({
     parentRef: post.ref
   });
-  const [{ block: blockParagraph2 }] = await changeSetAdapter.createBlockParagraph({
+  expect2(updatedPost2.children.blocks).toHaveLength(2);
+  const readPost2 = await changeSetAdapter.readEntity(post.ref);
+  expect2(readPost2.children.blocks).toHaveLength(2);
+  const [{ block: blockParagraph2, updatedParent: updatedBlockRow }] = await changeSetAdapter.createBlockParagraph({
     parentRef: blockRow.ref
   });
+  const readPost3 = await changeSetAdapter.readEntity(post.ref);
+  expect2(readPost3.children.blocks).toHaveLength(2);
   return {
     postRef: post.ref,
     draftRef: draft.ref,
     changeSetAdapter,
     blockParagraph1,
     blockParagraph2,
-    blockRow,
-    post: updatedParent
+    blockRow: updatedBlockRow,
+    draft,
+    post: readPost3
   };
 };
-var testAdapterImplementation = (adapterConstructor, engineArgsAdapter1 = {}, engineArgsAdapter2 = {}) => {
-  return async () => {
-    const adapter1 = adapterConstructor({ operations, entities, ...engineArgsAdapter1 });
-    const adapter2 = adapterConstructor({ operations, entities, ...engineArgsAdapter2 });
-    describe("Post CRUD", async () => {
-      let postRef;
-      let post;
-      let createPostMutation;
-      beforeAll(async () => {
-        const createPostRes = await adapter1.createPost({
-          title: "Title 1",
-          slug: "title-1",
-          tags: ["Foo", "Bar"]
-        });
-        post = createPostRes[0];
-        postRef = createPostRes[0].ref;
-        createPostMutation = createPostRes[1];
-      });
-      test("create (createEntity function)", async () => {
-        expect(post).toMatchZodSchema(PostSchema);
-        expect(post.data.title).toBe("Title 1");
-        expect(post.data.tags).toStrictEqual(["Foo", "Bar"]);
-      });
-      test("read (readEntity function)", async () => {
-        const readPostRes = await adapter1.readPost(postRef);
-        expect(readPostRes.data.title).toStrictEqual("Title 1");
-        expect(readPostRes.data.tags).toStrictEqual(["Foo", "Bar"]);
-        expect(readPostRes).toMatchZodSchema(PostSchema);
-      });
-      test("update (updateEntity function)", async () => {
-        const [post2] = await adapter1.updatePost({
-          ref: postRef,
-          title: "Title 2",
-          tags: ["Foo"]
-        });
-        expect(post2.data.tags).toStrictEqual(["Foo"]);
-        expect(post2.data.title).toBe("Title 2");
-        expect(post2).toMatchZodSchema(PostSchema);
-      });
-      test("updateTitle (patchEntity function + debounce)", async () => {
-        const updatePostTitleRes1 = await adapter1.updatePostTitle({
-          ref: postRef,
-          title: "Title 3"
-        });
-        expect(updatePostTitleRes1[0]).toMatchZodSchema(PostSchema);
-        const updatePostTitleRes2 = await adapter1.updatePostTitle({
-          ref: postRef,
-          title: "Title 4"
-        });
-        expect(updatePostTitleRes2[0]).toMatchZodSchema(PostSchema);
-        expect(updatePostTitleRes2[1].ref).toBe(updatePostTitleRes1[1].ref);
-        expect(updatePostTitleRes2[1].timestamp >= updatePostTitleRes1[1].timestamp).toBeTrue();
-      });
-      test("delete (deleteEntity function)", async () => {
-        const [count, mutation] = await adapter1.deletePost(postRef);
-        expect(count).toBe(1);
-        expect(mutation.log).toStrictEqual([[postRef, "delete", null]]);
-      });
-      test("sync mutation", async () => {
-        const res = await adapter2.syncOptimisticMutation(createPostMutation);
-        expect(res[0]).toStrictEqual(post);
-        expect(res[1]).toStrictEqual(createPostMutation);
-        expect(() => adapter2.syncOptimisticMutation(createPostMutation)).toThrowError(BadRequestError);
-      });
-    });
-    describe("changeSet", async () => {
-      let postRef, draftRef, changeSetAdapter, blockParagraph1, post, blockRow, blockParagraph2;
-      beforeAll(async () => {
-        ({
-          postRef,
-          draftRef,
-          changeSetAdapter,
-          blockParagraph1,
-          post,
-          blockRow,
-          blockParagraph2
-        } = await prepareChangeSetTest(adapter1));
-      });
-      test("create (createEntity function w/changeSetRef)", async () => {
-        expect(blockParagraph1).toMatchZodSchema(BlockParagraphSchema);
-        expect(post).toMatchZodSchema(PostSchema);
-      });
-      test("read (readEntity function w/changeSetRef)", async () => {
-        const read = await changeSetAdapter.readEntity(blockParagraph1.ref);
-        expect(read).toMatchZodSchema(BlockParagraphSchema);
-      });
-      test("update (patchEntity function w/changeSetRef)", async () => {
-        const [updatedBlock] = await changeSetAdapter.updateBlockParagraph({
-          ref: blockParagraph1.ref,
-          content: "Hello, world!"
-        });
-        expect(updatedBlock).toMatchZodSchema(BlockParagraphSchema);
-      });
-      test("delete (with cascade delete)", async () => {
-        const [count, mutation] = await changeSetAdapter.deletePost(postRef);
-        expect(count).toBe(4);
-        expect(mutation.log).toStrictEqual([
-          [blockParagraph1.ref, "delete", draftRef],
-          [blockRow.ref, "delete", draftRef],
-          [blockParagraph2.ref, "delete", draftRef],
-          [postRef, "delete", draftRef]
-        ]);
-        await expect(() => changeSetAdapter.readEntity(blockParagraph1.ref)).toThrow(NotFoundError2);
-        await expect(() => changeSetAdapter.updateBlockParagraph({
-          ref: blockParagraph1.ref,
-          content: "Foo"
-        })).toThrow(NotFoundError2);
-      });
-      test("pageMutations", async () => {
-        const res = await changeSetAdapter.pageMutations({
-          changeSetRef: draftRef
-        });
-        expect(res.length).toBeGreaterThan(0);
-        expect(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
-      });
-      test("pageMutations2", async () => {
-        const res = await changeSetAdapter.pageMutations({
-          changeSetRef: draftRef
-        });
-        expect(res.length).toBeGreaterThan(0);
-        expect(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
-      });
+var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
+  let createAdapter = async ({
+    optimistic = false,
+    session = { identityRef: "User/42" },
+    engineArgs
+  } = {}) => {
+    return adapterConstructor({
+      operations,
+      entities,
+      session,
+      snowflake,
+      optimistic,
+      ...engineArgs ?? await generateArgs()
     });
   };
+  let adapter1, adapter2;
+  beforeAll(async () => {
+    adapter1 = await createAdapter();
+    adapter2 = await createAdapter();
+  });
+  describe("Post CRUD", () => {
+    let postRef;
+    let post;
+    let createPostMutation;
+    beforeAll(async () => {
+      const createPostRes = await adapter1.createPost({
+        title: "Title 1",
+        slug: faker.lorem.slug(5),
+        tags: ["Foo", "Bar"]
+      });
+      post = createPostRes[0];
+      postRef = createPostRes[0].ref;
+      createPostMutation = createPostRes[1];
+    });
+    test("create (createEntity function)", async () => {
+      expect2(post).toMatchZodSchema(PostEntity.schema);
+      expect2(post.data.title).toBe("Title 1");
+      expect2(post.data.tags).toStrictEqual(["Foo", "Bar"]);
+      expect2(createPostMutation).toMatchZodSchema(CreatePostMutationSchema);
+    });
+    test("read (readEntity function)", async () => {
+      const readPostRes = await adapter1.readPost(postRef);
+      expect2(readPostRes.data.title).toStrictEqual("Title 1");
+      expect2(readPostRes.data.tags).toStrictEqual(["Foo", "Bar"]);
+      expect2(readPostRes).toMatchZodSchema(PostEntity.schema);
+    });
+    test("read by unique", async () => {
+      const readPostRes = await adapter1.readPostBySlug(post.data.slug);
+      expect2(readPostRes.data.title).toStrictEqual("Title 1");
+      expect2(readPostRes.data.tags).toStrictEqual(["Foo", "Bar"]);
+      expect2(readPostRes.data.slug).toStrictEqual(post.data.slug);
+    });
+    test("create with same slug", async () => {
+      expect2(() => adapter1.createPost({
+        title: "Title 2",
+        slug: post.data.slug,
+        tags: ["Foo", "Bar"]
+      })).toThrow(ConflictError);
+    });
+    test("update unique slug", async () => {
+      const slug1 = faker.lorem.slug(5);
+      const slug2 = faker.lorem.slug(5);
+      const [post2] = await adapter1.createPost({
+        title: "Title 1",
+        slug: slug1
+      });
+      const readPostRes1 = await adapter1.readPostBySlug(slug1);
+      expect2(readPostRes1.data.slug).toStrictEqual(slug1);
+      const [updateRes] = await adapter1.updatePostSlug({
+        ref: post2.ref,
+        slug: slug2
+      });
+      expect2(updateRes.data.slug).toStrictEqual(slug2);
+      expect2(() => adapter1.readPostBySlug(slug1)).toThrow(NotFoundError3);
+      const readPostRes2 = await adapter1.readPostBySlug(slug2);
+      expect2(readPostRes2.data.slug).toStrictEqual(slug2);
+    });
+    test("update and delete post by slug", async () => {
+      const slug1 = faker.lorem.slug(5);
+      const slug2 = faker.lorem.slug(5);
+      const [post2] = await adapter1.createPost({
+        title: "Title 1",
+        slug: slug1
+      });
+      const [res] = await adapter1.crudBySlug({
+        slug: slug1,
+        newSlug: slug2
+      });
+      expect2(res).toStrictEqual([null, null]);
+    });
+    test("update index entries", async () => {
+      const [post2] = await adapter1.createPost({
+        title: "Title 1",
+        tags: ["foo"]
+      });
+      const pageTagFoo1 = await adapter1.pagePostsByTag("foo");
+      expect2(pageTagFoo1.length).toBe(1);
+      expect2(pageTagFoo1[0].ref).toBe(post2.ref);
+      const [updatedRes] = await adapter1.updatePostTags({
+        ref: post2.ref,
+        tags: ["bar"]
+      });
+      const pageTagFoo2 = await adapter1.pagePostsByTag("foo");
+      expect2(pageTagFoo2.length).toBe(0);
+      const pageTagBar1 = await adapter1.pagePostsByTag("bar");
+      expect2(pageTagBar1.length).toBe(1);
+      await adapter1.deletePost(post2.ref);
+      const pageTagBar2 = await adapter1.pagePostsByTag("bar");
+      expect2(pageTagBar2.length).toBe(0);
+    });
+    test("read not found (readEntity function)", async () => {
+      expect2(() => adapter1.readPost("Post/999")).toThrow(NotFoundError3);
+    });
+    test.todo("update (updateEntity function)", async () => {
+      const [post2] = await adapter1.updatePost({
+        ref: postRef,
+        title: "Title 2",
+        tags: ["Foo"]
+      });
+      expect2(post2.data.tags).toStrictEqual(["Foo"]);
+      expect2(post2.data.title).toBe("Title 2");
+      expect2(post2).toMatchZodSchema(PostEntity.schema);
+    });
+    test("updateTitle (patchEntity function + debounce)", async () => {
+      const [update1, mutation1] = await adapter1.updatePostTitle({
+        ref: postRef,
+        title: "Title 3"
+      });
+      expect2(update1).toMatchZodSchema(PostEntity.schema);
+      expect2(mutation1).toMatchZodSchema(UpdatePostTitleMutationSchema);
+      const [update2, mutation2] = await adapter1.updatePostTitle({
+        ref: postRef,
+        title: "Title 4"
+      });
+      expect2(update2).toMatchZodSchema(PostEntity.schema);
+      expect2(mutation2).toMatchZodSchema(UpdatePostTitleMutationSchema);
+      expect2(mutation1.ref).toBe(mutation2.ref);
+      expect2(mutation2.timestamp >= mutation1.timestamp).toBeTrue();
+    });
+    test("updatePostDescription without changeSetAdapter fails with BadRequestError", async () => {
+      expect2(() => adapter1.updatePostDescription({
+        ref: postRef,
+        description: "Description 1"
+      })).toThrow(BadRequestError);
+    });
+    test("delete (deleteEntity function)", async () => {
+      const currentPost = await adapter1.readPost(postRef);
+      expect2(currentPost.ref).toBe(postRef);
+      const [count, mutation] = await adapter1.deletePost(postRef);
+      expect2(count).toBe(1);
+      expect2(mutation.log).toStrictEqual([
+        [postRef, "delete", currentPost]
+      ]);
+      expect2(() => adapter1.readPost(postRef)).toThrow(NotFoundError3);
+    });
+    test("sync mutation", async () => {
+      const {
+        persistedAt: ignore,
+        ...createPostMutationWithoutPersistedAt
+      } = createPostMutation;
+      const [{ persistedAt, ...mutation }] = await adapter2.persistOptimisticMutations([createPostMutation]);
+      expect2(mutation).toStrictEqual(createPostMutationWithoutPersistedAt);
+    });
+    test("sync mutation with debounce > 0", async () => {
+      const [post2, createPostMutation2] = await adapter1.createPost({
+        title: "Foo"
+      });
+      const [{ persistedAt, ...mutation }] = await adapter2.persistOptimisticMutations([createPostMutation2]);
+      const {
+        persistedAt: ignore,
+        ...createPostMutationWithoutPersistedAt
+      } = createPostMutation2;
+      expect2(mutation).toStrictEqual(createPostMutationWithoutPersistedAt);
+      const res = await adapter1.updatePostTitle({
+        ref: post2.ref,
+        title: "A"
+      });
+      const [, debounceMutation] = await adapter1.updatePostTitle({
+        ref: post2.ref,
+        title: "A"
+      });
+      expect2(debounceMutation.debounceCount).toBe(1);
+      const [debounceMutationPersist] = await adapter2.persistOptimisticMutations([debounceMutation]);
+      expect2(debounceMutationPersist.debounceCount).toBe(1);
+      expect2(debounceMutationPersist.persistedAt).toBeDefined();
+    });
+    test("create, patch and delete the same item within the same transaction", async () => {
+      const [post1] = await adapter1.createPost({ title: "Post 1" });
+      const [post2] = await adapter1.createPost({ title: "Post 1" });
+      const [currentPost, mutation] = await adapter1.testTransactionalEdits({
+        name: "Test"
+      });
+      expect2(mutation.log).toHaveLength(0);
+      const [, mutation2] = await adapter1.testTransactionalEdits({
+        post1ref: post1.ref
+      });
+      expect2(mutation2.log).toHaveLength(1);
+      expect2(mutation2.log[0][1]).toBe("delete");
+      expect2(() => adapter1.testTransactionalEdits({
+        post2ref: post2.ref
+      })).toThrow(BadRequestError);
+    });
+  });
+  describe("OrgSettings singleton", () => {
+    let adapter;
+    beforeAll(async () => {
+      adapter = await createAdapter();
+    });
+    test("create returns bare-name ref", async () => {
+      const [orgSettings] = await adapter.createOrgSettings({
+        name: "Acme",
+        theme: "dark",
+        primaryAdmin: "User/42"
+      });
+      expect2(orgSettings.ref).toBe("OrgSettings");
+      expect2(orgSettings.entity).toBe("OrgSettings");
+      expect2(orgSettings.data.name).toBe("Acme");
+      expect2(orgSettings.parents.primaryAdmin).toBe("User/42");
+      expect2(orgSettings.children.featuredPosts).toStrictEqual([]);
+    });
+    test("read by bare-name ref", async () => {
+      const orgSettings = await adapter.readOrgSettings();
+      expect2(orgSettings.ref).toBe("OrgSettings");
+      expect2(orgSettings.data.name).toBe("Acme");
+    });
+    test("second create throws ConflictError", async () => {
+      expect2(() => adapter.createOrgSettings({ name: "Other" })).toThrow(ConflictError);
+    });
+    test("patch + debounce collapses mutations", async () => {
+      const [, mutation1] = await adapter.updateOrgSettingsName({
+        name: "Acme Co"
+      });
+      const [updated, mutation2] = await adapter.updateOrgSettingsName({
+        name: "Acme Inc"
+      });
+      expect2(updated.data.name).toBe("Acme Inc");
+      expect2(mutation1.ref).toBe(mutation2.ref);
+      expect2(mutation2.debounceCount).toBeGreaterThanOrEqual(1);
+    });
+    test("debounce does not collapse across identities", async () => {
+      const sharedEngineArgs = await generateArgs();
+      const adapterA = await createAdapter({
+        session: { identityRef: "User/A" },
+        engineArgs: sharedEngineArgs
+      });
+      const adapterB = await createAdapter({
+        session: { identityRef: "User/B" },
+        engineArgs: sharedEngineArgs
+      });
+      await adapterA.createOrgSettings({ name: "Acme" });
+      const [, mutationA] = await adapterA.updateOrgSettingsName({
+        name: "From A"
+      });
+      const [, mutationB] = await adapterB.updateOrgSettingsName({
+        name: "From B"
+      });
+      expect2(mutationA.ref).not.toBe(mutationB.ref);
+      expect2(mutationA.identityRef).toBe("User/A");
+      expect2(mutationB.identityRef).toBe("User/B");
+      await adapterA.deleteOrgSettings();
+    });
+    test("delete removes the singleton", async () => {
+      const [count] = await adapter.deleteOrgSettings();
+      expect2(count).toBe(1);
+      expect2(() => adapter.readOrgSettings()).toThrow(NotFoundError3);
+    });
+    test("recreate after delete works", async () => {
+      const [orgSettings] = await adapter.createOrgSettings({
+        name: "NewOrg"
+      });
+      expect2(orgSettings.ref).toBe("OrgSettings");
+      expect2(orgSettings.data.name).toBe("NewOrg");
+    });
+    test("constructor rejects singleton + uniqueDataKeys", () => {
+      expect2(() => new Entity9("Bad", {
+        singleton: true,
+        data: z51.object({ name: z51.string() }),
+        uniqueDataKeys: ["name"]
+      })).toThrow(/singleton/);
+    });
+    test("createRef throws on unregistered entity", async () => {
+      expect2(() => adapter.createUnknownRef()).toThrow(BadRequestError);
+    });
+  });
+  describe("paging", () => {
+    let adapter;
+    let post1ref;
+    beforeAll(async () => {
+      adapter = await createAdapter();
+      const [post1] = await adapter.createPost({ title: "Post 1" });
+      post1ref = post1.ref;
+      const [user] = await adapter.createUser({ email: "foo@bar.com" });
+      const [draft1] = await adapter.createDraft({
+        postRef: post1.ref
+      });
+      const [post2] = await adapter.createPost({ title: "Post 2" });
+      const [draft2] = await adapter.createDraft({
+        postRef: post2.ref
+      });
+      const draft1adapter = adapter.changeSet(draft1.ref);
+      await draft1adapter.createBlockImage({
+        parentRef: post1.ref,
+        url: "https://example.com/image.png"
+      });
+      await draft1adapter.createBlockParagraph({
+        parentRef: post1.ref
+      });
+      await adapter.applyDraft(draft1.ref);
+      const draft2adapter = adapter.changeSet(draft2.ref);
+      await draft2adapter.createBlockImage({
+        parentRef: post2.ref,
+        url: "https://example.com/image.png"
+      });
+      await draft2adapter.createBlockParagraph({
+        parentRef: post2.ref
+      });
+      await adapter.applyDraft(draft2.ref);
+    });
+    test("limited to given collection", async () => {
+      const res = await adapter.pagePosts();
+      expect2(res).toHaveLength(2);
+    });
+    test("limit", async () => {
+      const res = await adapter.pagePosts({ size: 1 });
+      expect2(res).toHaveLength(1);
+    });
+    test("pageSplat", async () => {
+      const res = await adapter.pageSplat({});
+      expect2(res).toHaveLength(11);
+    });
+    test("pageEmptyEntitiesArray", async () => {
+      const res = await adapter.pageEmptyEntitiesArray({});
+      expect2(res).toHaveLength(0);
+    });
+    test("pageBlocks", async () => {
+      const res = await adapter.pageBlocks({});
+      expect2(res).toHaveLength(4);
+    });
+    test("pageBlocks with parent ref", async () => {
+      const res = await adapter.pageBlocks({ parentRef: post1ref });
+      expect2(res).toHaveLength(2);
+      expect2(res[0].parents.parent).toBe(post1ref);
+      expect2(res[1].parents.parent).toBe(post1ref);
+    });
+  });
+  describe("changeSet", () => {
+    let postRef, draftRef, changeSetAdapter, blockParagraph1, post, blockRow, blockParagraph2, draft;
+    beforeAll(async () => {
+      ({
+        postRef,
+        draftRef,
+        changeSetAdapter,
+        blockParagraph1,
+        post,
+        blockRow,
+        blockParagraph2,
+        draft
+      } = await prepareChangeSetTest(adapter1, adapter2));
+    });
+    test("create (createEntity function w/changeSetRef)", async () => {
+      expect2(blockParagraph1).toMatchZodSchema(BlockParagraph.schema);
+      expect2(post).toMatchZodSchema(PostEntity.schema);
+    });
+    test("read (readEntity function w/changeSetRef)", async () => {
+      const read = await changeSetAdapter.readEntity(blockParagraph1.ref);
+      expect2(read).toMatchZodSchema(BlockParagraph.schema);
+    });
+    test("update (patchEntity function w/changeSetRef)", async () => {
+      const [updatedBlock] = await changeSetAdapter.updateBlockParagraph({
+        ref: blockParagraph1.ref,
+        content: "Hello, world!"
+      });
+      expect2(updatedBlock).toMatchZodSchema(BlockParagraph.schema);
+    });
+    test("move (batchReadEntities function)", async () => {
+      const res = await changeSetAdapter.moveBlocks({
+        refs: [blockParagraph1.ref],
+        targetPosition: 1
+      });
+    });
+    test("delete (with cascade delete)", async () => {
+      const postUpdated = await changeSetAdapter.readEntity(postRef);
+      const blockParagraph1Update = await changeSetAdapter.readEntity(blockParagraph1.ref);
+      const blockRowUpdated = await changeSetAdapter.readEntity(blockRow.ref);
+      const [count, mutation] = await changeSetAdapter.deletePost(postRef);
+      expect2(count).toBe(4);
+      expect2(mutation.log).toStrictEqual([
+        [blockParagraph1.ref, "delete", blockParagraph1Update],
+        [blockParagraph2.ref, "delete", blockParagraph2],
+        [blockRow.ref, "delete", blockRowUpdated],
+        [postRef, "delete", postUpdated]
+      ]);
+      await expect2(() => changeSetAdapter.readEntity(blockParagraph1.ref)).toThrow(NotFoundError3);
+      await expect2(() => changeSetAdapter.updateBlockParagraph({
+        ref: blockParagraph1.ref,
+        content: "Foo"
+      })).toThrow(NotFoundError3);
+    });
+    test("pageMutations", async () => {
+      const res = await changeSetAdapter.pageMutations({
+        changeSetRef: draftRef
+      });
+      expect2(res.length).toBeGreaterThan(0);
+      expect2(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
+    });
+    test("pageMutations run again", async () => {
+      const res = await changeSetAdapter.pageMutations({
+        changeSetRef: draftRef
+      });
+      expect2(res.length).toBeGreaterThan(0);
+      expect2(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
+    });
+    test("invalid changeSetRef throws error", async () => {
+      const changeSetAdapter2 = adapter1.changeSet("Draft/123");
+      expect2(() => changeSetAdapter2.createPost({ title: "Title 1" })).toThrow(BadRequestError);
+    });
+    test("duplicateDraft (txn.duplicateChangeSetMutations) produces an independent copy with remapped refs", async () => {
+      const [post2] = await adapter1.createPost({
+        title: "Title 1",
+        slug: faker.lorem.slug(5)
+      });
+      const [sourceDraft] = await adapter1.createDraft({
+        postRef: post2.ref
+      });
+      const sourceCs = adapter1.changeSet(sourceDraft.ref);
+      const [{ block: row }] = await sourceCs.createBlockRow({
+        parentRef: post2.ref
+      });
+      const [{ block: para }] = await sourceCs.createBlockParagraph({
+        parentRef: row.ref,
+        content: "Hello"
+      });
+      const [{ draftRef: newDraftRef, mutations, refMap }] = await adapter1.duplicateDraft({
+        sourceRef: sourceDraft.ref,
+        postRef: post2.ref
+      });
+      expect2(mutations).toHaveLength(2);
+      const newRow = refMap.get(row.ref);
+      const newPara = refMap.get(para.ref);
+      expect2(newRow).toBeDefined();
+      expect2(newPara).toBeDefined();
+      expect2(newRow).not.toBe(row.ref);
+      expect2(newPara).not.toBe(para.ref);
+      expect2([...refMap.values()]).not.toContain(row.ref);
+      expect2([...refMap.values()]).not.toContain(para.ref);
+      const targetCs = adapter1.changeSet(newDraftRef);
+      expect2((await targetCs.readEntity(newRow)).ref).toBe(newRow);
+      expect2((await targetCs.readEntity(newPara)).parents.parent).toBe(newRow);
+      expect2((await sourceCs.readEntity(para.ref)).parents.parent).toBe(row.ref);
+    });
+    test("duplicateDraft when a source op reads the changeSet root (one-transaction, pending target root)", async () => {
+      const [post2] = await adapter1.createPost({
+        title: "Title 1",
+        slug: faker.lorem.slug(5)
+      });
+      const [sourceDraft] = await adapter1.createDraft({
+        postRef: post2.ref
+      });
+      await adapter1.changeSet(sourceDraft.ref).createBlockRowReadingRoot({ parentRef: post2.ref });
+      const [{ draftRef: newDraftRef, mutations, refMap }] = await adapter1.duplicateDraft({
+        sourceRef: sourceDraft.ref,
+        postRef: post2.ref
+      });
+      expect2(mutations).toHaveLength(1);
+      expect2(mutations[0].operation.name).toBe("createBlockRowReadingRoot");
+      const newRow = [...refMap.values()][0];
+      expect2(newRow).toBeDefined();
+      const targetCs = adapter1.changeSet(newDraftRef);
+      expect2((await targetCs.readEntity(newRow)).ref).toBe(newRow);
+    });
+    test("deleteBlocks (patch running 2 times removing on array element every time)", async () => {
+      const [post2, createPostMutation] = await adapter1.createPost({
+        title: "Title 1",
+        slug: faker.lorem.slug(5),
+        tags: ["Foo", "Bar"]
+      });
+      const [draft2, createDraftMutation] = await adapter1.createDraft({
+        postRef: post2.ref
+      });
+      const changeSetAdapter2 = adapter1.changeSet(draft2.ref);
+      const [{ block: blockParagraph12 }, createBlockParagraph1Mutation] = await changeSetAdapter2.createBlockParagraph({
+        parentRef: post2.ref
+      });
+      const [{ block: blockParagraph22 }, createBlockParagraph2Mutation] = await changeSetAdapter2.createBlockParagraph({
+        parentRef: post2.ref
+      });
+      const readPost2 = await changeSetAdapter2.readEntity(post2.ref);
+      expect2(readPost2.children.blocks).toEqual([
+        blockParagraph12.ref,
+        blockParagraph22.ref
+      ]);
+      const [, deleteMutation] = await changeSetAdapter2.deleteBlocks([
+        blockParagraph12.ref,
+        blockParagraph22.ref
+      ]);
+      expect2(deleteMutation.log[0][2].children.blocks).toEqual([
+        blockParagraph12.ref,
+        blockParagraph22.ref
+      ]);
+      expect2(deleteMutation.log[0][2].updated.mutationRef).toBe(createBlockParagraph2Mutation.ref);
+      const readPost22 = await changeSetAdapter2.readEntity(post2.ref);
+      expect2(readPost22.updated.mutationRef).toEqual(deleteMutation.ref);
+    });
+    test("applyDraft", async () => {
+      const { draftRef: draftRef2, post: post2, changeSetAdapter: changeSetAdapter2 } = await prepareChangeSetTest(adapter1);
+      const [version, mutation] = await adapter1.applyDraft(draftRef2);
+      expect2(() => changeSetAdapter2.createBlockImage({
+        parentRef: post2.ref,
+        url: "https://example.com/image.png"
+      })).toThrowError("The provided changeSetRef has already been applied");
+    });
+    test("deleteDraft", async () => {
+      const { draftRef: draftRef2 } = await prepareChangeSetTest(adapter1);
+      const mutationsBefore = await adapter1.pageMutations({
+        changeSetRef: draftRef2
+      });
+      const [, mutation] = await adapter1.deleteDraft(draftRef2);
+      expect2(mutation.log).toHaveLength(mutationsBefore.length + 1);
+      const mutationsAfter = await adapter1.pageMutations({
+        changeSetRef: draftRef2
+      });
+      expect2(mutationsAfter).toHaveLength(0);
+    });
+    test("init adapter2", async () => {
+      const adapterA = await createAdapter({ optimistic: true });
+      const adapterB = await createAdapter({ optimistic: true });
+      const { draftRef: draftRef2 } = await prepareChangeSetTest(adapterA, adapterB);
+      const mutations = await adapterA.pageMutations({
+        changeSetRef: draftRef2
+      });
+      const allMutationsAdapter1 = await adapterA.pageMutations({});
+      const allMutationsAdapter2 = await adapterB.pageMutations({});
+      expect2(allMutationsAdapter1).not.toBeEmpty();
+      expect2(allMutationsAdapter2).toBeEmpty();
+      const res = await adapterB.loadMutations(allMutationsAdapter1);
+      const allMutationsAdapter2after = await adapterB.pageMutations({});
+      expect2(allMutationsAdapter2after.length).toBe(allMutationsAdapter1.length);
+      const res2 = await adapterB.loadMutations(allMutationsAdapter1);
+    });
+    test("persisted at", async () => {
+      const adapterA = await createAdapter({ optimistic: false });
+      const adapterB = await createAdapter({ optimistic: true });
+      const [, mutationNonOptimistic] = await adapterA.createPost({
+        title: "Foo"
+      });
+      expect2(mutationNonOptimistic.persistedAt).toBeDefined();
+      expect2(mutationNonOptimistic.persistedAt).toBe(mutationNonOptimistic.timestamp);
+      const [, mutationOptimistic] = await adapterB.createPost({
+        title: "Foo"
+      });
+      expect2(mutationOptimistic.persistedAt).toBeNull();
+      const [mutationOptimisticPersisted] = await adapterA.persistOptimisticMutations([mutationOptimistic]);
+      expect2(mutationOptimisticPersisted.persistedAt).toBeString();
+    });
+    test("persistOptimisticMutations", async () => {
+      const persistedAdapter = await createAdapter({ optimistic: false });
+      const optimisticAdapter = await createAdapter({ optimistic: true });
+      expect2(persistedAdapter.persistOptimisticMutations).toBeDefined();
+      expect2(optimisticAdapter.loadMutations).toBeDefined();
+      const [post2, createPostMutation] = await optimisticAdapter.createPost({
+        title: "Foo",
+        slug: faker.lorem.slug(5),
+        tags: []
+      });
+      const [persistCratePostMutation] = await persistedAdapter.persistOptimisticMutations([
+        createPostMutation
+      ]);
+      expect2(persistCratePostMutation.persistedAt >= createPostMutation.timestamp).toBeTrue();
+      const readMutation2 = await persistedAdapter.readMutation(persistCratePostMutation.ref);
+      expect2(readMutation2).toStrictEqual(persistCratePostMutation);
+      const [draft2, { persistedAt: ignore, ...createDraftMutation }] = await optimisticAdapter.createDraft({
+        postRef: post2.ref
+      });
+      const [{ persistedAt, ...persistedCreateDraftMutation }] = await persistedAdapter.persistOptimisticMutations([
+        createDraftMutation
+      ]);
+      expect2(persistedCreateDraftMutation).toStrictEqual(createDraftMutation);
+      const changeSetAdapter2 = optimisticAdapter.changeSet(draft2.ref);
+      const [res] = await changeSetAdapter2.createBlockParagraph({
+        parentRef: post2.ref
+      });
+    });
+  });
 };
 // src/inMemoryAdapter.ts
 import { createInMemoryAdapter } from "@roc-db/in-memory";
 var inMemoryAdapter = createInMemoryAdapter({
   operations,
-  entities
+  entities,
+  session: {
+    identityRef: "User/42"
+  }
 });
 export {
   testAdapterImplementation,