@kyneta/yjs-schema 1.0.0 → 1.1.0

package/src/__tests__/create.test.ts

@@ -1,11 +1,11 @@
+import { change, Schema, subscribe } from "@kyneta/schema"
 import { describe, expect, it, vi } from "vitest"
 import * as Y from "yjs"
-import { Schema, change, subscribe } from "@kyneta/schema"
-import { createYjsDoc, createYjsDocFromSnapshot } from "../create.js"
-import { version, exportSnapshot, exportSince, importDelta } from "../sync.js"
-import { YjsVersion } from "../version.js"
+import { createYjsDoc, createYjsDocFromEntirety } from "../create.js"
 import { ensureContainers } from "../populate.js"
 import { yjsSubstrateFactory } from "../substrate.js"
+import { exportEntirety, exportSince, merge, version } from "../sync.js"
+import { YjsVersion } from "../version.js"
 import { yjs } from "../yjs-escape.js"
 
 // ===========================================================================
@@ -192,10 +192,10 @@ describe("createYjsDoc", () => {
 })
 
 // ===========================================================================
-// createYjsDocFromSnapshot
+// createYjsDocFromEntirety
 // ===========================================================================
 
-describe("createYjsDocFromSnapshot", () => {
+describe("createYjsDocFromEntirety", () => {
   it("reconstructs state from a snapshot", () => {
     const doc1 = createYjsDoc(SimpleSchema)
     change(doc1, (d: any) => {
@@ -205,8 +205,8 @@ describe("createYjsDocFromSnapshot", () => {
     change(doc1, (d: any) => d.items.push("a"))
     change(doc1, (d: any) => d.items.push("b"))
 
-    const payload = exportSnapshot(doc1)
-    const doc2 = createYjsDocFromSnapshot(SimpleSchema, payload)
+    const payload = exportEntirety(doc1)
+    const doc2 = createYjsDocFromEntirety(SimpleSchema, payload)
 
     expect(doc2.title()).toBe("Snapshot")
     expect(doc2.count()).toBe(42)
@@ -225,8 +225,8 @@ describe("createYjsDocFromSnapshot", () => {
       d.items.push("x")
     })
 
-    const payload = exportSnapshot(doc1)
-    const doc2 = createYjsDocFromSnapshot(SimpleSchema, payload)
+    const payload = exportEntirety(doc1)
+    const doc2 = createYjsDocFromEntirety(SimpleSchema, payload)
 
     expect(doc2.title()).toBe("Start End")
     expect(doc2.count()).toBe(99)
@@ -243,8 +243,8 @@ describe("createYjsDocFromSnapshot", () => {
     change(doc1, (d: any) => d.meta.tags.push("v1"))
     change(doc1, (d: any) => d.meta.tags.push("v2"))
 
-    const payload = exportSnapshot(doc1)
-    const doc2 = createYjsDocFromSnapshot(NestedSchema, payload)
+    const payload = exportEntirety(doc1)
+    const doc2 = createYjsDocFromEntirety(NestedSchema, payload)
 
     expect(doc2.title()).toBe("Nested")
     expect(doc2.meta.author()).toBe("Alice")
@@ -258,8 +258,8 @@ describe("createYjsDocFromSnapshot", () => {
     change(doc1, (d: any) => d.tasks.push({ name: "Task A", done: false }))
     change(doc1, (d: any) => d.tasks.push({ name: "Task B", done: true }))
 
-    const payload = exportSnapshot(doc1)
-    const doc2 = createYjsDocFromSnapshot(StructListSchema, payload)
+    const payload = exportEntirety(doc1)
+    const doc2 = createYjsDocFromEntirety(StructListSchema, payload)
 
     expect(doc2.tasks.length).toBe(2)
     expect((doc2.tasks.at(0) as any).name()).toBe("Task A")
@@ -271,8 +271,8 @@ describe("createYjsDocFromSnapshot", () => {
     change(doc1, (d: any) => {
       d.title.insert(0, "Original")
     })
-    const payload = exportSnapshot(doc1)
-    const doc2 = createYjsDocFromSnapshot(SimpleSchema, payload)
+    const payload = exportEntirety(doc1)
+    const doc2 = createYjsDocFromEntirety(SimpleSchema, payload)
 
     change(doc2, (d: any) => {
       d.title.insert(8, " Copy")
@@ -288,8 +288,8 @@ describe("createYjsDocFromSnapshot", () => {
     change(doc1, (d: any) => {
       d.title.insert(0, "Original")
     })
-    const payload = exportSnapshot(doc1)
-    const doc2 = createYjsDocFromSnapshot(SimpleSchema, payload)
+    const payload = exportEntirety(doc1)
+    const doc2 = createYjsDocFromEntirety(SimpleSchema, payload)
 
     const received: any[] = []
     subscribe(doc2, (changeset: any) => {
@@ -330,7 +330,9 @@ describe("sync primitives", () => {
 
     it("serialize/parse round-trips", () => {
       const doc = createYjsDoc(SimpleSchema)
-      change(doc, (d: any) => { d.title.insert(0, "Test") })
+      change(doc, (d: any) => {
+        d.title.insert(0, "Test")
+      })
       const v = version(doc)
       const serialized = v.serialize()
       const parsed = YjsVersion.parse(serialized)
@@ -338,22 +340,26 @@ describe("sync primitives", () => {
     })
   })
 
-  describe("exportSnapshot", () => {
+  describe("exportEntirety", () => {
     it("returns a binary payload", () => {
       const doc = createYjsDoc(SimpleSchema)
-      change(doc, (d: any) => { d.title.insert(0, "Snap") })
-      const payload = exportSnapshot(doc)
+      change(doc, (d: any) => {
+        d.title.insert(0, "Snap")
+      })
+      const payload = exportEntirety(doc)
       expect(payload.encoding).toBe("binary")
       expect(payload.data).toBeInstanceOf(Uint8Array)
       expect((payload.data as Uint8Array).byteLength).toBeGreaterThan(0)
     })
   })
 
-  describe("exportSince + importDelta", () => {
+  describe("exportSince + merge", () => {
     it("syncs incremental changes between two docs", () => {
       const doc1 = createYjsDoc(SimpleSchema)
-      change(doc1, (d: any) => { d.title.insert(0, "Start") })
-      const doc2 = createYjsDocFromSnapshot(SimpleSchema, exportSnapshot(doc1))
+      change(doc1, (d: any) => {
+        d.title.insert(0, "Start")
+      })
+      const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
 
       const v2Before = version(doc2)
 
@@ -369,7 +375,7 @@ describe("sync primitives", () => {
       expect(delta).not.toBeNull()
       expect(delta!.encoding).toBe("binary")
 
-      importDelta(doc2, delta!)
+      merge(doc2, delta!)
 
       expect(doc2.title()).toBe("Start Edited")
       expect(doc2.count()).toBe(42)
@@ -378,37 +384,39 @@ describe("sync primitives", () => {
 
     it("syncs multiple incremental deltas", () => {
       const doc1 = createYjsDoc(SimpleSchema)
-      const doc2 = createYjsDocFromSnapshot(SimpleSchema, exportSnapshot(doc1))
+      const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
 
       // First round
       let vBefore = version(doc2)
       change(doc1, (d: any) => {
         d.title.insert(0, "A")
       })
-      importDelta(doc2, exportSince(doc1, vBefore)!)
+      merge(doc2, exportSince(doc1, vBefore)!)
 
       // Second round
       vBefore = version(doc2)
       change(doc1, (d: any) => {
         d.title.insert(1, "B")
       })
-      importDelta(doc2, exportSince(doc1, vBefore)!)
+      merge(doc2, exportSince(doc1, vBefore)!)
 
       // Third round
       vBefore = version(doc2)
       change(doc1, (d: any) => {
         d.count.set(3)
       })
-      importDelta(doc2, exportSince(doc1, vBefore)!)
+      merge(doc2, exportSince(doc1, vBefore)!)
 
       expect(doc2.title()).toBe("AB")
       expect(doc2.count()).toBe(3)
     })
 
-    it("changefeed fires on importDelta", () => {
+    it("changefeed fires on merge", () => {
       const doc1 = createYjsDoc(SimpleSchema)
-      change(doc1, (d: any) => { d.title.insert(0, "Source") })
-      const doc2 = createYjsDocFromSnapshot(SimpleSchema, exportSnapshot(doc1))
+      change(doc1, (d: any) => {
+        d.title.insert(0, "Source")
+      })
+      const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
 
       const v2Before = version(doc2)
 
@@ -423,15 +431,15 @@ describe("sync primitives", () => {
         received.push(changeset)
       })
 
-      importDelta(doc2, delta!)
+      merge(doc2, delta!)
 
       expect(received.length).toBeGreaterThanOrEqual(1)
       expect(doc2.count()).toBe(77)
     })
 
-    it("importDelta passes origin to changefeed", () => {
+    it("merge passes origin to changefeed", () => {
       const doc1 = createYjsDoc(SimpleSchema)
-      const doc2 = createYjsDocFromSnapshot(SimpleSchema, exportSnapshot(doc1))
+      const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
 
       const v2Before = version(doc2)
       change(doc1, (d: any) => {
@@ -443,7 +451,7 @@ describe("sync primitives", () => {
         receivedOrigins.push(changeset.origin)
       })
 
-      importDelta(doc2, exportSince(doc1, v2Before)!, "my-sync-origin")
+      merge(doc2, exportSince(doc1, v2Before)!, "my-sync-origin")
 
       expect(receivedOrigins).toContain("my-sync-origin")
     })
@@ -452,19 +460,21 @@ describe("sync primitives", () => {
   describe("versions equal after sync", () => {
     it("versions equal after full snapshot sync", () => {
       const doc1 = createYjsDoc(SimpleSchema)
-      change(doc1, (d: any) => { d.title.insert(0, "Same") })
+      change(doc1, (d: any) => {
+        d.title.insert(0, "Same")
+      })
       change(doc1, (d: any) => {
         d.count.set(42)
       })
 
-      const doc2 = createYjsDocFromSnapshot(SimpleSchema, exportSnapshot(doc1))
+      const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
 
       expect(version(doc1).compare(version(doc2))).toBe("equal")
     })
 
     it("versions equal after bidirectional delta sync", () => {
       const doc1 = createYjsDoc(SimpleSchema)
-      const doc2 = createYjsDocFromSnapshot(SimpleSchema, exportSnapshot(doc1))
+      const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
 
       const v1Before = version(doc1)
       const v2Before = version(doc2)
@@ -480,8 +490,8 @@ describe("sync primitives", () => {
       // Bidirectional sync
       const d1to2 = exportSince(doc1, v2Before)
       const d2to1 = exportSince(doc2, v1Before)
-      importDelta(doc2, d1to2!)
-      importDelta(doc1, d2to1!)
+      merge(doc2, d1to2!)
+      merge(doc1, d2to1!)
 
       expect(version(doc1).compare(version(doc2))).toBe("equal")
     })
@@ -496,9 +506,9 @@ describe("full workflow", () => {
   it("create → mutate → sync → observe", () => {
     // 1. Create two docs
     const doc1 = createYjsDoc(StructListSchema)
-    const doc2 = createYjsDocFromSnapshot(
+    const doc2 = createYjsDocFromEntirety(
       StructListSchema,
-      exportSnapshot(doc1),
+      exportEntirety(doc1),
     )
 
     // 2. Set up observer on doc2
@@ -520,7 +530,7 @@ describe("full workflow", () => {
 
     // 4. Sync doc1 → doc2
     const delta = exportSince(doc1, vBefore)
-    importDelta(doc2, delta!)
+    merge(doc2, delta!)
 
     // 5. Verify state converged
     expect(doc2.tasks.length).toBe(2)
@@ -541,7 +551,7 @@ describe("full workflow", () => {
     })
 
     const delta2 = exportSince(doc2, v1Before)
-    importDelta(doc1, delta2!)
+    merge(doc1, delta2!)
 
     expect(doc1.tasks.length).toBe(3)
     expect((doc1.tasks.at(2) as any).name()).toBe("Read book")
@@ -561,10 +571,10 @@ describe("full workflow", () => {
     })
 
     // 2. Snapshot
-    const snapshot = exportSnapshot(doc1)
+    const snapshot = exportEntirety(doc1)
 
     // 3. Reconstruct
-    const doc2 = createYjsDocFromSnapshot(SimpleSchema, snapshot)
+    const doc2 = createYjsDocFromEntirety(SimpleSchema, snapshot)
     expect(doc2.title()).toBe("Start Middle")
     expect(doc2.count()).toBe(10)
     expect(doc2.items()).toEqual(["first"])
@@ -590,7 +600,7 @@ describe("full workflow", () => {
   it("concurrent edits converge correctly", () => {
     // 1. Create two peers from the same initial state
     const doc1 = createYjsDoc(SimpleSchema)
-    const doc2 = createYjsDocFromSnapshot(SimpleSchema, exportSnapshot(doc1))
+    const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
 
     const v1Before = version(doc1)
     const v2Before = version(doc2)
@@ -611,8 +621,8 @@ describe("full workflow", () => {
     // 4. Bidirectional sync
     const d1to2 = exportSince(doc1, v2Before)
     const d2to1 = exportSince(doc2, v1Before)
-    importDelta(doc2, d1to2!)
-    importDelta(doc1, d2to1!)
+    merge(doc2, d1to2!)
+    merge(doc1, d2to1!)
 
     // 5. Versions converge
     expect(version(doc1).compare(version(doc2))).toBe("equal")

package/src/__tests__/{store-reader.test.ts → reader.test.ts}

@@ -1,8 +1,8 @@
+import { RawPath, Schema } from "@kyneta/schema"
 import { describe, expect, it } from "vitest"
 import * as Y from "yjs"
-import { RawPath, Schema } from "@kyneta/schema"
-import { yjsStoreReader } from "../store-reader.js"
 import { ensureContainers } from "../populate.js"
+import { yjsReader } from "../reader.js"
 
 // ===========================================================================
 // Helpers
@@ -27,7 +27,7 @@ function setup(
       populateSeed(rootMap, schema, seed)
     })
   }
-  const reader = yjsStoreReader(doc, schema)
+  const reader = yjsReader(doc, schema)
   return { doc, reader }
 }
 
@@ -84,9 +84,9 @@ function populateField(
         for (const [childKey, childValue] of Object.entries(
           value as Record<string, unknown>,
         )) {
-          const childFieldSchema = (
-            structural.fields as Record<string, any>
-          )[childKey]
+          const childFieldSchema = (structural.fields as Record<string, any>)[
+            childKey
+          ]
           if (!childFieldSchema) continue
           populateField(childMap, childKey, childFieldSchema, childValue)
         }
@@ -100,10 +100,7 @@ function populateField(
       if (arr && Array.isArray(value)) {
         for (const item of value) {
           const itemSchema = structural.item
-          if (
-            itemSchema &&
-            unwrapAnnotations(itemSchema)._kind === "product"
-          ) {
+          if (itemSchema && unwrapAnnotations(itemSchema)._kind === "product") {
             // Struct items: create a Y.Map for each
             const itemMap = buildStructMap(
               unwrapAnnotations(itemSchema),
@@ -153,8 +150,7 @@ function buildStructMap(
     const value = seed[key]
     if (value === undefined) continue
 
-    const tag =
-      fieldSchema._kind === "annotated" ? fieldSchema.tag : undefined
+    const tag = fieldSchema._kind === "annotated" ? fieldSchema.tag : undefined
     if (tag === "text") {
       const text = new Y.Text()
       if (typeof value === "string" && value.length > 0) {
@@ -302,7 +298,7 @@ const MixedSchema = Schema.doc({
 // Tests
 // ===========================================================================
 
-describe("YjsStoreReader", () => {
+describe("YjsReader", () => {
   // -------------------------------------------------------------------------
   // read
   // -------------------------------------------------------------------------
@@ -347,12 +343,8 @@ describe("YjsStoreReader", () => {
       })
       expect(reader.read(p("profile", "first"))).toBe("Jane")
       expect(reader.read(p("profile", "last"))).toBe("Doe")
-      expect(
-        reader.read(p("profile", "address", "city")),
-      ).toBe("Portland")
-      expect(
-        reader.read(p("profile", "address", "zip")),
-      ).toBe("97201")
+      expect(reader.read(p("profile", "address", "city"))).toBe("Portland")
+      expect(reader.read(p("profile", "address", "zip"))).toBe("97201")
     })
 
     it("reads nested struct as plain object", () => {
@@ -395,14 +387,9 @@ describe("YjsStoreReader", () => {
           { name: "Task 2", done: true },
         ],
       })
-      expect(reader.read(p("structs", 0, "name"))).toBe(
-        "Task 1",
-      )
+      expect(reader.read(p("structs", 0, "name"))).toBe("Task 1")
       expect(reader.read(p("structs", 1, "done"))).toBe(true)
-      const item = reader.read(p("structs", 0)) as Record<
-        string,
-        unknown
-      >
+      const item = reader.read(p("structs", 0)) as Record<string, unknown>
       expect(item.name).toBe("Task 1")
       expect(item.done).toBe(false)
     })
@@ -468,7 +455,11 @@ describe("YjsStoreReader", () => {
     })
 
     it("returns 0 for non-list paths", () => {
-      const { reader } = setup(ScalarSchema, { name: "test", count: 0, active: true })
+      const { reader } = setup(ScalarSchema, {
+        name: "test",
+        count: 0,
+        active: true,
+      })
       expect(reader.arrayLength(p("name"))).toBe(0)
     })
   })
@@ -516,7 +507,11 @@ describe("YjsStoreReader", () => {
     })
 
     it("returns empty array for non-map paths", () => {
-      const { reader } = setup(ScalarSchema, { name: "test", count: 0, active: true })
+      const { reader } = setup(ScalarSchema, {
+        name: "test",
+        count: 0,
+        active: true,
+      })
       expect(reader.keys(p("name"))).toEqual([])
     })
   })
@@ -564,7 +559,11 @@ describe("YjsStoreReader", () => {
     })
 
     it("returns false for non-map paths", () => {
-      const { reader } = setup(ScalarSchema, { name: "test", count: 0, active: true })
+      const { reader } = setup(ScalarSchema, {
+        name: "test",
+        count: 0,
+        active: true,
+      })
       expect(reader.hasKey(p("name"), "anything")).toBe(false)
     })
   })
@@ -655,9 +654,7 @@ describe("YjsStoreReader", () => {
       const profile = rootMap.get("profile") as Y.Map<unknown>
       const address = profile.get("address") as Y.Map<string>
       address.set("city", "Seattle")
-      expect(
-        reader.read(p("profile", "address", "city")),
-      ).toBe("Seattle")
+      expect(reader.read(p("profile", "address", "city"))).toBe("Seattle")
     })
 
     it("list delete + insert mutations are immediately visible", () => {
@@ -719,4 +716,4 @@ describe("YjsStoreReader", () => {
       expect(reader.keys(p("labels"))).toEqual(["priority"])
     })
   })
-})
+})

package/src/__tests__/record-text-spike.test.ts

@@ -18,16 +18,16 @@
 
 import { describe, expect, it } from "vitest"
 import {
+  change,
   createYjsDoc,
-  createYjsDocFromSnapshot,
-  version,
-  exportSnapshot,
+  createYjsDocFromEntirety,
+  exportEntirety,
   exportSince,
-  importDelta,
-  change,
+  merge,
+  Schema,
   subscribe,
   text,
-  Schema,
+  version,
 } from "../index.js"
 
 // ===========================================================================
@@ -114,8 +114,8 @@ describe("record-of-struct (plain baseline)", () => {
       d.profiles.set("alice", { displayName: "Alice", age: 30 })
     })
 
-    const snapshot = exportSnapshot(docA)
-    const docB = createYjsDocFromSnapshot(PlainRecordSchema, snapshot)
+    const snapshot = exportEntirety(docA)
+    const docB = createYjsDocFromEntirety(PlainRecordSchema, snapshot)
 
     expect(docB.profiles()).toEqual({
       alice: { displayName: "Alice", age: 30 },
@@ -130,7 +130,10 @@ describe("record-of-struct (plain baseline)", () => {
     })
 
     // Establish docB from snapshot (avoids Yjs clientID collision)
-    const docB = createYjsDocFromSnapshot(PlainRecordSchema, exportSnapshot(docA))
+    const docB = createYjsDocFromEntirety(
+      PlainRecordSchema,
+      exportEntirety(docA),
+    )
 
     const v0 = version(docB)
 
@@ -140,7 +143,7 @@ describe("record-of-struct (plain baseline)", () => {
 
     const delta = exportSince(docA, v0)
     expect(delta).not.toBeNull()
-    importDelta(docB, delta!, "sync")
+    merge(docB, delta!, "sync")
 
     expect(docB.profiles()).toEqual({
       alice: { displayName: "Alice", age: 30 },
@@ -246,7 +249,9 @@ describe("text-inside-struct-inside-record", () => {
     })
 
     let fired = false
-    subscribe(doc, () => { fired = true })
+    subscribe(doc, () => {
+      fired = true
+    })
 
     change(doc, (d: any) => {
       d.profiles.at("alice").bio.insert(0, "Hello")
@@ -265,8 +270,8 @@ describe("text-inside-struct-inside-record", () => {
       d.profiles.at("alice").bio.insert(0, "Collaborative bio")
     })
 
-    const snapshot = exportSnapshot(docA)
-    const docB = createYjsDocFromSnapshot(ProfileSchema, snapshot)
+    const snapshot = exportEntirety(docA)
+    const docB = createYjsDocFromEntirety(ProfileSchema, snapshot)
 
     expect(docB.profiles()).toEqual({
       alice: { displayName: "Alice", bio: "Collaborative bio" },
@@ -286,7 +291,7 @@ describe("text-inside-struct-inside-record", () => {
     // Establish docB from snapshot (consistent with Yjs test patterns —
     // two independently-created Y.Docs may share a clientID, causing
     // silent update drops)
-    const docB = createYjsDocFromSnapshot(ProfileSchema, exportSnapshot(docA))
+    const docB = createYjsDocFromEntirety(ProfileSchema, exportEntirety(docA))
     const v0 = version(docB)
 
     change(docA, (d: any) => {
@@ -295,7 +300,7 @@ describe("text-inside-struct-inside-record", () => {
 
     const delta = exportSince(docA, v0)
     expect(delta).not.toBeNull()
-    importDelta(docB, delta!, "sync")
+    merge(docB, delta!, "sync")
 
     expect(docB.profiles()).toEqual({
       alice: { displayName: "Alice", bio: "Hello from A" },
@@ -315,7 +320,7 @@ describe("text-inside-struct-inside-record", () => {
     change(docA, (d: any) => {
       d.profiles.set("alice", { displayName: "Alice" })
     })
-    const docB = createYjsDocFromSnapshot(ProfileSchema, exportSnapshot(docA))
+    const docB = createYjsDocFromEntirety(ProfileSchema, exportEntirety(docA))
 
     // Both peers edit concurrently
     const vA = version(docA)
@@ -333,8 +338,8 @@ describe("text-inside-struct-inside-record", () => {
     const deltaBA = exportSince(docB, vA)
     expect(deltaAB).not.toBeNull()
     expect(deltaBA).not.toBeNull()
-    importDelta(docB, deltaAB!, "sync")
-    importDelta(docA, deltaBA!, "sync")
+    merge(docB, deltaAB!, "sync")
+    merge(docA, deltaBA!, "sync")
 
     // Both converge to the same value (order depends on client IDs)
     expect((docA as any).profiles.at("alice").bio()).toBe(
@@ -411,7 +416,10 @@ describe("text-inside-struct-inside-list", () => {
     })
 
     // Establish docB from snapshot (avoids Yjs clientID collision)
-    const docB = createYjsDocFromSnapshot(ListProfileSchema, exportSnapshot(docA))
+    const docB = createYjsDocFromEntirety(
+      ListProfileSchema,
+      exportEntirety(docA),
+    )
     const v0 = version(docB)
 
     change(docA, (d: any) => {
@@ -420,10 +428,10 @@ describe("text-inside-struct-inside-list", () => {
 
     const delta = exportSince(docA, v0)
     expect(delta).not.toBeNull()
-    importDelta(docB, delta!, "sync")
+    merge(docB, delta!, "sync")
 
     expect(docB.players.length).toBe(1)
     expect((docB as any).players.at(0).name()).toBe("Alice")
     expect((docB as any).players.at(0).bio()).toBe("Synced bio")
   })
-})
+})