@roc-db/test-utils 0.2.0-pre.97 → 0.2.0-pre.99

package/dist/index.js

@@ -66,12 +66,20 @@ import { z as z5 } from "zod";
 // src/entities/Draft.ts
 import { Entity } from "roc-db";
 import { z as z4 } from "zod";
+
+// src/schemas/PostVersionRefSchema.ts
+import { refSchemaGenerator as refSchemaGenerator5 } from "roc-db";
+var PostVersionRefSchema = refSchemaGenerator5("PostVersion");
+
+// src/entities/Draft.ts
 var Draft = new Entity("Draft", {
+  changeSet: true,
   data: z4.object({
     appliedAt: z4.string().optional()
   }),
   parents: z4.object({
-    post: PostRefSchema
+    post: PostRefSchema,
+    version: PostVersionRefSchema.optional()
   })
 });
 
@@ -91,8 +99,8 @@ import { entitySchemaGenerator as entitySchemaGenerator5 } from "roc-db";
 import { z as z6 } from "zod";
 
 // src/schemas/UserRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator5 } from "roc-db";
-var UserRefSchema = refSchemaGenerator5("User");
+import { refSchemaGenerator as refSchemaGenerator6 } from "roc-db";
+var UserRefSchema = refSchemaGenerator6("User");
 
 // src/schemas/PostSchema.ts
 var PostSchema = entitySchemaGenerator5("Post", {
@@ -167,8 +175,8 @@ var PostEntity = new Entity3("Post", {
 import { z as z13 } from "zod";
 
 // src/schemas/BlockRowRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator6 } from "roc-db";
-var BlockRowRefSchema = refSchemaGenerator6("BlockRow");
+import { refSchemaGenerator as refSchemaGenerator7 } from "roc-db";
+var BlockRowRefSchema = refSchemaGenerator7("BlockRow");
 
 // src/schemas/BlockRefSchema.ts
 var BlockRefSchema = z13.union([
@@ -198,25 +206,39 @@ var BlockRow = new Entity5("BlockRow", {
   })
 });
 
-// src/entities/PostVersion.ts
+// src/entities/OrgSettingsEntity.ts
 import { Entity as Entity6 } from "roc-db";
 import { z as z16 } from "zod";
-var PostVersion = new Entity6("PostVersion", {
+var OrgSettingsEntity = new Entity6("OrgSettings", {
+  singleton: true,
   data: z16.object({
-    version: z16.number(),
-    snapshot: z16.array(z16.any())
+    name: z16.string(),
+    theme: z16.string().optional()
   }),
-  parents: z16.object({ post: PostRefSchema }),
-  indexedDataKeys: ["version"],
-  uniqueDataKeys: ["slug"]
+  parents: z16.object({ primaryAdmin: UserRefSchema.optional() }),
+  children: z16.object({ featuredPosts: z16.array(z16.string()) })
 });
 
-// src/entities/UserEntity.ts
+// src/entities/PostVersion.ts
 import { Entity as Entity7 } from "roc-db";
 import { z as z17 } from "zod";
-var UserEntity = new Entity7("User", {
+var PostVersion = new Entity7("PostVersion", {
+  version: true,
   data: z17.object({
-    email: z17.string().email()
+    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"]
 });
@@ -227,6 +249,7 @@ var entities = [
   BlockParagraph,
   BlockRow,
   Draft,
+  OrgSettingsEntity,
   PostEntity,
   PostVersion,
   UserEntity
@@ -251,8 +274,8 @@ var applyDraft = writeOperation("applyDraft", DraftRefSchema, (txn) => {
 
 // src/operations/createBlockImage.ts
 import { Query as Query2, writeOperation as writeOperation2 } from "roc-db";
-import { z as z18 } from "zod";
-var createBlockImage = writeOperation2("createBlockImage", z18.object({ parentRef: PostRefSchema, url: z18.string().url() }).strict(), (txn) => {
+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, {
@@ -263,10 +286,10 @@ var createBlockImage = writeOperation2("createBlockImage", z18.object({ parentRe
 
 // src/operations/createBlockParagraph.ts
 import { Query as Query3, QueryChain as QueryChain2, writeOperation as writeOperation3 } from "roc-db";
-import { z as z19 } from "zod";
-var createBlockParagrah = writeOperation3("createBlockParagraph", z19.object({
-  parentRef: z19.union([PostRefSchema, BlockRowRefSchema]),
-  content: z19.string().optional()
+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;
@@ -278,16 +301,16 @@ var createBlockParagrah = writeOperation3("createBlockParagraph", z19.object({
   })), Query3((block, updatedParent) => ({ block, updatedParent })));
 }, {
   changeSetOnly: true,
-  outputSchema: z19.object({
-    block: z19.any(),
-    updatedParent: z19.any()
+  outputSchema: z20.object({
+    block: z20.any(),
+    updatedParent: z20.any()
   })
 });
 
 // src/operations/createBlockRow.ts
 import { Query as Query4, QueryChain as QueryChain3, writeOperation as writeOperation4 } from "roc-db";
-import { z as z20 } from "zod";
-var createBlockRow = writeOperation4("createBlockRow", z20.object({ parentRef: z20.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
+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 QueryChain3(Query4(() => txn.readEntity(parentRef)), Query4((parent) => {
@@ -300,16 +323,16 @@ var createBlockRow = writeOperation4("createBlockRow", z20.object({ parentRef: z
   })), Query4((block, updatedParent) => ({ block, updatedParent })));
 }, {
   changeSetOnly: true,
-  outputSchema: z20.object({
-    block: z20.any(),
-    updatedParent: z20.any()
+  outputSchema: z21.object({
+    block: z21.any(),
+    updatedParent: z21.any()
   })
 });
 
 // src/operations/createBlockTitle.ts
 import { Query as Query5, writeOperation as writeOperation5 } from "roc-db";
-import { z as z21 } from "zod";
-var PayloadSchema = z21.object({ parentRef: z21.union([PostRefSchema, BlockRowRefSchema]) }).strict();
+import { z as z22 } from "zod";
+var PayloadSchema = z22.object({ parentRef: z22.union([PostRefSchema, BlockRowRefSchema]) }).strict();
 var createBlockTitle = writeOperation5("createBlockTitle", PayloadSchema, (txn) => {
   const ref = txn.createRef("BlockTitle");
   const { postRef } = txn.payload;
@@ -318,8 +341,8 @@ var createBlockTitle = writeOperation5("createBlockTitle", PayloadSchema, (txn)
 
 // src/operations/createDraft.ts
 import { Query as Query6, writeOperation as writeOperation6 } from "roc-db";
-import { z as z22 } from "zod";
-var createDraft = writeOperation6("createDraft", z22.object({ postRef: PostRefSchema }).strict(), (txn) => {
+import { z as z23 } from "zod";
+var createDraft = writeOperation6("createDraft", z23.object({ postRef: PostRefSchema }).strict(), (txn) => {
   const ref = txn.createRef("Draft");
   const { postRef } = txn.payload;
   return Query6(() => txn.createEntity(ref, {
@@ -329,47 +352,69 @@ var createDraft = writeOperation6("createDraft", z22.object({ postRef: PostRefSc
   }));
 }, { outputSchema: DraftSchema });
 
-// src/operations/createPost.ts
+// src/operations/createOrgSettings.ts
 import { Query as Query7, writeOperation as writeOperation7 } from "roc-db";
-import { z as z23 } from "zod";
-var PayloadSchema2 = z23.object({
-  title: z23.string(),
-  slug: z23.string().optional(),
-  tags: z23.array(z23.string()).default([])
+import { z as z24 } from "zod";
+var createOrgSettings = writeOperation7("createOrgSettings", z24.object({
+  name: z24.string(),
+  theme: z24.string().optional(),
+  primaryAdmin: UserRefSchema.optional()
+}), (txn) => {
+  const ref = txn.createRef("OrgSettings");
+  const { name, theme, primaryAdmin } = txn.payload;
+  return Query7(() => txn.createEntity(ref, {
+    data: { name, theme },
+    parents: { primaryAdmin },
+    children: { featuredPosts: [] }
+  }));
+});
+
+// src/operations/createPost.ts
+import { Query as Query8, writeOperation as writeOperation8 } from "roc-db";
+import { z as z25 } from "zod";
+var PayloadSchema2 = z25.object({
+  title: z25.string(),
+  slug: z25.string().optional(),
+  tags: z25.array(z25.string()).default([])
 }).strict();
-var createPost = writeOperation7("createPost", PayloadSchema2, (txn) => {
+var createPost = writeOperation8("createPost", PayloadSchema2, (txn) => {
   const ref = txn.createRef("Post");
   const { title, slug, tags } = txn.payload;
-  return Query7(() => txn.createEntity(ref, {
+  return Query8(() => txn.createEntity(ref, {
     data: { title, tags, slug },
     children: { blocks: [] }
   }));
 });
 
+// src/operations/createUnknownRef.ts
+import { Query as Query9, writeOperation as writeOperation9 } from "roc-db";
+import { z as z26 } from "zod";
+var createUnknownRef = writeOperation9("createUnknownRef", z26.object({}).optional(), (txn) => Query9(() => txn.createRef("NotARegisteredEntity")));
+
 // src/operations/createUser.ts
-import { Query as Query8, writeOperation as writeOperation8 } from "roc-db";
-import { z as z24 } from "zod";
-var createUser = writeOperation8("createUser", z24.object({ email: z24.string() }), (txn) => {
+import { Query as Query10, writeOperation as writeOperation10 } from "roc-db";
+import { z as z27 } from "zod";
+var createUser = writeOperation10("createUser", z27.object({ email: z27.string() }), (txn) => {
   const ref = txn.createRef("User");
   const { email } = txn.payload;
-  return Query8(() => txn.createEntity(ref, { data: { email } }));
+  return Query10(() => txn.createEntity(ref, { data: { email } }));
 });
 
 // src/operations/deleteBlocks.ts
-import { Query as Query9, QueryChain as QueryChain4, writeOperation as writeOperation9 } from "roc-db";
-import { z as z25 } from "zod";
+import { Query as Query11, QueryChain as QueryChain4, writeOperation as writeOperation11 } from "roc-db";
+import { z as z28 } from "zod";
 var DeleteBlockQuery = (txn, blockRef) => {
-  return QueryChain4(Query9(() => txn.readEntity(blockRef)), Query9((block) => {
+  return QueryChain4(Query11(() => txn.readEntity(blockRef)), Query11((block) => {
     return txn.readEntity(block.parents.parent, true);
-  }), Query9((post) => {
+  }), Query11((post) => {
     return txn.patchEntity(post.ref, {
       children: {
         blocks: post.children.blocks.filter((ref) => ref !== blockRef)
       }
     });
-  }), Query9(() => txn.deleteEntity(blockRef)));
+  }), Query11(() => txn.deleteEntity(blockRef)));
 };
-var deleteBlocks = writeOperation9("deleteBlocks", z25.array(z25.union([
+var deleteBlocks = writeOperation11("deleteBlocks", z28.array(z28.union([
   BlockParagraphRefSchema,
   BlockImageRefSchema,
   BlockRowRefSchema
@@ -379,42 +424,60 @@ var deleteBlocks = writeOperation9("deleteBlocks", z25.array(z25.union([
 }, { changeSetOnly: true });
 
 // src/operations/deleteDraft.ts
-import { Query as Query10, QueryChain as QueryChain5, writeOperation as writeOperation10 } from "roc-db";
-var deleteDraft = writeOperation10("deleteDraft", DraftRefSchema, (txn) => {
+import { Query as Query12, QueryChain as QueryChain5, writeOperation as writeOperation12 } from "roc-db";
+var deleteDraft = writeOperation12("deleteDraft", DraftRefSchema, (txn) => {
   const ref = txn.payload;
-  return QueryChain5(Query10(() => txn.deleteEntity(ref, true)), Query10(() => txn.deleteChangeSet(ref)));
+  return QueryChain5(Query12(() => txn.deleteEntity(ref, true)), Query12(() => txn.deleteChangeSet(ref)));
 });
 
+// src/operations/deleteOrgSettings.ts
+import { Query as Query13, writeOperation as writeOperation13 } from "roc-db";
+import { z as z29 } from "zod";
+var deleteOrgSettings = writeOperation13("deleteOrgSettings", z29.object({}).optional(), (txn) => Query13(() => txn.deleteEntity("OrgSettings")));
+
 // src/operations/deletePost.ts
-import { Query as Query11, writeOperation as writeOperation11 } from "roc-db";
-var deletePost = writeOperation11("deletePost", PostRefSchema, (txn) => {
+import { Query as Query14, writeOperation as writeOperation14 } from "roc-db";
+var deletePost = writeOperation14("deletePost", PostRefSchema, (txn) => {
   const ref = txn.payload;
-  return Query11(() => txn.deleteEntity(ref, true));
+  return Query14(() => txn.deleteEntity(ref, true));
+});
+
+// src/operations/duplicateDraft.ts
+import { Query as Query15, QueryChain as QueryChain6, writeOperation as writeOperation15 } from "roc-db";
+import { z as z30 } from "zod";
+var duplicateDraft = writeOperation15("duplicateDraft", z30.object({ sourceRef: DraftRefSchema, postRef: PostRefSchema }).strict(), (txn) => {
+  const newDraftRef = txn.createRef("Draft");
+  const { sourceRef, postRef } = txn.payload;
+  return QueryChain6(Query15(() => txn.createEntity(newDraftRef, { parents: { post: postRef } })), Query15(() => txn.duplicateChangeSetMutations(sourceRef, newDraftRef)), Query15((dup) => ({
+    draftRef: newDraftRef,
+    mutations: dup.mutations,
+    refMap: dup.refMap
+  })));
 });
 
 // src/operations/moveBlocks.ts
-import { Query as Query12, QueryChain as QueryChain6, writeOperation as writeOperation12 } from "roc-db";
-import { z as z26 } from "zod";
-var PayloadSchema3 = z26.object({
-  refs: z26.array(z26.union([BlockParagraphRefSchema, BlockRowRefSchema])),
-  targetPosition: z26.number().min(0)
+import { Query as Query16, QueryChain as QueryChain7, writeOperation as writeOperation16 } from "roc-db";
+import { z as z31 } from "zod";
+var PayloadSchema3 = z31.object({
+  refs: z31.array(z31.union([BlockParagraphRefSchema, BlockRowRefSchema])),
+  targetPosition: z31.number().min(0)
 }).strict();
-var moveBlocks = writeOperation12("moveBlocks", PayloadSchema3, (txn) => {
+var moveBlocks = writeOperation16("moveBlocks", PayloadSchema3, (txn) => {
   const { refs } = txn.payload;
-  return QueryChain6(Query12(() => txn.batchReadEntities(refs)), Query12((items) => {
+  return QueryChain7(Query16(() => txn.batchReadEntities(refs)), Query16((items) => {
     return "todo";
   }));
 });
 
 // src/operations/pageBlocks.ts
-import { Query as Query13, readOperation } from "roc-db";
-import { z as z27 } from "zod";
-var pageBlocks = readOperation("pageBlocks", z27.object({
-  size: z27.number().default(100),
-  parentRef: z27.string().optional()
+import { Query as Query17, readOperation } from "roc-db";
+import { z as z32 } from "zod";
+var pageBlocks = readOperation("pageBlocks", z32.object({
+  size: z32.number().default(100),
+  parentRef: z32.string().optional()
 }), (txn) => {
   const { size, parentRef } = txn.payload;
-  return Query13(() => txn.pageEntities({
+  return Query17(() => txn.pageEntities({
     entities: ["BlockImage", "BlockParagraph"],
     size,
     childrenOf: parentRef ? [parentRef] : []
@@ -422,50 +485,50 @@ var pageBlocks = readOperation("pageBlocks", z27.object({
 });
 
 // src/operations/pageEmptyEntitiesArray.ts
-import { Query as Query14, readOperation as readOperation2 } from "roc-db";
-import { z as z28 } from "zod";
-var pageEmptyEntitiesArray = readOperation2("pageEmptyEntitiesArray", z28.object({ size: z28.number().default(100) }), (txn) => {
+import { Query as Query18, readOperation as readOperation2 } from "roc-db";
+import { z as z33 } from "zod";
+var pageEmptyEntitiesArray = readOperation2("pageEmptyEntitiesArray", z33.object({ size: z33.number().default(100) }), (txn) => {
   const { size } = txn.payload;
-  return Query14(() => txn.pageEntities({ entities: [], size }));
+  return Query18(() => txn.pageEntities({ entities: [], size }));
 });
 
 // src/operations/pagePosts.ts
-import { Query as Query15, readOperation as readOperation3 } from "roc-db";
-import { z as z29 } from "zod";
-var pagePosts = readOperation3("pagePosts", z29.object({ size: z29.number().default(100) }).default({}), (txn) => {
+import { Query as Query19, readOperation as readOperation3 } from "roc-db";
+import { z as z34 } from "zod";
+var pagePosts = readOperation3("pagePosts", z34.object({ size: z34.number().default(100) }).default({}), (txn) => {
   const { size } = txn.payload;
-  return Query15(() => txn.pageEntities({ entities: ["Post"], size }));
+  return Query19(() => txn.pageEntities({ entities: ["Post"], size }));
 });
 
 // src/operations/pageSplat.ts
-import { Query as Query16, readOperation as readOperation4 } from "roc-db";
-import { z as z30 } from "zod";
-var pageSplat = readOperation4("pageSplat", z30.object({ size: z30.number().default(100) }), (txn) => {
+import { Query as Query20, readOperation as readOperation4 } from "roc-db";
+import { z as z35 } from "zod";
+var pageSplat = readOperation4("pageSplat", z35.object({ size: z35.number().default(100) }), (txn) => {
   const { size } = txn.payload;
-  return Query16(() => txn.pageEntities({ entities: "*", size }));
+  return Query20(() => txn.pageEntities({ entities: "*", size }));
 });
 
 // src/operations/pagePostsByTag.ts
-import { Query as Query17, readOperation as readOperation5 } from "roc-db";
-import { z as z31 } from "zod";
-var pagePostsByTag = readOperation5("pagePostsByTag", z31.string(), (txn) => {
+import { Query as Query21, readOperation as readOperation5 } from "roc-db";
+import { z as z36 } from "zod";
+var pagePostsByTag = readOperation5("pagePostsByTag", z36.string(), (txn) => {
   const tag = txn.payload;
-  return Query17(() => txn.pageEntitiesByIndex("Post", "tags", tag));
+  return Query21(() => txn.pageEntitiesByIndex("Post", "tags", tag));
 });
 
 // src/operations/readEntity.ts
-import { NotFoundError, Query as Query18, QueryChain as QueryChain7, readOperation as readOperation6 } from "roc-db";
-import { z as z32 } from "zod";
-var readEntity = readOperation6("readEntity", z32.string(), (txn) => {
+import { NotFoundError, Query as Query22, QueryChain as QueryChain8, readOperation as readOperation6 } from "roc-db";
+import { z as z37 } from "zod";
+var readEntity = readOperation6("readEntity", z37.string(), (txn) => {
   const ref = txn.payload;
-  return QueryChain7(Query18(() => txn.readEntity(ref)), Query18((entity) => {
+  return QueryChain8(Query22(() => txn.readEntity(ref)), Query22((entity) => {
     if (!entity) {
       throw new NotFoundError(ref);
     }
     return entity;
   }));
 }, {
-  outputSchema: z32.union([
+  outputSchema: z37.union([
     PostSchema,
     BlockImageSchema,
     BlockParagraphSchema
@@ -473,11 +536,11 @@ var readEntity = readOperation6("readEntity", z32.string(), (txn) => {
 });
 
 // src/operations/readMutation.ts
-import { NotFoundError as NotFoundError2, Query as Query19, QueryChain as QueryChain8, readOperation as readOperation7 } from "roc-db";
-import { z as z33 } from "zod";
-var readMutation = readOperation7("readMutation", z33.string(), (txn) => {
+import { NotFoundError as NotFoundError2, Query as Query23, QueryChain as QueryChain9, readOperation as readOperation7 } from "roc-db";
+import { z as z38 } from "zod";
+var readMutation = readOperation7("readMutation", z38.string(), (txn) => {
   const ref = txn.payload;
-  return QueryChain8(Query19(() => txn.readMutation(ref)), Query19((entity) => {
+  return QueryChain9(Query23(() => txn.readMutation(ref)), Query23((entity) => {
     if (!entity) {
       throw new NotFoundError2(ref);
     }
@@ -485,53 +548,58 @@ var readMutation = readOperation7("readMutation", z33.string(), (txn) => {
   }));
 });
 
+// src/operations/readOrgSettings.ts
+import { Query as Query24, readOperation as readOperation8 } from "roc-db";
+import { z as z39 } from "zod";
+var readOrgSettings = readOperation8("readOrgSettings", z39.object({}).optional(), (txn) => Query24(() => txn.readEntity("OrgSettings", true)));
+
 // src/operations/readPost.ts
-import { Query as Query20, readOperation as readOperation8 } from "roc-db";
-var readPost = readOperation8("readPost", PostRefSchema, (txn) => {
+import { Query as Query25, readOperation as readOperation9 } from "roc-db";
+var readPost = readOperation9("readPost", PostRefSchema, (txn) => {
   const ref = txn.payload;
-  return Query20(() => txn.readEntity(ref, true));
+  return Query25(() => txn.readEntity(ref, true));
 }, { outputSchema: PostSchema });
 
 // src/operations/readPostBySlug.ts
-import { Query as Query21, readOperation as readOperation9 } from "roc-db";
-import { z as z34 } from "zod";
-var readPostBySlug = readOperation9("readPostBySlug", z34.string(), (txn) => {
+import { Query as Query26, readOperation as readOperation10 } from "roc-db";
+import { z as z40 } from "zod";
+var readPostBySlug = readOperation10("readPostBySlug", z40.string(), (txn) => {
   const slug = txn.payload;
-  return Query21(() => txn.readEntityByUniqueField("Post", "slug", slug));
+  return Query26(() => txn.readEntityByUniqueField("Post", "slug", slug));
 }, { outputSchema: PostSchema });
 
 // src/operations/testTransactionalEdits.ts
 import { expect } from "bun:test";
-import { Query as Query22, QueryChain as QueryChain9, writeOperation as writeOperation13 } from "roc-db";
-import { z as z35 } from "zod";
+import { Query as Query27, QueryChain as QueryChain10, writeOperation as writeOperation17 } from "roc-db";
+import { z as z41 } from "zod";
 var TestCreatePatchDeleteInSameTransaction = (txn, title) => {
   const postRef = txn.createRef("Post");
-  return QueryChain9(Query22(() => txn.createEntity(postRef, {
+  return QueryChain10(Query27(() => txn.createEntity(postRef, {
     data: { title, tags: [] },
     children: { blocks: [] }
-  })), Query22(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query22((post) => {
+  })), Query27(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query27((post) => {
     expect(post.data.title).toBe(title);
     expect(post.data.foo).toBe("bar");
-  }), Query22(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query22((post) => {
+  }), Query27(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query27((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");
-  }), Query22((post) => txn.deleteEntity(postRef)), Query22((res) => {
+  }), Query27((post) => txn.deleteEntity(postRef)), Query27((res) => {
     expect(res).toBe(1);
     expect(txn.log).toHaveLength(0);
   }));
 };
 var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
-  return QueryChain9(Query22(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query22((post) => {
+  return QueryChain10(Query27(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query27((post) => {
     expect(post.data.foo).toBe("bar");
-  }), Query22(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query22((post) => {
+  }), Query27(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query27((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");
-  }), Query22((post) => txn.deleteEntity(ref)), Query22((res) => {
+  }), Query27((post) => txn.deleteEntity(ref)), Query27((res) => {
     expect(res).toBe(1);
     expect(txn.log).toHaveLength(1);
     expect(txn.log.get(ref)[0]).toBe("delete");
@@ -539,14 +607,14 @@ var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
 };
 var TestCreateOnExistingRef = (txn) => {
   const ref = txn.createRef("Post");
-  return QueryChain9(Query22(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query22(() => txn.createEntity(ref, { data: { foo: "bar" } })));
+  return QueryChain10(Query27(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query27(() => txn.createEntity(ref, { data: { foo: "bar" } })));
 };
-var PayloadSchema4 = z35.object({
-  name: z35.string().optional(),
+var PayloadSchema4 = z41.object({
+  name: z41.string().optional(),
   post1ref: PostRefSchema.optional(),
   post2ref: PostRefSchema.optional()
 }).strict();
-var testTransactionalEdits = writeOperation13("testTransactionalEdits", PayloadSchema4, (txn) => {
+var testTransactionalEdits = writeOperation17("testTransactionalEdits", PayloadSchema4, (txn) => {
   const { name, post1ref, post2ref } = txn.payload;
   if (name)
     return TestCreatePatchDeleteInSameTransaction(txn, name);
@@ -557,30 +625,38 @@ var testTransactionalEdits = writeOperation13("testTransactionalEdits", PayloadS
 }, {});
 
 // src/operations/updateBlockParagraph.ts
-import { Query as Query23, writeOperation as writeOperation14 } from "roc-db";
-import { z as z36 } from "zod";
-var updateBlockParagraph = writeOperation14("updateBlockParagraph", z36.object({
+import { Query as Query28, writeOperation as writeOperation18 } from "roc-db";
+import { z as z42 } from "zod";
+var updateBlockParagraph = writeOperation18("updateBlockParagraph", z42.object({
   ref: BlockParagraphRefSchema,
-  content: z36.string()
+  content: z42.string()
 }), (txn) => {
   const { ref, content } = txn.payload;
-  return Query23(() => txn.patchEntity(ref, {
+  return Query28(() => txn.patchEntity(ref, {
     data: { content }
   }));
 }, { outputSchema: BlockParagraphSchema });
 
+// src/operations/updateOrgSettingsName.ts
+import { Query as Query29, writeOperation as writeOperation19 } from "roc-db";
+import { z as z43 } from "zod";
+var updateOrgSettingsName = writeOperation19("updateOrgSettingsName", z43.object({ name: z43.string() }), (txn) => {
+  const { name } = txn.payload;
+  return Query29(() => txn.patchEntity("OrgSettings", { data: { name } }));
+}, { debounce: 10 });
+
 // src/operations/updatePost.ts
-import { Query as Query24, writeOperation as writeOperation15 } from "roc-db";
-import { z as z37 } from "zod";
-var PayloadSchema5 = z37.object({
+import { Query as Query30, writeOperation as writeOperation20 } from "roc-db";
+import { z as z44 } from "zod";
+var PayloadSchema5 = z44.object({
   ref: PostRefSchema,
-  title: z37.string().optional(),
-  tags: z37.array(z37.string()).optional().default([]),
+  title: z44.string().optional(),
+  tags: z44.array(z44.string()).optional().default([]),
   authorRef: UserRefSchema.optional()
 });
-var updatePost = writeOperation15("updatePost", PayloadSchema5, (txn) => {
+var updatePost = writeOperation20("updatePost", PayloadSchema5, (txn) => {
   const { ref, authorRef, ...data } = txn.payload;
-  return Query24(() => txn.updateEntity(ref, {
+  return Query30(() => txn.updateEntity(ref, {
     data,
     parents: { author: authorRef },
     children: { blocks: [] }
@@ -588,43 +664,43 @@ var updatePost = writeOperation15("updatePost", PayloadSchema5, (txn) => {
 }, { outputSchema: PostSchema });
 
 // src/operations/updatePostDescription.ts
-import { Query as Query25, writeOperation as writeOperation16 } from "roc-db";
-import { z as z38 } from "zod";
-var updatePostDescription = writeOperation16("updatePostDescription", z38.object({ ref: PostRefSchema, description: z38.string() }), (txn) => {
+import { Query as Query31, writeOperation as writeOperation21 } from "roc-db";
+import { z as z45 } from "zod";
+var updatePostDescription = writeOperation21("updatePostDescription", z45.object({ ref: PostRefSchema, description: z45.string() }), (txn) => {
   const { ref, description } = txn.payload;
-  return Query25(() => txn.patchEntity(ref, { data: { description } }));
+  return Query31(() => txn.patchEntity(ref, { data: { description } }));
 }, { debounce: 10, changeSetOnly: true, outputSchema: PostSchema });
 
 // src/operations/updatePostSlug.ts
-import { Query as Query26, writeOperation as writeOperation17 } from "roc-db";
-import { z as z39 } from "zod";
-var updatePostSlug = writeOperation17("updatePostSlug", z39.object({ ref: PostRefSchema, slug: z39.string() }), (txn) => {
+import { Query as Query32, writeOperation as writeOperation22 } from "roc-db";
+import { z as z46 } from "zod";
+var updatePostSlug = writeOperation22("updatePostSlug", z46.object({ ref: PostRefSchema, slug: z46.string() }), (txn) => {
   const { ref, slug } = txn.payload;
-  return Query26(() => txn.patchEntity(ref, { data: { slug } }));
+  return Query32(() => txn.patchEntity(ref, { data: { slug } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/updatePostTags.ts
-import { Query as Query27, writeOperation as writeOperation18 } from "roc-db";
-import { z as z40 } from "zod";
-var updatePostTags = writeOperation18("updatePostTags", z40.object({ ref: PostRefSchema, tags: z40.array(z40.string()) }), (txn) => {
+import { Query as Query33, writeOperation as writeOperation23 } from "roc-db";
+import { z as z47 } from "zod";
+var updatePostTags = writeOperation23("updatePostTags", z47.object({ ref: PostRefSchema, tags: z47.array(z47.string()) }), (txn) => {
   const { ref, tags } = txn.payload;
-  return Query27(() => txn.patchEntity(ref, { data: { tags } }));
+  return Query33(() => txn.patchEntity(ref, { data: { tags } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/updatePostTitle.ts
-import { Query as Query28, writeOperation as writeOperation19 } from "roc-db";
-import { z as z41 } from "zod";
-var updatePostTitle = writeOperation19("updatePostTitle", z41.object({ ref: PostRefSchema, title: z41.string() }), (txn) => {
+import { Query as Query34, writeOperation as writeOperation24 } from "roc-db";
+import { z as z48 } from "zod";
+var updatePostTitle = writeOperation24("updatePostTitle", z48.object({ ref: PostRefSchema, title: z48.string() }), (txn) => {
   const { ref, title } = txn.payload;
-  return Query28(() => txn.patchEntity(ref, { data: { title } }));
+  return Query34(() => txn.patchEntity(ref, { data: { title } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/crudBySlug.ts
-import { Query as Query29, QueryChain as QueryChain10, writeOperation as writeOperation20 } from "roc-db";
-import { z as z42 } from "zod";
-var crudBySlug = writeOperation20("crudBySlug", z42.object({ slug: z42.string(), newSlug: z42.string() }), (txn) => {
+import { Query as Query35, QueryChain as QueryChain11, writeOperation as writeOperation25 } from "roc-db";
+import { z as z49 } from "zod";
+var crudBySlug = writeOperation25("crudBySlug", z49.object({ slug: z49.string(), newSlug: z49.string() }), (txn) => {
   const { slug, newSlug } = txn.payload;
-  return QueryChain10(Query29(() => txn.readEntityByUniqueField("Post", "slug", slug)), Query29((post) => txn.patchEntity(post.ref, { data: { slug: newSlug } })), Query29(() => txn.readEntityByUniqueField("Post", "slug", newSlug)), Query29((post) => txn.deleteEntity(post.ref)), Query29(() => {
+  return QueryChain11(Query35(() => txn.readEntityByUniqueField("Post", "slug", slug)), Query35((post) => txn.patchEntity(post.ref, { data: { slug: newSlug } })), Query35(() => txn.readEntityByUniqueField("Post", "slug", newSlug)), Query35((post) => txn.deleteEntity(post.ref)), Query35(() => {
     return [
       txn.readEntityByUniqueField("Post", "slug", slug, false),
       txn.readEntityByUniqueField("Post", "slug", newSlug, false)
@@ -640,24 +716,30 @@ var operations = [
   createBlockParagrah,
   createBlockRow,
   createDraft,
+  createOrgSettings,
   createPost,
+  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,
@@ -669,9 +751,11 @@ 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 z50 } from "zod";
 import { faker } from "@faker-js/faker";
 var snowflake = new Snowflake(10, 10);
 var prepareChangeSetTest = async (adapter, adapter2) => {
@@ -720,14 +804,18 @@ var prepareChangeSetTest = async (adapter, adapter2) => {
   };
 };
 var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
-  let createAdapter = async ({ optimistic = false } = {}) => {
+  let createAdapter = async ({
+    optimistic = false,
+    session = { identityRef: "User/42" },
+    engineArgs
+  } = {}) => {
     return adapterConstructor({
       operations,
       entities,
-      session: { identityRef: "User/42" },
+      session,
       snowflake,
       optimistic,
-      ...await generateArgs()
+      ...engineArgs ?? await generateArgs()
     });
   };
   let adapter1, adapter2;
@@ -918,6 +1006,87 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
       })).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: z50.object({ name: z50.string() }),
+        uniqueDataKeys: ["name"]
+      })).toThrow(/singleton/);
+    });
+    test("createRef throws on unregistered entity", async () => {
+      expect2(() => adapter.createUnknownRef()).toThrow(BadRequestError);
+    });
+  });
   describe("paging", () => {
     let adapter;
     let post1ref;
@@ -1050,6 +1219,40 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
       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("deleteBlocks (patch running 2 times removing on array element every time)", async () => {
       const [post2, createPostMutation] = await adapter1.createPost({
         title: "Title 1",

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

@@ -4,4 +4,4 @@ export declare const BlockImageEntity: Entity<"BlockImage", z.ZodObject<{
     url: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
     parent: z.ZodTemplateLiteral<`Post/${number}`>;
-}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

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

@@ -4,4 +4,4 @@ export declare const BlockParagraph: Entity<"BlockParagraph", z.ZodObject<{
     content: z.ZodOptional<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>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

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

@@ -4,4 +4,4 @@ export declare const BlockRow: Entity<"BlockRow", z.ZodObject<{}, z.core.$strip>
     blocks: z.ZodArray<z.ZodUnion<readonly [z.ZodTemplateLiteral<`BlockParagraph/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>>;
 }, 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>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

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

@@ -4,4 +4,5 @@ export declare const Draft: Entity<"Draft", z.ZodObject<{
     appliedAt: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
     post: z.ZodTemplateLiteral<`Post/${number}`>;
-}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+    version: z.ZodOptional<z.ZodTemplateLiteral<`PostVersion/${number}`>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

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

@@ -0,0 +1,10 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const OrgSettingsEntity: Entity<"OrgSettings", z.ZodObject<{
+    name: z.ZodString;
+    theme: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    featuredPosts: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    primaryAdmin: z.ZodOptional<z.ZodTemplateLiteral<`User/${number}`>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, true>;

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

@@ -9,4 +9,4 @@ export declare const PostEntity: Entity<"Post", z.ZodObject<{
     blocks: z.ZodArray<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     author: z.ZodOptional<z.ZodTemplateLiteral<`User/${number}`>>;
-}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

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

@@ -5,4 +5,4 @@ export declare const PostVersion: Entity<"PostVersion", z.ZodObject<{
     snapshot: z.ZodArray<z.ZodAny>;
 }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
     post: z.ZodTemplateLiteral<`Post/${number}`>;
-}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

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

@@ -2,4 +2,4 @@ import { Entity } from "roc-db";
 import { z } from "zod";
 export declare const UserEntity: Entity<"User", z.ZodObject<{
     email: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

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

@@ -2,11 +2,12 @@ export declare const entities: (import("roc-db").Entity<"Draft", import("zod").Z
     appliedAt: import("zod").ZodOptional<import("zod").ZodString>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     post: import("zod").ZodTemplateLiteral<`Post/${number}`>;
-}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>> | import("roc-db").Entity<"BlockImage", import("zod").ZodObject<{
+    version: import("zod").ZodOptional<import("zod").ZodTemplateLiteral<`PostVersion/${number}`>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false> | import("roc-db").Entity<"BlockImage", import("zod").ZodObject<{
     url: import("zod").ZodString;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     parent: import("zod").ZodTemplateLiteral<`Post/${number}`>;
-}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>> | import("roc-db").Entity<"Post", import("zod").ZodObject<{
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false> | import("roc-db").Entity<"Post", import("zod").ZodObject<{
     title: import("zod").ZodString;
     text: import("zod").ZodOptional<import("zod").ZodString>;
     tags: import("zod").ZodArray<import("zod").ZodString>;
@@ -15,19 +16,26 @@ export declare const entities: (import("roc-db").Entity<"Draft", import("zod").Z
     blocks: import("zod").ZodArray<import("zod").ZodString>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     author: import("zod").ZodOptional<import("zod").ZodTemplateLiteral<`User/${number}`>>;
-}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>> | import("roc-db").Entity<"BlockParagraph", import("zod").ZodObject<{
+}, 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>;
 }, 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>> | import("roc-db").Entity<"BlockRow", import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+}, 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<{
     blocks: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodTemplateLiteral<`BlockParagraph/${number}`>, import("zod").ZodTemplateLiteral<`BlockRow/${number}`>]>>;
 }, 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>> | import("roc-db").Entity<"PostVersion", import("zod").ZodObject<{
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false> | import("roc-db").Entity<"OrgSettings", import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    theme: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    featuredPosts: import("zod").ZodArray<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    primaryAdmin: import("zod").ZodOptional<import("zod").ZodTemplateLiteral<`User/${number}`>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, true> | import("roc-db").Entity<"PostVersion", import("zod").ZodObject<{
     version: import("zod").ZodNumber;
     snapshot: import("zod").ZodArray<import("zod").ZodAny>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     post: import("zod").ZodTemplateLiteral<`Post/${number}`>;
-}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>> | import("roc-db").Entity<"User", import("zod").ZodObject<{
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false> | import("roc-db").Entity<"User", import("zod").ZodObject<{
     email: import("zod").ZodString;
-}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>>)[];
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false>)[];

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

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const createOrgSettings: import("roc-db").WriteOperation<"createOrgSettings", z.ZodObject<{
+    name: z.ZodString;
+    theme: z.ZodOptional<z.ZodString>;
+    primaryAdmin: z.ZodOptional<z.ZodTemplateLiteral<`User/${number}`>>;
+}, z.core.$strip>>;

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare const createUnknownRef: import("roc-db").WriteOperation<"createUnknownRef", z.ZodOptional<z.ZodObject<{}, z.core.$strip>>>;

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare const deleteOrgSettings: import("roc-db").WriteOperation<"deleteOrgSettings", z.ZodOptional<z.ZodObject<{}, z.core.$strip>>>;

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

@@ -0,0 +1,10 @@
+import { z } from "zod";
+/**
+ * Canonical consumer usage of the `txn.duplicateChangeSetMutations` primitive:
+ * create the new draft and copy the source draft's pending mutations into it,
+ * all in one transaction.
+ */
+export declare const duplicateDraft: import("roc-db").WriteOperation<"duplicateDraft", z.ZodObject<{
+    sourceRef: z.ZodType<`Draft/${number}`, `Draft/${number}`, z.core.$ZodTypeInternals<`Draft/${number}`, `Draft/${number}`>>;
+    postRef: z.ZodTemplateLiteral<`Post/${number}`>;
+}, z.core.$strict>>;

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare const readOrgSettings: import("roc-db").ReadOperation<"readOrgSettings", z.ZodOptional<z.ZodObject<{}, z.core.$strip>>>;

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

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const updateOrgSettingsName: import("roc-db").WriteOperation<"updateOrgSettingsName", z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>>;

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

@@ -10,7 +10,7 @@ export declare const CreatePostMutationSchema: z.ZodObject<{
         name: z.ZodLiteral<"createPost">;
         version: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
-    changeSetRef: z.ZodTemplateLiteral<`${string}/${number}`> | z.ZodNullable<z.ZodTemplateLiteral<`${string}/${number}`>>;
+    changeSetRef: z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]> | z.ZodTemplateLiteral<never> | z.ZodNullable<z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]>> | z.ZodNullable<z.ZodTemplateLiteral<never>>;
     payload: z.ZodObject<{
         title: z.ZodString;
         slug: z.ZodOptional<z.ZodString>;

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

@@ -10,7 +10,7 @@ export declare const CreateUserMutationSchema: z.ZodObject<{
         name: z.ZodLiteral<"createUser">;
         version: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
-    changeSetRef: z.ZodTemplateLiteral<`${string}/${number}`> | z.ZodNullable<z.ZodTemplateLiteral<`${string}/${number}`>>;
+    changeSetRef: z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]> | z.ZodTemplateLiteral<never> | z.ZodNullable<z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]>> | z.ZodNullable<z.ZodTemplateLiteral<never>>;
     payload: z.ZodObject<{
         email: z.ZodString;
     }, z.core.$strip>;

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

@@ -0,0 +1 @@
+export declare const PostVersionRefSchema: import("zod").ZodTemplateLiteral<`PostVersion/${number}`>;

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

@@ -10,7 +10,7 @@ export declare const UpdatePostMutationSchema: z.ZodObject<{
         name: z.ZodLiteral<"updatePost">;
         version: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
-    changeSetRef: z.ZodTemplateLiteral<`${string}/${number}`> | z.ZodNullable<z.ZodTemplateLiteral<`${string}/${number}`>>;
+    changeSetRef: z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]> | z.ZodTemplateLiteral<never> | z.ZodNullable<z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]>> | z.ZodNullable<z.ZodTemplateLiteral<never>>;
     payload: z.ZodObject<{
         ref: z.ZodTemplateLiteral<`Post/${number}`>;
         title: z.ZodOptional<z.ZodString>;

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

@@ -10,7 +10,7 @@ export declare const UpdatePostTitleMutationSchema: z.ZodObject<{
         name: z.ZodLiteral<"updatePostTitle">;
         version: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
-    changeSetRef: z.ZodTemplateLiteral<`${string}/${number}`> | z.ZodNullable<z.ZodTemplateLiteral<`${string}/${number}`>>;
+    changeSetRef: z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]> | z.ZodTemplateLiteral<never> | z.ZodNullable<z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]>> | z.ZodNullable<z.ZodTemplateLiteral<never>>;
     payload: z.ZodObject<{
         ref: z.ZodTemplateLiteral<`Post/${number}`>;
         title: z.ZodString;

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

@@ -0,0 +1,11 @@
+import type { ZodSchema } from "zod";
+interface CustomMatchers {
+    toMatchZodSchema(schema: ZodSchema): any;
+}
+declare module "bun:test" {
+    interface Matchers<T> extends CustomMatchers {
+    }
+    interface AsymmetricMatchers extends CustomMatchers {
+    }
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@roc-db/test-utils",
-    "version": "0.2.0-pre.97",
+    "version": "0.2.0-pre.99",
     "type": "module",
     "exports": {
         ".": {
@@ -17,7 +17,7 @@
     ],
     "sideEffects": false,
     "peerDependencies": {
-        "roc-db": "0.2.0-pre.97",
+        "roc-db": ">=0.2.0-pre.98 <1.0.0",
         "zod": ">=4.0.0"
     },
     "keywords": [],
@@ -26,5 +26,9 @@
         "type": "git",
         "url": "git+https://github.com/eigilsagafos/roc-db.git"
     },
-    "license": "MIT"
+    "license": "MIT",
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
+    }
 }