@kyneta/yjs-schema 1.0.0 → 1.2.0

package/src/__tests__/create.test.ts

@@ -1,24 +1,23 @@
-import { describe, expect, it, vi } from "vitest"
+import { change, Schema, subscribe } from "@kyneta/schema"
+import { describe, expect, it } 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 { yjs } from "../bind-yjs.js"
+import { createYjsDoc, createYjsDocFromEntirety } from "../create.js"
 import { ensureContainers } from "../populate.js"
-import { yjsSubstrateFactory } from "../substrate.js"
-import { yjs } from "../yjs-escape.js"
+import { exportEntirety, exportSince, merge, version } from "../sync.js"
+import { YjsVersion } from "../version.js"
 
 // ===========================================================================
 // Schemas used across tests
 // ===========================================================================
 
-const SimpleSchema = Schema.doc({
-  title: Schema.annotated("text"),
+const SimpleSchema = Schema.struct({
+  title: Schema.text(),
   count: Schema.number(),
   items: Schema.list(Schema.string()),
 })
 
-const StructListSchema = Schema.doc({
+const StructListSchema = Schema.struct({
   tasks: Schema.list(
     Schema.struct({
       name: Schema.string(),
@@ -27,8 +26,8 @@ const StructListSchema = Schema.doc({
   ),
 })
 
-const NestedSchema = Schema.doc({
-  title: Schema.annotated("text"),
+const NestedSchema = Schema.struct({
+  title: Schema.text(),
   meta: Schema.struct({
     author: Schema.string(),
     tags: Schema.list(Schema.string()),
@@ -179,12 +178,12 @@ describe("createYjsDoc", () => {
       expect(doc.count()).toBe(77)
     })
 
-    it("yjs() escape hatch returns the same Y.Doc", () => {
+    it("yjs.unwrap() escape hatch returns the same Y.Doc", () => {
       const yjsDoc = new Y.Doc()
       ensureContainers(yjsDoc, SimpleSchema)
 
       const doc = createYjsDoc(SimpleSchema, yjsDoc)
-      const escaped = yjs(doc)
+      const escaped = yjs.unwrap(doc)
 
       expect(escaped).toBe(yjsDoc)
     })
@@ -192,10 +191,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 +204,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 +224,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 +242,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 +257,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 +270,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 +287,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 +329,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 +339,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)
 
@@ -367,9 +372,9 @@ describe("sync primitives", () => {
       // Export delta and apply to doc2
       const delta = exportSince(doc1, v2Before)
       expect(delta).not.toBeNull()
-      expect(delta!.encoding).toBe("binary")
+      expect(delta?.encoding).toBe("binary")
 
-      importDelta(doc2, delta!)
+      merge(doc2, delta!)
 
       expect(doc2.title()).toBe("Start Edited")
       expect(doc2.count()).toBe(42)
@@ -378,37 +383,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 +430,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 +450,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 +459,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 +489,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 +505,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 +529,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 +550,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 +570,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 +599,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 +620,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 { KIND, 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
@@ -16,7 +16,7 @@ import { ensureContainers } from "../populate.js"
  * values. We populate values via raw Yjs API within a single transact.
  */
 function setup(
-  schema: ReturnType<typeof Schema.doc>,
+  schema: any,
   seed?: Record<string, unknown>,
 ) {
   const doc = new Y.Doc()
@@ -27,7 +27,7 @@ function setup(
       populateSeed(rootMap, schema, seed)
     })
   }
-  const reader = yjsStoreReader(doc, schema)
+  const reader = yjsReader(doc, schema)
   return { doc, reader }
 }
 
@@ -42,11 +42,11 @@ function setup(
  */
 function populateSeed(
   ymap: Y.Map<unknown>,
-  schema: ReturnType<typeof Schema.doc>,
+  schema: any,
   seed: Record<string, unknown>,
 ) {
-  const rootProduct = unwrapToProduct(schema)
-  if (!rootProduct) return
+  if (schema[KIND] !== "product") return
+  const rootProduct = schema
 
   for (const [key, value] of Object.entries(seed)) {
     if (value === undefined) continue
@@ -63,20 +63,15 @@ function populateField(
   fieldSchema: any,
   value: unknown,
 ) {
-  const tag = fieldSchema._kind === "annotated" ? fieldSchema.tag : undefined
-
-  if (tag === "text") {
-    // Text field — the Y.Text was already created by ensureContainers
-    const text = ymap.get(key) as Y.Text
-    if (text && typeof value === "string" && value.length > 0) {
-      text.insert(0, value)
+  switch (fieldSchema[KIND]) {
+    case "text": {
+      // Text field — the Y.Text was already created by ensureContainers
+      const text = ymap.get(key) as Y.Text
+      if (text && typeof value === "string" && value.length > 0) {
+        text.insert(0, value)
+      }
+      return
     }
-    return
-  }
-
-  const structural = unwrapAnnotations(fieldSchema)
-
-  switch (structural._kind) {
     case "product": {
       // Struct — recurse into the existing Y.Map
       const childMap = ymap.get(key) as Y.Map<unknown>
@@ -84,9 +79,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 = (fieldSchema.fields as Record<string, any>)[
+            childKey
+          ]
           if (!childFieldSchema) continue
           populateField(childMap, childKey, childFieldSchema, childValue)
         }
@@ -99,14 +94,11 @@ function populateField(
       const arr = ymap.get(key) as Y.Array<unknown>
       if (arr && Array.isArray(value)) {
         for (const item of value) {
-          const itemSchema = structural.item
-          if (
-            itemSchema &&
-            unwrapAnnotations(itemSchema)._kind === "product"
-          ) {
+          const itemSchema = fieldSchema.item
+          if (itemSchema && itemSchema[KIND] === "product") {
             // Struct items: create a Y.Map for each
             const itemMap = buildStructMap(
-              unwrapAnnotations(itemSchema),
+              itemSchema,
               item as Record<string, unknown>,
             )
             arr.push([itemMap])
@@ -153,23 +145,19 @@ function buildStructMap(
     const value = seed[key]
     if (value === undefined) continue
 
-    const tag =
-      fieldSchema._kind === "annotated" ? fieldSchema.tag : undefined
-    if (tag === "text") {
-      const text = new Y.Text()
-      if (typeof value === "string" && value.length > 0) {
-        text.insert(0, value)
+    switch (fieldSchema[KIND]) {
+      case "text": {
+        const text = new Y.Text()
+        if (typeof value === "string" && value.length > 0) {
+          text.insert(0, value)
+        }
+        map.set(key, text)
+        break
       }
-      map.set(key, text)
-      continue
-    }
-
-    const structural = unwrapAnnotations(fieldSchema)
-    switch (structural._kind) {
       case "product": {
         map.set(
           key,
-          buildStructMap(structural, value as Record<string, unknown>),
+          buildStructMap(fieldSchema, value as Record<string, unknown>),
         )
         break
       }
@@ -177,14 +165,14 @@ function buildStructMap(
         const arr = new Y.Array()
         if (Array.isArray(value)) {
           for (const item of value) {
-            const itemSchema = structural.element ?? structural.schema
+            const itemSchema = fieldSchema.item
             if (
               itemSchema &&
-              unwrapAnnotations(itemSchema)._kind === "product"
+              itemSchema[KIND] === "product"
             ) {
               arr.push([
                 buildStructMap(
-                  unwrapAnnotations(itemSchema),
+                  itemSchema,
                   item as Record<string, unknown>,
                 ),
               ])
@@ -216,22 +204,7 @@ function buildStructMap(
   return map
 }
 
-function unwrapToProduct(schema: any): any {
-  let s = schema
-  while (s._kind === "annotated" && s.schema !== undefined) {
-    s = s.schema
-  }
-  if (s._kind === "product") return s
-  return null
-}
 
-function unwrapAnnotations(schema: any): any {
-  let s = schema
-  while (s._kind === "annotated" && s.schema !== undefined) {
-    s = s.schema
-  }
-  return s
-}
 
 /** Build a RawPath from variadic key/index segments. */
 function p(...segs: (string | number)[]): RawPath {
@@ -246,18 +219,18 @@ function p(...segs: (string | number)[]): RawPath {
 // Schemas used across tests
 // ===========================================================================
 
-const TextSchema = Schema.doc({
-  title: Schema.annotated("text"),
-  subtitle: Schema.annotated("text"),
+const TextSchema = Schema.struct({
+  title: Schema.text(),
+  subtitle: Schema.text(),
 })
 
-const ScalarSchema = Schema.doc({
+const ScalarSchema = Schema.struct({
   name: Schema.string(),
   count: Schema.number(),
   active: Schema.boolean(),
 })
 
-const NestedStructSchema = Schema.doc({
+const NestedStructSchema = Schema.struct({
   profile: Schema.struct({
     first: Schema.string(),
     last: Schema.string(),
@@ -268,7 +241,7 @@ const NestedStructSchema = Schema.doc({
   }),
 })
 
-const ListSchema = Schema.doc({
+const ListSchema = Schema.struct({
   items: Schema.list(Schema.string()),
   structs: Schema.list(
     Schema.struct({
@@ -278,12 +251,12 @@ const ListSchema = Schema.doc({
   ),
 })
 
-const MapSchema = Schema.doc({
+const MapSchema = Schema.struct({
   labels: Schema.record(Schema.string()),
 })
 
-const MixedSchema = Schema.doc({
-  title: Schema.annotated("text"),
+const MixedSchema = Schema.struct({
+  title: Schema.text(),
   count: Schema.number(),
   items: Schema.list(
     Schema.struct({
@@ -302,7 +275,7 @@ const MixedSchema = Schema.doc({
 // Tests
 // ===========================================================================
 
-describe("YjsStoreReader", () => {
+describe("YjsReader", () => {
   // -------------------------------------------------------------------------
   // read
   // -------------------------------------------------------------------------
@@ -347,12 +320,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 +364,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 +432,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 +484,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 +536,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 +631,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 +693,4 @@ describe("YjsStoreReader", () => {
       expect(reader.keys(p("labels"))).toEqual(["priority"])
     })
   })
-})
+})