@roc-db/test-utils 0.2.0-pre.102 → 0.2.0-pre.103

package/dist/index.js

@@ -21,7 +21,8 @@ import { entitySchemaGenerator as entitySchemaGenerator2 } from "roc-db";
 import { z as z2 } from "zod";
 var BlockParagraphSchema = entitySchemaGenerator2("BlockParagraph", {
   data: z2.object({
-    content: z2.string().optional()
+    content: z2.string().optional(),
+    mentions: z2.array(z2.string()).optional()
   }),
   parents: z2.object({
     parent: PostRefSchema
@@ -168,7 +169,8 @@ var BlockRefSchema = z13.union([
 // src/entities/BlockParagraph.ts
 var BlockParagraph = new Entity4("BlockParagraph", {
   data: z14.object({
-    content: z14.string().optional()
+    content: z14.string().optional(),
+    mentions: z14.array(z14.string()).optional()
   }),
   parents: z14.object({
     parent: z14.union([PostEntity.refSchema, BlockRefSchema])
@@ -440,29 +442,62 @@ var deleteDraft = writeOperation13("deleteDraft", DraftRefSchema, (txn) => {
   return QueryChain6(Query13(() => txn.deleteEntity(ref, true)), Query13(() => txn.deleteChangeSet(ref)));
 });
 
-// src/operations/deleteOrgSettings.ts
-import { Query as Query14, writeOperation as writeOperation14 } from "roc-db";
+// src/operations/deleteUnmentionedBlockParagraph.ts
+import { BadRequestError, Query as Query14, QueryChain as QueryChain7, writeOperation as writeOperation14 } from "roc-db";
 import { z as z30 } from "zod";
-var deleteOrgSettings = writeOperation14("deleteOrgSettings", z30.object({}).optional(), (txn) => Query14(() => txn.deleteEntity("OrgSettings")));
+var deleteUnmentionedBlockParagraph = writeOperation14("deleteUnmentionedBlockParagraph", z30.object({
+  ref: BlockParagraphRefSchema,
+  mentionedByRef: BlockParagraphRefSchema
+}).strict(), (txn) => {
+  const { ref, mentionedByRef } = txn.payload;
+  return QueryChain7(Query14(() => txn.readEntity(mentionedByRef)), Query14((mentionedBy) => {
+    if (mentionedBy.data.mentions?.includes(ref)) {
+      throw new BadRequestError("Delete not allowed. Paragraph is mentioned");
+    }
+    return txn.readEntity(ref);
+  }), Query14((block) => txn.readEntity(block.parents.parent)), Query14((parent) => txn.patchEntity(parent.ref, {
+    children: {
+      blocks: parent.children.blocks.filter((blockRef) => blockRef !== ref)
+    }
+  })), Query14(() => txn.deleteEntity(ref)));
+}, { changeSetOnly: true });
+
+// src/operations/duplicateBlockParagraph.ts
+import { Query as Query15, QueryChain as QueryChain8, writeOperation as writeOperation15 } from "roc-db";
+import { z as z31 } from "zod";
+var duplicateBlockParagraph = writeOperation15("duplicateBlockParagraph", z31.object({ ref: BlockParagraphRefSchema }).strict(), (txn) => {
+  const copyRef = txn.createRef("BlockParagraph");
+  return QueryChain8(Query15(() => txn.readEntity(txn.payload.ref)), Query15((source) => txn.readEntity(source.parents.parent)), Query15((parent) => txn.patchEntity(parent.ref, {
+    children: { blocks: [...parent.children.blocks, copyRef] }
+  })), Query15((_parent, _readParent, source) => txn.createEntity(copyRef, {
+    parents: source.parents,
+    data: source.data
+  })));
+}, { changeSetOnly: true, outputSchema: BlockParagraphSchema });
+
+// src/operations/deleteOrgSettings.ts
+import { Query as Query16, writeOperation as writeOperation16 } from "roc-db";
+import { z as z32 } from "zod";
+var deleteOrgSettings = writeOperation16("deleteOrgSettings", z32.object({}).optional(), (txn) => Query16(() => txn.deleteEntity("OrgSettings")));
 
 // src/operations/deletePost.ts
-import { Query as Query15, writeOperation as writeOperation15 } from "roc-db";
-var deletePost = writeOperation15("deletePost", PostRefSchema, (txn) => {
+import { Query as Query17, writeOperation as writeOperation17 } from "roc-db";
+var deletePost = writeOperation17("deletePost", PostRefSchema, (txn) => {
   const ref = txn.payload;
-  return Query15(() => txn.deleteEntity(ref, true));
+  return Query17(() => txn.deleteEntity(ref, true));
 });
 
 // src/operations/duplicateDraft.ts
 import {
-  Query as Query16,
-  QueryChain as QueryChain7,
-  writeOperation as writeOperation16
+  Query as Query18,
+  QueryChain as QueryChain9,
+  writeOperation as writeOperation18
 } from "roc-db";
-import { z as z31 } from "zod";
-var duplicateDraft = writeOperation16("duplicateDraft", z31.object({ sourceRef: DraftRefSchema, postRef: PostRefSchema }).strict(), (txn) => {
+import { z as z33 } from "zod";
+var duplicateDraft = writeOperation18("duplicateDraft", z33.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) => {
+  return QueryChain9(Query18(() => txn.createEntity(newDraftRef, { parents: { post: postRef } })), Query18(() => txn.duplicateChangeSetMutations(sourceRef, newDraftRef)), Query18((dup) => {
     const result = dup;
     return {
       draftRef: newDraftRef,
@@ -473,28 +508,28 @@ var duplicateDraft = writeOperation16("duplicateDraft", z31.object({ sourceRef:
 });
 
 // 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)
+import { Query as Query19, QueryChain as QueryChain10, writeOperation as writeOperation19 } from "roc-db";
+import { z as z34 } from "zod";
+var PayloadSchema3 = z34.object({
+  refs: z34.array(z34.union([BlockParagraphRefSchema, BlockRowRefSchema])),
+  targetPosition: z34.number().min(0)
 }).strict();
-var moveBlocks = writeOperation17("moveBlocks", PayloadSchema3, (txn) => {
+var moveBlocks = writeOperation19("moveBlocks", PayloadSchema3, (txn) => {
   const { refs } = txn.payload;
-  return QueryChain8(Query17(() => txn.batchReadEntities(refs)), Query17((items) => {
+  return QueryChain10(Query19(() => txn.batchReadEntities(refs)), Query19((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()
+import { Query as Query20, readOperation } from "roc-db";
+import { z as z35 } from "zod";
+var pageBlocks = readOperation("pageBlocks", z35.object({
+  size: z35.number().default(100),
+  parentRef: z35.string().optional()
 }), (txn) => {
   const { size, parentRef } = txn.payload;
-  return Query18(() => txn.pageEntities({
+  return Query20(() => txn.pageEntities({
     entities: ["BlockImage", "BlockParagraph"],
     size,
     childrenOf: parentRef ? [parentRef] : []
@@ -502,50 +537,50 @@ var pageBlocks = readOperation("pageBlocks", z33.object({
 });
 
 // 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) => {
+import { Query as Query21, readOperation as readOperation2 } from "roc-db";
+import { z as z36 } from "zod";
+var pageEmptyEntitiesArray = readOperation2("pageEmptyEntitiesArray", z36.object({ size: z36.number().default(100) }), (txn) => {
   const { size } = txn.payload;
-  return Query19(() => txn.pageEntities({ entities: [], size }));
+  return Query21(() => 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) => {
+import { Query as Query22, readOperation as readOperation3 } from "roc-db";
+import { z as z37 } from "zod";
+var pagePosts = readOperation3("pagePosts", z37.object({ size: z37.number().default(100) }).default({}), (txn) => {
   const { size } = txn.payload;
-  return Query20(() => txn.pageEntities({ entities: ["Post"], size }));
+  return Query22(() => 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) => {
+import { Query as Query23, readOperation as readOperation4 } from "roc-db";
+import { z as z38 } from "zod";
+var pageSplat = readOperation4("pageSplat", z38.object({ size: z38.number().default(100) }), (txn) => {
   const { size } = txn.payload;
-  return Query21(() => txn.pageEntities({ entities: "*", size }));
+  return Query23(() => 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) => {
+import { Query as Query24, readOperation as readOperation5 } from "roc-db";
+import { z as z39 } from "zod";
+var pagePostsByTag = readOperation5("pagePostsByTag", z39.string(), (txn) => {
   const tag = txn.payload;
-  return Query22(() => txn.pageEntitiesByIndex("Post", "tags", tag));
+  return Query24(() => txn.pageEntitiesByIndex("Post", "tags", tag));
 });
 
 // src/operations/readEntity.ts
-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) => {
+import { NotFoundError, Query as Query25, QueryChain as QueryChain11, readOperation as readOperation6 } from "roc-db";
+import { z as z40 } from "zod";
+var readEntity = readOperation6("readEntity", z40.string(), (txn) => {
   const ref = txn.payload;
-  return QueryChain9(Query23(() => txn.readEntity(ref)), Query23((entity) => {
+  return QueryChain11(Query25(() => txn.readEntity(ref)), Query25((entity) => {
     if (!entity) {
       throw new NotFoundError(ref);
     }
     return entity;
   }));
 }, {
-  outputSchema: z38.union([
+  outputSchema: z40.union([
     PostSchema,
     BlockImageSchema,
     BlockParagraphSchema
@@ -553,11 +588,11 @@ var readEntity = readOperation6("readEntity", z38.string(), (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) => {
+import { NotFoundError as NotFoundError2, Query as Query26, QueryChain as QueryChain12, readOperation as readOperation7 } from "roc-db";
+import { z as z41 } from "zod";
+var readMutation = readOperation7("readMutation", z41.string(), (txn) => {
   const ref = txn.payload;
-  return QueryChain10(Query24(() => txn.readMutation(ref)), Query24((entity) => {
+  return QueryChain12(Query26(() => txn.readMutation(ref)), Query26((entity) => {
     if (!entity) {
       throw new NotFoundError2(ref);
     }
@@ -566,57 +601,57 @@ var readMutation = readOperation7("readMutation", z39.string(), (txn) => {
 });
 
 // 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)));
+import { Query as Query27, readOperation as readOperation8 } from "roc-db";
+import { z as z42 } from "zod";
+var readOrgSettings = readOperation8("readOrgSettings", z42.object({}).optional(), (txn) => Query27(() => txn.readEntity("OrgSettings", true)));
 
 // src/operations/readPost.ts
-import { Query as Query26, readOperation as readOperation9 } from "roc-db";
+import { Query as Query28, readOperation as readOperation9 } from "roc-db";
 var readPost = readOperation9("readPost", PostRefSchema, (txn) => {
   const ref = txn.payload;
-  return Query26(() => txn.readEntity(ref, true));
+  return Query28(() => 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) => {
+import { Query as Query29, readOperation as readOperation10 } from "roc-db";
+import { z as z43 } from "zod";
+var readPostBySlug = readOperation10("readPostBySlug", z43.string(), (txn) => {
   const slug = txn.payload;
-  return Query27(() => txn.readEntityByUniqueField("Post", "slug", slug));
+  return Query29(() => 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";
+import { Query as Query30, QueryChain as QueryChain13, writeOperation as writeOperation20 } from "roc-db";
+import { z as z44 } from "zod";
 var TestCreatePatchDeleteInSameTransaction = (txn, title) => {
   const postRef = txn.createRef("Post");
-  return QueryChain11(Query28(() => txn.createEntity(postRef, {
+  return QueryChain13(Query30(() => txn.createEntity(postRef, {
     data: { title, tags: [] },
     children: { blocks: [] }
-  })), Query28(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query28((post) => {
+  })), Query30(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query30((post) => {
     expect(post.data.title).toBe(title);
     expect(post.data.foo).toBe("bar");
-  }), Query28(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query28((post) => {
+  }), Query30(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query30((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) => {
+  }), Query30((post) => txn.deleteEntity(postRef)), Query30((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) => {
+  return QueryChain13(Query30(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query30((post) => {
     expect(post.data.foo).toBe("bar");
-  }), Query28(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query28((post) => {
+  }), Query30(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query30((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) => {
+  }), Query30((post) => txn.deleteEntity(ref)), Query30((res) => {
     expect(res).toBe(1);
     expect(txn.log).toHaveLength(1);
     expect(txn.log.get(ref)?.[0]).toBe("delete");
@@ -624,14 +659,14 @@ var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
 };
 var TestCreateOnExistingRef = (txn) => {
   const ref = txn.createRef("Post");
-  return QueryChain11(Query28(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query28(() => txn.createEntity(ref, { data: { foo: "bar" } })));
+  return QueryChain13(Query30(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query30(() => txn.createEntity(ref, { data: { foo: "bar" } })));
 };
-var PayloadSchema4 = z42.object({
-  name: z42.string().optional(),
+var PayloadSchema4 = z44.object({
+  name: z44.string().optional(),
   post1ref: PostRefSchema.optional(),
   post2ref: PostRefSchema.optional()
 }).strict();
-var testTransactionalEdits = writeOperation18("testTransactionalEdits", PayloadSchema4, (txn) => {
+var testTransactionalEdits = writeOperation20("testTransactionalEdits", PayloadSchema4, (txn) => {
   const { name, post1ref, post2ref } = txn.payload;
   if (name)
     return TestCreatePatchDeleteInSameTransaction(txn, name);
@@ -642,38 +677,56 @@ var testTransactionalEdits = writeOperation18("testTransactionalEdits", PayloadS
 }, {});
 
 // src/operations/updateBlockParagraph.ts
-import { Query as Query29, writeOperation as writeOperation19 } from "roc-db";
-import { z as z43 } from "zod";
-var updateBlockParagraph = writeOperation19("updateBlockParagraph", z43.object({
+import { Query as Query31, writeOperation as writeOperation21 } from "roc-db";
+import { z as z45 } from "zod";
+var updateBlockParagraph = writeOperation21("updateBlockParagraph", z45.object({
   ref: BlockParagraphRefSchema,
-  content: z43.string()
+  content: z45.string()
 }), (txn) => {
   const { ref, content } = txn.payload;
-  return Query29(() => txn.patchEntity(ref, {
+  return Query31(() => txn.patchEntity(ref, {
     data: { content }
   }));
 }, { outputSchema: BlockParagraphSchema });
 
+// src/operations/updateBlockParagraphMentions.ts
+import {
+  Query as Query32,
+  QueryChain as QueryChain14,
+  writeOperation as writeOperation22
+} from "roc-db";
+import { z as z46 } from "zod";
+var PayloadSchema5 = z46.object({
+  ref: BlockParagraphRefSchema,
+  mentions: z46.array(BlockParagraphRefSchema)
+}).strict();
+var setMentions = (txn) => {
+  const { ref, mentions } = txn.payload;
+  return QueryChain14(...mentions.map((mention) => Query32(() => txn.readEntity(mention))), Query32(() => txn.patchEntity(ref, { data: { mentions } })));
+};
+var updateBlockParagraphMentions = writeOperation22("updateBlockParagraphMentions", PayloadSchema5, setMentions, { debounce: 10, changeSetOnly: true, outputSchema: BlockParagraphSchema });
+var setBlockParagraphMentions = writeOperation22("setBlockParagraphMentions", PayloadSchema5, setMentions, { changeSetOnly: true, 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) => {
+import { Query as Query33, writeOperation as writeOperation23 } from "roc-db";
+import { z as z47 } from "zod";
+var updateOrgSettingsName = writeOperation23("updateOrgSettingsName", z47.object({ name: z47.string() }), (txn) => {
   const { name } = txn.payload;
-  return Query30(() => txn.patchEntity("OrgSettings", { data: { name } }));
+  return Query33(() => txn.patchEntity("OrgSettings", { data: { name } }));
 }, { debounce: 10 });
 
 // src/operations/updatePost.ts
-import { Query as Query31, writeOperation as writeOperation21 } from "roc-db";
-import { z as z45 } from "zod";
-var PayloadSchema5 = z45.object({
+import { Query as Query34, writeOperation as writeOperation24 } from "roc-db";
+import { z as z48 } from "zod";
+var PayloadSchema6 = z48.object({
   ref: PostRefSchema,
-  title: z45.string().optional(),
-  tags: z45.array(z45.string()).optional().default([]),
+  title: z48.string().optional(),
+  tags: z48.array(z48.string()).optional().default([]),
   authorRef: UserRefSchema.optional()
 });
-var updatePost = writeOperation21("updatePost", PayloadSchema5, (txn) => {
+var updatePost = writeOperation24("updatePost", PayloadSchema6, (txn) => {
   const { ref, authorRef, ...data } = txn.payload;
-  return Query31(() => txn.updateEntity(ref, {
+  return Query34(() => txn.updateEntity(ref, {
     data,
     parents: { author: authorRef },
     children: { blocks: [] }
@@ -681,43 +734,43 @@ var updatePost = writeOperation21("updatePost", PayloadSchema5, (txn) => {
 }, { 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) => {
+import { Query as Query35, writeOperation as writeOperation25 } from "roc-db";
+import { z as z49 } from "zod";
+var updatePostDescription = writeOperation25("updatePostDescription", z49.object({ ref: PostRefSchema, description: z49.string() }), (txn) => {
   const { ref, description } = txn.payload;
-  return Query32(() => txn.patchEntity(ref, { data: { description } }));
+  return Query35(() => 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) => {
+import { Query as Query36, writeOperation as writeOperation26 } from "roc-db";
+import { z as z50 } from "zod";
+var updatePostSlug = writeOperation26("updatePostSlug", z50.object({ ref: PostRefSchema, slug: z50.string() }), (txn) => {
   const { ref, slug } = txn.payload;
-  return Query33(() => txn.patchEntity(ref, { data: { slug } }));
+  return Query36(() => 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) => {
+import { Query as Query37, writeOperation as writeOperation27 } from "roc-db";
+import { z as z51 } from "zod";
+var updatePostTags = writeOperation27("updatePostTags", z51.object({ ref: PostRefSchema, tags: z51.array(z51.string()) }), (txn) => {
   const { ref, tags } = txn.payload;
-  return Query34(() => txn.patchEntity(ref, { data: { tags } }));
+  return Query37(() => txn.patchEntity(ref, { data: { tags } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/updatePostTitle.ts
-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) => {
+import { Query as Query38, writeOperation as writeOperation28 } from "roc-db";
+import { z as z52 } from "zod";
+var updatePostTitle = writeOperation28("updatePostTitle", z52.object({ ref: PostRefSchema, title: z52.string() }), (txn) => {
   const { ref, title } = txn.payload;
-  return Query35(() => txn.patchEntity(ref, { data: { title } }));
+  return Query38(() => 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) => {
+import { Query as Query39, QueryChain as QueryChain15, writeOperation as writeOperation29 } from "roc-db";
+import { z as z53 } from "zod";
+var crudBySlug = writeOperation29("crudBySlug", z53.object({ slug: z53.string(), newSlug: z53.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 QueryChain15(Query39(() => txn.readEntityByUniqueField("Post", "slug", slug)), Query39((post) => txn.patchEntity(post.ref, { data: { slug: newSlug } })), Query39(() => txn.readEntityByUniqueField("Post", "slug", newSlug)), Query39((post) => txn.deleteEntity(post.ref)), Query39(() => {
     return [
       txn.readEntityByUniqueField("Post", "slug", slug, false),
       txn.readEntityByUniqueField("Post", "slug", newSlug, false)
@@ -745,6 +798,8 @@ var operations = [
   crudBySlug,
   deleteBlocks,
   deleteDraft,
+  deleteUnmentionedBlockParagraph,
+  duplicateBlockParagraph,
   deleteOrgSettings,
   deletePost,
   duplicateDraft,
@@ -761,6 +816,8 @@ var operations = [
   pageSplat,
   testTransactionalEdits,
   updateBlockParagraph,
+  updateBlockParagraphMentions,
+  setBlockParagraphMentions,
   updateOrgSettingsName,
   updatePost,
   updatePostDescription,
@@ -771,13 +828,13 @@ var operations = [
 // src/testAdapterImplementation.ts
 import { beforeAll, describe, expect as expect2, test } from "bun:test";
 import {
-  BadRequestError,
+  BadRequestError as BadRequestError2,
   ConflictError,
   Entity as Entity9,
   NotFoundError as NotFoundError3,
   Snowflake
 } from "roc-db";
-import { z as z51 } from "zod";
+import { z as z54 } from "zod";
 import { faker } from "@faker-js/faker";
 var snowflake = new Snowflake(10, 10);
 var prepareChangeSetTest = async (adapter, adapter2) => {
@@ -968,7 +1025,7 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
       expect2(() => adapter1.updatePostDescription({
         ref: postRef,
         description: "Description 1"
-      })).toThrow(BadRequestError);
+      })).toThrow(BadRequestError2);
     });
     test("delete (deleteEntity function)", async () => {
       const currentPost = await adapter1.readPost(postRef);
@@ -1025,7 +1082,7 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
       expect2(mutation2.log[0][1]).toBe("delete");
       expect2(() => adapter1.testTransactionalEdits({
         post2ref: post2.ref
-      })).toThrow(BadRequestError);
+      })).toThrow(BadRequestError2);
     });
   });
   describe("OrgSettings singleton", () => {
@@ -1101,12 +1158,12 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
     test("constructor rejects singleton + uniqueDataKeys", () => {
       expect2(() => new Entity9("Bad", {
         singleton: true,
-        data: z51.object({ name: z51.string() }),
+        data: z54.object({ name: z54.string() }),
         uniqueDataKeys: ["name"]
       })).toThrow(/singleton/);
     });
     test("createRef throws on unregistered entity", async () => {
-      expect2(() => adapter.createUnknownRef()).toThrow(BadRequestError);
+      expect2(() => adapter.createUnknownRef()).toThrow(BadRequestError2);
     });
   });
   describe("paging", () => {
@@ -1239,7 +1296,7 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
     });
     test("invalid changeSetRef throws error", async () => {
       const changeSetAdapter2 = adapter1.changeSet("Draft/123");
-      expect2(() => changeSetAdapter2.createPost({ title: "Title 1" })).toThrow(BadRequestError);
+      expect2(() => changeSetAdapter2.createPost({ title: "Title 1" })).toThrow(BadRequestError2);
     });
     test("duplicateDraft (txn.duplicateChangeSetMutations) produces an independent copy with remapped refs", async () => {
       const [post2] = await adapter1.createPost({
@@ -1431,6 +1488,329 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
       });
     });
   });
+  describe("debounce ordering", () => {
+    const tick = () => Bun.sleep(2);
+    const createSyncQueue = (server) => {
+      const queue = [];
+      return {
+        add: ([result, mutation]) => {
+          const index = queue.findIndex((m) => m.ref === mutation.ref);
+          if (index === -1)
+            queue.push(mutation);
+          else
+            queue[index] = mutation;
+          return result;
+        },
+        flush: async () => {
+          while (queue.length) {
+            await tick();
+            await server.persistOptimisticMutations([queue[0]]);
+            queue.shift();
+          }
+        }
+      };
+    };
+    const replay = async (source) => {
+      const mutations = await source.pageMutations({ size: 1000 });
+      const replayed = await createAdapter({ optimistic: true });
+      await replayed.loadMutations(mutations);
+      return replayed;
+    };
+    const setupClient = async () => {
+      const server = await createAdapter();
+      const client = await createAdapter({ optimistic: true });
+      const queue = createSyncQueue(server);
+      const post = queue.add(await client.createPost({ title: "Post", tags: [] }));
+      const draft = queue.add(await client.createDraft({ postRef: post.ref }));
+      const changeSet = client.changeSet(draft.ref);
+      const createParagraph = async () => queue.add(await changeSet.createBlockParagraph({
+        parentRef: post.ref
+      })).block;
+      const holder = await createParagraph();
+      await queue.flush();
+      return {
+        server,
+        queue,
+        post,
+        draft,
+        changeSet,
+        createParagraph,
+        holder
+      };
+    };
+    test("forward: a version that reads an entity created after the previous version syncs", async () => {
+      const { server, queue, draft, changeSet, createParagraph, holder } = await setupClient();
+      queue.add(await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: []
+      }));
+      const mentioned = await createParagraph();
+      queue.add(await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: [mentioned.ref]
+      }));
+      await queue.flush();
+      const replayed = (await replay(server)).changeSet(draft.ref);
+      const replayedHolder = await replayed.readEntity(holder.ref);
+      expect2(replayedHolder.data.mentions).toEqual([mentioned.ref]);
+    });
+    test("reverse: a version that frees an entity before it is deleted replays", async () => {
+      const {
+        server,
+        queue,
+        post,
+        draft,
+        changeSet,
+        createParagraph,
+        holder
+      } = await setupClient();
+      const first = await createParagraph();
+      const second = await createParagraph();
+      const third = await createParagraph();
+      queue.add(await changeSet.setBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: [first.ref]
+      }));
+      await queue.flush();
+      queue.add(await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: [second.ref]
+      }));
+      await queue.flush();
+      queue.add(await changeSet.deleteUnmentionedBlockParagraph({
+        ref: first.ref,
+        mentionedByRef: holder.ref
+      }));
+      await queue.flush();
+      queue.add(await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: [third.ref]
+      }));
+      await queue.flush();
+      const replayed = (await replay(server)).changeSet(draft.ref);
+      const replayedHolder = await replayed.readEntity(holder.ref);
+      expect2(replayedHolder.data.mentions).toEqual([third.ref]);
+      const replayedPost = await replayed.readEntity(post.ref);
+      expect2(replayedPost.children.blocks).not.toContain(first.ref);
+    });
+    test("copy: an entity copied between two versions keeps the version it copied", async () => {
+      const { server, queue, draft, changeSet, createParagraph, holder } = await setupClient();
+      const first = await createParagraph();
+      const second = await createParagraph();
+      queue.add(await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: [first.ref]
+      }));
+      await queue.flush();
+      const copy = queue.add(await changeSet.duplicateBlockParagraph({ ref: holder.ref }));
+      await queue.flush();
+      queue.add(await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: [second.ref]
+      }));
+      await queue.flush();
+      expect2(copy.data.mentions).toEqual([first.ref]);
+      const replayed = (await replay(server)).changeSet(draft.ref);
+      const replayedCopy = await replayed.readEntity(copy.ref);
+      expect2(replayedCopy.data.mentions).toEqual([first.ref]);
+      const replayedHolder = await replayed.readEntity(holder.ref);
+      expect2(replayedHolder.data.mentions).toEqual([second.ref]);
+    });
+    test("server-side: non-optimistic versions around another write replay", async () => {
+      const server = await createAdapter();
+      const [post] = await server.createPost({ title: "Post", tags: [] });
+      const [draft] = await server.createDraft({ postRef: post.ref });
+      const changeSet = server.changeSet(draft.ref);
+      const [{ block: holder }] = await changeSet.createBlockParagraph({
+        parentRef: post.ref
+      });
+      await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: []
+      });
+      await tick();
+      const [{ block: mentioned }] = await changeSet.createBlockParagraph({ parentRef: post.ref });
+      await tick();
+      await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: [mentioned.ref]
+      });
+      await changeSet.createBlockParagraph({ parentRef: post.ref });
+      const replayed = (await replay(server)).changeSet(draft.ref);
+      const replayedHolder = await replayed.readEntity(holder.ref);
+      expect2(replayedHolder.data.mentions).toEqual([mentioned.ref]);
+    });
+    test("old client: merged versions whose row is no longer last persist once and replay", async () => {
+      const {
+        server,
+        queue,
+        post,
+        draft,
+        changeSet,
+        createParagraph,
+        holder
+      } = await setupClient();
+      const first = await createParagraph();
+      const second = await createParagraph();
+      const third = await createParagraph();
+      queue.add(await changeSet.setBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: [first.ref]
+      }));
+      const [, versionMutation] = await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: [second.ref]
+      });
+      queue.add([undefined, versionMutation]);
+      queue.add(await changeSet.deleteUnmentionedBlockParagraph({
+        ref: first.ref,
+        mentionedByRef: holder.ref
+      }));
+      await queue.flush();
+      const mergedPayload = { ref: holder.ref, mentions: [third.ref] };
+      await tick();
+      const resentTimestamp = new Date().toISOString();
+      await server.persistOptimisticMutations([
+        {
+          ...versionMutation,
+          payload: mergedPayload,
+          debounceCount: versionMutation.debounceCount + 1,
+          timestamp: resentTimestamp
+        }
+      ]);
+      await expect2((async () => server.persistOptimisticMutations([
+        {
+          ...versionMutation,
+          payload: mergedPayload,
+          debounceCount: versionMutation.debounceCount + 1,
+          timestamp: resentTimestamp
+        }
+      ]))()).rejects.toThrow("Mutation already synced");
+      await tick();
+      const finalPayload = { ref: holder.ref, mentions: [] };
+      await server.persistOptimisticMutations([
+        {
+          ...versionMutation,
+          payload: finalPayload,
+          debounceCount: versionMutation.debounceCount + 2,
+          timestamp: new Date().toISOString()
+        }
+      ]);
+      const stored = await server.pageMutations({ size: 1000 });
+      const versions = stored.filter((m) => m.operation.name === "updateBlockParagraphMentions");
+      expect2(versions).toHaveLength(2);
+      expect2(versions.map((m) => m.payload)).toContainEqual({
+        ref: holder.ref,
+        mentions: [second.ref]
+      });
+      expect2(versions.map((m) => m.payload)).toContainEqual(finalPayload);
+      const replayed = (await replay(server)).changeSet(draft.ref);
+      const replayedHolder = await replayed.readEntity(holder.ref);
+      expect2(replayedHolder.data.mentions).toEqual([]);
+      const replayedPost = await replayed.readEntity(post.ref);
+      expect2(replayedPost.children.blocks).not.toContain(first.ref);
+    });
+    test("old client: a merged version and a write depending on it in one batch replay in order", async () => {
+      const { server, queue, draft, changeSet, createParagraph, holder } = await setupClient();
+      const first = await createParagraph();
+      const second = await createParagraph();
+      const [, versionMutation] = await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: [first.ref]
+      });
+      queue.add([undefined, versionMutation]);
+      await queue.flush();
+      await createParagraph();
+      await queue.flush();
+      await tick();
+      const [, version] = await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: [second.ref]
+      });
+      const mergedVersion = {
+        ...versionMutation,
+        payload: version.payload,
+        debounceCount: versionMutation.debounceCount + 1,
+        timestamp: version.timestamp
+      };
+      await tick();
+      const [, deleteMutation] = await changeSet.deleteUnmentionedBlockParagraph({
+        ref: first.ref,
+        mentionedByRef: holder.ref
+      });
+      await tick();
+      await server.persistOptimisticMutations([
+        mergedVersion,
+        deleteMutation
+      ]);
+      const replayed = (await replay(server)).changeSet(draft.ref);
+      const replayedHolder = await replayed.readEntity(holder.ref);
+      expect2(replayedHolder.data.mentions).toEqual([second.ref]);
+    });
+    test("consecutive versions coalesce into the row after an intervening write", async () => {
+      const { changeSet, createParagraph, holder } = await setupClient();
+      const [, version1] = await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: []
+      });
+      await tick();
+      const mentioned = await createParagraph();
+      await tick();
+      const [, version2] = await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: [mentioned.ref]
+      });
+      const [, version3] = await changeSet.updateBlockParagraphMentions({
+        ref: holder.ref,
+        mentions: []
+      });
+      expect2(version2.ref).not.toBe(version1.ref);
+      expect2(version3.ref).toBe(version2.ref);
+      expect2(version3.debounceCount).toBe(version2.debounceCount + 1);
+    });
+    test("another identity's write in the changeSet, or the identity's own write elsewhere, ends coalescing", async () => {
+      const engineArgs = await generateArgs();
+      const adapterA = await createAdapter({
+        session: { identityRef: "User/A" },
+        engineArgs
+      });
+      const adapterB = await createAdapter({
+        session: { identityRef: "User/B" },
+        engineArgs
+      });
+      const [post] = await adapterA.createPost({
+        title: "Post",
+        tags: []
+      });
+      const [draft] = await adapterA.createDraft({ postRef: post.ref });
+      const changeSetA = adapterA.changeSet(draft.ref);
+      const changeSetB = adapterB.changeSet(draft.ref);
+      const [{ block: holder }] = await changeSetA.createBlockParagraph({
+        parentRef: post.ref
+      });
+      const update = async () => {
+        await tick();
+        const [, mutation] = await changeSetA.updateBlockParagraphMentions({
+          ref: holder.ref,
+          mentions: []
+        });
+        return mutation;
+      };
+      const version1 = await update();
+      await tick();
+      await changeSetB.createBlockParagraph({ parentRef: post.ref });
+      const version2 = await update();
+      await tick();
+      await adapterA.createPost({ title: "Elsewhere", tags: [] });
+      const version3 = await update();
+      await tick();
+      await adapterB.createPost({ title: "Not A", tags: [] });
+      const version4 = await update();
+      expect2(version2.ref).not.toBe(version1.ref);
+      expect2(version3.ref).not.toBe(version2.ref);
+      expect2(version4.ref).toBe(version3.ref);
+    });
+  });
 };
 // src/inMemoryAdapter.ts
 import { createInMemoryAdapter } from "@roc-db/in-memory";

package/dist/types/entities/BlockParagraph.d.ts

@@ -2,6 +2,7 @@ import { Entity } from "roc-db";
 import { z } from "zod";
 export declare const BlockParagraph: Entity<"BlockParagraph", z.ZodObject<{
     content: z.ZodOptional<z.ZodString>;
+    mentions: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
     parent: z.ZodUnion<readonly [z.ZodType<`Post/${number}`, `Post/${number}`, z.core.$ZodTypeInternals<`Post/${number}`, `Post/${number}`>>, z.ZodUnion<readonly [z.ZodTemplateLiteral<`BlockParagraph/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>]>;
 }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

package/dist/types/entities/index.d.ts

@@ -18,6 +18,7 @@ export declare const entities: (import("roc-db").Entity<"Draft", import("zod").Z
     author: import("zod").ZodOptional<import("zod").ZodTemplateLiteral<`User/${number}`>>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false> | import("roc-db").Entity<"BlockParagraph", import("zod").ZodObject<{
     content: import("zod").ZodOptional<import("zod").ZodString>;
+    mentions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     parent: import("zod").ZodUnion<readonly [import("zod").ZodType<`Post/${number}`, `Post/${number}`, import("zod/v4/core").$ZodTypeInternals<`Post/${number}`, `Post/${number}`>>, import("zod").ZodUnion<readonly [import("zod").ZodTemplateLiteral<`BlockParagraph/${number}`>, import("zod").ZodTemplateLiteral<`BlockRow/${number}`>]>]>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false> | import("roc-db").Entity<"BlockRow", import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{

package/dist/types/operations/deleteUnmentionedBlockParagraph.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const deleteUnmentionedBlockParagraph: import("roc-db").WriteOperation<"deleteUnmentionedBlockParagraph", z.ZodObject<{
+    ref: z.ZodTemplateLiteral<`BlockParagraph/${number}`>;
+    mentionedByRef: z.ZodTemplateLiteral<`BlockParagraph/${number}`>;
+}, z.core.$strict>>;

package/dist/types/operations/duplicateBlockParagraph.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const duplicateBlockParagraph: import("roc-db").WriteOperation<"duplicateBlockParagraph", z.ZodObject<{
+    ref: z.ZodTemplateLiteral<`BlockParagraph/${number}`>;
+}, z.core.$strict>>;

package/dist/types/operations/updateBlockParagraphMentions.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const updateBlockParagraphMentions: import("roc-db").WriteOperation<"updateBlockParagraphMentions", z.ZodObject<{
+    ref: z.ZodTemplateLiteral<`BlockParagraph/${number}`>;
+    mentions: z.ZodArray<z.ZodTemplateLiteral<`BlockParagraph/${number}`>>;
+}, z.core.$strict>>;
+export declare const setBlockParagraphMentions: import("roc-db").WriteOperation<"setBlockParagraphMentions", z.ZodObject<{
+    ref: z.ZodTemplateLiteral<`BlockParagraph/${number}`>;
+    mentions: z.ZodArray<z.ZodTemplateLiteral<`BlockParagraph/${number}`>>;
+}, z.core.$strict>>;

package/dist/types/schemas/BlockParagraphSchema.d.ts

@@ -12,6 +12,7 @@ export declare const BlockParagraphSchema: z.ZodObject<{
     }, z.core.$strict>>;
     data: z.ZodNonOptional<z.ZodObject<{
         content: z.ZodOptional<z.ZodString>;
+        mentions: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
     children: z.ZodNonOptional<z.ZodObject<{}, z.core.$strip>>;
     parents: z.ZodNonOptional<z.ZodObject<{

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@roc-db/test-utils",
-    "version": "0.2.0-pre.102",
+    "version": "0.2.0-pre.103",
     "type": "module",
     "exports": {
         ".": {