@kyneta/yjs-schema 1.2.0 → 1.3.1

package/src/__tests__/bind-yjs.test.ts

@@ -1,8 +1,20 @@
-import { change, RawPath, Schema } from "@kyneta/schema"
+import {
+  change,
+  createRef,
+  exportEntirety,
+  RawPath,
+  Schema,
+  unwrap,
+} from "@kyneta/schema"
 import { describe, expect, it } from "vitest"
 import * as Y from "yjs"
 import { yjs } from "../bind-yjs.js"
-import { createYjsDoc } from "../create.js"
+
+// ===========================================================================
+// Helper — createDoc using the generic API
+// ===========================================================================
+
+import { createDoc } from "@kyneta/schema"
 
 // ===========================================================================
 // Schemas used across tests
@@ -83,8 +95,7 @@ describe("yjs.bind", () => {
         d.title.insert(0, "Snap")
         d.count.set(42)
       })
-      const substrate1 = (unwrap as any)(doc1)
-      const snapshot = substrate1.exportEntirety()
+      const snapshot = exportEntirety(doc1)
 
       // Restore
       const substrate2 = factory.fromEntirety(snapshot, SimpleSchema)
@@ -117,8 +128,12 @@ describe("yjs.bind", () => {
       const _s2 = factory.create(SimpleSchema)
 
       // Both docs should have the same clientID
-      const doc1 = yjs.unwrap(createYjsDocFromFactory(factory, SimpleSchema))
-      const doc2 = yjs.unwrap(createYjsDocFromFactory(factory, SimpleSchema))
+      const doc1 = unwrap(
+        createYjsDocFromFactory(factory, SimpleSchema),
+      ) as Y.Doc
+      const doc2 = unwrap(
+        createYjsDocFromFactory(factory, SimpleSchema),
+      ) as Y.Doc
 
       expect(doc1.clientID).toBe(doc2.clientID)
     })
@@ -128,8 +143,12 @@ describe("yjs.bind", () => {
       const factory1 = bound.factory({ peerId: "peer-alpha" })
       const factory2 = bound.factory({ peerId: "peer-beta" })
 
-      const doc1 = yjs.unwrap(createYjsDocFromFactory(factory1, SimpleSchema))
-      const doc2 = yjs.unwrap(createYjsDocFromFactory(factory2, SimpleSchema))
+      const doc1 = unwrap(
+        createYjsDocFromFactory(factory1, SimpleSchema),
+      ) as Y.Doc
+      const doc2 = unwrap(
+        createYjsDocFromFactory(factory2, SimpleSchema),
+      ) as Y.Doc
 
       expect(doc1.clientID).not.toBe(doc2.clientID)
     })
@@ -137,7 +156,9 @@ describe("yjs.bind", () => {
     it("clientID is a valid uint32", () => {
       const bound = yjs.bind(SimpleSchema)
       const factory = bound.factory({ peerId: "test-peer-id-12345" })
-      const doc = yjs.unwrap(createYjsDocFromFactory(factory, SimpleSchema))
+      const doc = unwrap(
+        createYjsDocFromFactory(factory, SimpleSchema),
+      ) as Y.Doc
 
       expect(typeof doc.clientID).toBe("number")
       expect(doc.clientID).toBeGreaterThanOrEqual(0)
@@ -151,61 +172,70 @@ describe("yjs.bind", () => {
       // Simulate two separate "sessions" — both should hash to the same value
       const bound1 = yjs.bind(SimpleSchema)
       const factory1 = bound1.factory({ peerId })
-      const doc1 = yjs.unwrap(createYjsDocFromFactory(factory1, SimpleSchema))
+      const doc1 = unwrap(
+        createYjsDocFromFactory(factory1, SimpleSchema),
+      ) as Y.Doc
 
       const bound2 = yjs.bind(SimpleSchema)
       const factory2 = bound2.factory({ peerId })
-      const doc2 = yjs.unwrap(createYjsDocFromFactory(factory2, SimpleSchema))
+      const doc2 = unwrap(
+        createYjsDocFromFactory(factory2, SimpleSchema),
+      ) as Y.Doc
 
       expect(doc1.clientID).toBe(doc2.clientID)
     })
   })
 
   // -------------------------------------------------------------------------
-  // yjs() escape hatch
+  // unwrap() escape hatch
   // -------------------------------------------------------------------------
 
-  describe("yjs.unwrap() escape hatch", () => {
-    it("returns the underlying Y.Doc from a createYjsDoc ref", () => {
-      const doc = createYjsDoc(SimpleSchema)
+  describe("unwrap() escape hatch", () => {
+    it("returns the underlying Y.Doc from a createDoc ref", () => {
+      const doc = createDoc(yjs.bind(SimpleSchema))
       change(doc, (d: any) => {
         d.title.insert(0, "Escape")
         d.count.set(0)
       })
-      const yjsDoc = yjs.unwrap(doc)
+      const yjsDoc = unwrap(doc) as Y.Doc
 
       expect(yjsDoc).toBeInstanceOf(Y.Doc)
       expect(yjsDoc.getMap("root").get("count")).toBe(0)
     })
 
     it("returns a Y.Doc with the correct root map state", () => {
-      const doc = createYjsDoc(SimpleSchema)
+      const doc = createDoc(yjs.bind(SimpleSchema))
       change(doc, (d: any) => {
         d.title.insert(0, "Hello")
         d.count.set(42)
       })
-      const yjsDoc = yjs.unwrap(doc)
+      const yjsDoc = unwrap(doc) as Y.Doc
       const rootMap = yjsDoc.getMap("root")
 
       expect((rootMap.get("title") as Y.Text).toJSON()).toBe("Hello")
       expect(rootMap.get("count")).toBe(42)
     })
 
-    it("throws for non-Yjs refs (plain object)", () => {
-      expect(() => yjs.unwrap({})).toThrow("yjs.unwrap() requires a ref")
+    it("returns undefined for non-refs (plain object)", () => {
+      expect(unwrap({} as any)).toBeUndefined()
     })
 
-    it("throws for non-Yjs refs (random object with properties)", () => {
+    it("returns undefined for non-refs (random object with properties)", () => {
       const fake = {
         title: () => "fake",
         count: () => 0,
       }
-      expect(() => yjs.unwrap(fake)).toThrow("yjs.unwrap() requires a ref")
+      expect(unwrap(fake as any)).toBeUndefined()
+    })
+
+    it("throws for primitives", () => {
+      expect(() => unwrap(null as any)).toThrow("unwrap() requires a ref")
+      expect(() => unwrap(undefined as any)).toThrow("unwrap() requires a ref")
     })
 
     it("mutations through escape hatch are visible via kyneta ref", () => {
-      const doc = createYjsDoc(SimpleSchema)
-      const yjsDoc = yjs.unwrap(doc)
+      const doc = createDoc(yjs.bind(SimpleSchema))
+      const yjsDoc = unwrap(doc) as Y.Doc
 
       // Mutate via raw Yjs
       yjsDoc.getMap("root").set("count", 99)
@@ -213,11 +243,11 @@ describe("yjs.bind", () => {
     })
 
     it("text mutations through escape hatch are visible", () => {
-      const doc = createYjsDoc(SimpleSchema)
+      const doc = createDoc(yjs.bind(SimpleSchema))
       change(doc, (d: any) => {
         d.title.insert(0, "Hello")
       })
-      const yjsDoc = yjs.unwrap(doc)
+      const yjsDoc = unwrap(doc) as Y.Doc
 
       const text = yjsDoc.getMap("root").get("title") as Y.Text
       text.insert(5, " World")
@@ -231,14 +261,6 @@ describe("yjs.bind", () => {
 // ===========================================================================
 
 import type { Schema as SchemaType, SubstrateFactory } from "@kyneta/schema"
-import {
-  interpret,
-  observation,
-  readable,
-  registerSubstrate,
-  unwrap,
-  writable,
-} from "@kyneta/schema"
 
 /**
  * Helper to create a kyneta ref from a factory (mimicking what exchange.get does).
@@ -249,16 +271,5 @@ function createYjsDocFromFactory(
   schema: SchemaType,
 ): any {
   const substrate = factory.create(schema)
-  const doc: any = (interpret as any)(schema, substrate.context())
-    .with(readable)
-    .with(writable)
-    .with(observation)
-    .done()
-
-  // Register for escape hatch — createYjsSubstrate already registered
-  // substrate → Y.Doc internally, but we also need ref → substrate
-  // for unwrap() (used by the yjs() escape hatch).
-  registerSubstrate(doc, substrate)
-
-  return doc
+  return createRef(schema, substrate)
 }

package/src/__tests__/create.test.ts

@@ -1,10 +1,17 @@
-import { change, Schema, subscribe } from "@kyneta/schema"
+import {
+  change,
+  createDoc,
+  createRef,
+  Schema,
+  subscribe,
+  unwrap,
+} from "@kyneta/schema"
 import { describe, expect, it } from "vitest"
 import * as Y from "yjs"
 import { yjs } from "../bind-yjs.js"
-import { createYjsDoc, createYjsDocFromEntirety } from "../create.js"
+import { exportEntirety, exportSince, merge, version } from "../index.js"
 import { ensureContainers } from "../populate.js"
-import { exportEntirety, exportSince, merge, version } from "../sync.js"
+import { createYjsSubstrate } from "../substrate.js"
 import { YjsVersion } from "../version.js"
 
 // ===========================================================================
@@ -35,18 +42,26 @@ const NestedSchema = Schema.struct({
   labels: Schema.record(Schema.string()),
 })
 
+// ===========================================================================
+// Helpers
+// ===========================================================================
+
+const boundSimple = yjs.bind(SimpleSchema)
+const boundStructList = yjs.bind(StructListSchema)
+const boundNested = yjs.bind(NestedSchema)
+
 // ===========================================================================
 // Tests
 // ===========================================================================
 
-describe("createYjsDoc", () => {
+describe("createDoc", () => {
   // -------------------------------------------------------------------------
   // Default values
   // -------------------------------------------------------------------------
 
   describe("with defaults", () => {
     it("creates a doc with empty containers for shared types", () => {
-      const doc = createYjsDoc(SimpleSchema)
+      const doc = createDoc(boundSimple)
       // Text annotation returns "" (empty Y.Text)
       expect(doc.title()).toBe("")
       // Plain scalars return structural zeros
@@ -56,7 +71,7 @@ describe("createYjsDoc", () => {
     })
 
     it("creates a doc with nested struct empty containers", () => {
-      const doc = createYjsDoc(NestedSchema)
+      const doc = createDoc(boundNested)
       expect(doc.title()).toBe("")
       // Plain scalar inside struct returns structural zero
       expect(doc.meta.author()).toBe("")
@@ -65,7 +80,7 @@ describe("createYjsDoc", () => {
     })
 
     it("creates a doc with struct list defaults", () => {
-      const doc = createYjsDoc(StructListSchema)
+      const doc = createDoc(boundStructList)
       expect(doc.tasks()).toEqual([])
       expect(doc.tasks.length).toBe(0)
     })
@@ -77,7 +92,7 @@ describe("createYjsDoc", () => {
 
   describe("with seeds", () => {
     it("creates a doc with scalar seed values", () => {
-      const doc = createYjsDoc(SimpleSchema)
+      const doc = createDoc(boundSimple)
       change(doc, (d: any) => {
         d.title.insert(0, "Hello")
         d.count.set(42)
@@ -93,7 +108,7 @@ describe("createYjsDoc", () => {
     })
 
     it("creates a doc with partial seed (defaults fill gaps)", () => {
-      const doc = createYjsDoc(SimpleSchema)
+      const doc = createDoc(boundSimple)
       change(doc, (d: any) => {
         d.title.insert(0, "Partial")
       })
@@ -103,7 +118,7 @@ describe("createYjsDoc", () => {
     })
 
     it("creates a doc with nested struct seed", () => {
-      const doc = createYjsDoc(NestedSchema)
+      const doc = createDoc(boundNested)
       change(doc, (d: any) => {
         d.title.insert(0, "Doc")
         d.meta.author.set("Alice")
@@ -118,7 +133,7 @@ describe("createYjsDoc", () => {
     })
 
     it("creates a doc with struct list seed items", () => {
-      const doc = createYjsDoc(StructListSchema)
+      const doc = createDoc(boundStructList)
       // Separate change() calls for list pushes to preserve order
       change(doc, (d: any) => d.tasks.push({ name: "Task 1", done: false }))
       change(doc, (d: any) => d.tasks.push({ name: "Task 2", done: true }))
@@ -145,7 +160,10 @@ describe("createYjsDoc", () => {
         ;(rootMap.get("items") as Y.Array<string>).push(["x"])
       })
 
-      const doc = createYjsDoc(SimpleSchema, yjsDoc)
+      const doc = createRef(
+        SimpleSchema,
+        createYjsSubstrate(yjsDoc, SimpleSchema),
+      )
       expect(doc.title()).toBe("External")
       expect(doc.count()).toBe(99)
       expect(doc.items()).toEqual(["x"])
@@ -155,7 +173,10 @@ describe("createYjsDoc", () => {
       const yjsDoc = new Y.Doc()
       ensureContainers(yjsDoc, SimpleSchema)
 
-      const doc = createYjsDoc(SimpleSchema, yjsDoc)
+      const doc = createRef(
+        SimpleSchema,
+        createYjsSubstrate(yjsDoc, SimpleSchema),
+      )
       change(doc, (d: any) => {
         d.title.insert(0, "Hello")
         d.count.set(42)
@@ -170,7 +191,10 @@ describe("createYjsDoc", () => {
       const yjsDoc = new Y.Doc()
       ensureContainers(yjsDoc, SimpleSchema)
 
-      const doc = createYjsDoc(SimpleSchema, yjsDoc)
+      const doc = createRef(
+        SimpleSchema,
+        createYjsSubstrate(yjsDoc, SimpleSchema),
+      )
 
       const rootMap = yjsDoc.getMap("root")
       rootMap.set("count", 77)
@@ -178,12 +202,15 @@ describe("createYjsDoc", () => {
       expect(doc.count()).toBe(77)
     })
 
-    it("yjs.unwrap() escape hatch returns the same Y.Doc", () => {
+    it("unwrap() escape hatch returns the same Y.Doc", () => {
       const yjsDoc = new Y.Doc()
       ensureContainers(yjsDoc, SimpleSchema)
 
-      const doc = createYjsDoc(SimpleSchema, yjsDoc)
-      const escaped = yjs.unwrap(doc)
+      const doc = createRef(
+        SimpleSchema,
+        createYjsSubstrate(yjsDoc, SimpleSchema),
+      )
+      const escaped = unwrap(doc)
 
       expect(escaped).toBe(yjsDoc)
     })
@@ -191,12 +218,12 @@ describe("createYjsDoc", () => {
 })
 
 // ===========================================================================
-// createYjsDocFromEntirety
+// createDoc with payload (fromEntirety)
 // ===========================================================================
 
-describe("createYjsDocFromEntirety", () => {
+describe("createDoc with payload", () => {
   it("reconstructs state from a snapshot", () => {
-    const doc1 = createYjsDoc(SimpleSchema)
+    const doc1 = createDoc(boundSimple)
     change(doc1, (d: any) => {
       d.title.insert(0, "Snapshot")
       d.count.set(42)
@@ -205,7 +232,7 @@ describe("createYjsDocFromEntirety", () => {
     change(doc1, (d: any) => d.items.push("b"))
 
     const payload = exportEntirety(doc1)
-    const doc2 = createYjsDocFromEntirety(SimpleSchema, payload)
+    const doc2 = createDoc(boundSimple, payload)
 
     expect(doc2.title()).toBe("Snapshot")
     expect(doc2.count()).toBe(42)
@@ -213,7 +240,7 @@ describe("createYjsDocFromEntirety", () => {
   })
 
   it("reconstructs state after mutations", () => {
-    const doc1 = createYjsDoc(SimpleSchema)
+    const doc1 = createDoc(boundSimple)
     change(doc1, (d: any) => {
       d.title.insert(0, "Start")
     })
@@ -225,7 +252,7 @@ describe("createYjsDocFromEntirety", () => {
     })
 
     const payload = exportEntirety(doc1)
-    const doc2 = createYjsDocFromEntirety(SimpleSchema, payload)
+    const doc2 = createDoc(boundSimple, payload)
 
     expect(doc2.title()).toBe("Start End")
     expect(doc2.count()).toBe(99)
@@ -233,7 +260,7 @@ describe("createYjsDocFromEntirety", () => {
   })
 
   it("reconstructs nested struct state from snapshot", () => {
-    const doc1 = createYjsDoc(NestedSchema)
+    const doc1 = createDoc(boundNested)
     change(doc1, (d: any) => {
       d.title.insert(0, "Nested")
       d.meta.author.set("Alice")
@@ -243,7 +270,7 @@ describe("createYjsDocFromEntirety", () => {
     change(doc1, (d: any) => d.meta.tags.push("v2"))
 
     const payload = exportEntirety(doc1)
-    const doc2 = createYjsDocFromEntirety(NestedSchema, payload)
+    const doc2 = createDoc(boundNested, payload)
 
     expect(doc2.title()).toBe("Nested")
     expect(doc2.meta.author()).toBe("Alice")
@@ -253,12 +280,12 @@ describe("createYjsDocFromEntirety", () => {
   })
 
   it("reconstructs struct list state from snapshot", () => {
-    const doc1 = createYjsDoc(StructListSchema)
+    const doc1 = createDoc(boundStructList)
     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 = exportEntirety(doc1)
-    const doc2 = createYjsDocFromEntirety(StructListSchema, payload)
+    const doc2 = createDoc(boundStructList, payload)
 
     expect(doc2.tasks.length).toBe(2)
     expect((doc2.tasks.at(0) as any).name()).toBe("Task A")
@@ -266,12 +293,12 @@ describe("createYjsDocFromEntirety", () => {
   })
 
   it("is writable after reconstruction", () => {
-    const doc1 = createYjsDoc(SimpleSchema)
+    const doc1 = createDoc(boundSimple)
     change(doc1, (d: any) => {
       d.title.insert(0, "Original")
     })
     const payload = exportEntirety(doc1)
-    const doc2 = createYjsDocFromEntirety(SimpleSchema, payload)
+    const doc2 = createDoc(boundSimple, payload)
 
     change(doc2, (d: any) => {
       d.title.insert(8, " Copy")
@@ -283,12 +310,12 @@ describe("createYjsDocFromEntirety", () => {
   })
 
   it("is observable after reconstruction", () => {
-    const doc1 = createYjsDoc(SimpleSchema)
+    const doc1 = createDoc(boundSimple)
     change(doc1, (d: any) => {
       d.title.insert(0, "Original")
     })
     const payload = exportEntirety(doc1)
-    const doc2 = createYjsDocFromEntirety(SimpleSchema, payload)
+    const doc2 = createDoc(boundSimple, payload)
 
     const received: any[] = []
     subscribe(doc2, (changeset: any) => {
@@ -310,13 +337,13 @@ describe("createYjsDocFromEntirety", () => {
 describe("sync primitives", () => {
   describe("version", () => {
     it("returns a YjsVersion", () => {
-      const doc = createYjsDoc(SimpleSchema)
+      const doc = createDoc(boundSimple)
       const v = version(doc)
       expect(v).toBeInstanceOf(YjsVersion)
     })
 
     it("advances after mutations", () => {
-      const doc = createYjsDoc(SimpleSchema)
+      const doc = createDoc(boundSimple)
       const v1 = version(doc)
 
       change(doc, (d: any) => {
@@ -328,7 +355,7 @@ describe("sync primitives", () => {
     })
 
     it("serialize/parse round-trips", () => {
-      const doc = createYjsDoc(SimpleSchema)
+      const doc = createDoc(boundSimple)
       change(doc, (d: any) => {
         d.title.insert(0, "Test")
       })
@@ -341,7 +368,7 @@ describe("sync primitives", () => {
 
   describe("exportEntirety", () => {
     it("returns a binary payload", () => {
-      const doc = createYjsDoc(SimpleSchema)
+      const doc = createDoc(boundSimple)
       change(doc, (d: any) => {
         d.title.insert(0, "Snap")
       })
@@ -354,11 +381,11 @@ describe("sync primitives", () => {
 
   describe("exportSince + merge", () => {
     it("syncs incremental changes between two docs", () => {
-      const doc1 = createYjsDoc(SimpleSchema)
+      const doc1 = createDoc(boundSimple)
       change(doc1, (d: any) => {
         d.title.insert(0, "Start")
       })
-      const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
+      const doc2 = createDoc(boundSimple, exportEntirety(doc1))
 
       const v2Before = version(doc2)
 
@@ -382,8 +409,8 @@ describe("sync primitives", () => {
     })
 
     it("syncs multiple incremental deltas", () => {
-      const doc1 = createYjsDoc(SimpleSchema)
-      const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
+      const doc1 = createDoc(boundSimple)
+      const doc2 = createDoc(boundSimple, exportEntirety(doc1))
 
       // First round
       let vBefore = version(doc2)
@@ -411,11 +438,11 @@ describe("sync primitives", () => {
     })
 
     it("changefeed fires on merge", () => {
-      const doc1 = createYjsDoc(SimpleSchema)
+      const doc1 = createDoc(boundSimple)
       change(doc1, (d: any) => {
         d.title.insert(0, "Source")
       })
-      const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
+      const doc2 = createDoc(boundSimple, exportEntirety(doc1))
 
       const v2Before = version(doc2)
 
@@ -437,8 +464,8 @@ describe("sync primitives", () => {
     })
 
     it("merge passes origin to changefeed", () => {
-      const doc1 = createYjsDoc(SimpleSchema)
-      const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
+      const doc1 = createDoc(boundSimple)
+      const doc2 = createDoc(boundSimple, exportEntirety(doc1))
 
       const v2Before = version(doc2)
       change(doc1, (d: any) => {
@@ -458,7 +485,7 @@ describe("sync primitives", () => {
 
   describe("versions equal after sync", () => {
     it("versions equal after full snapshot sync", () => {
-      const doc1 = createYjsDoc(SimpleSchema)
+      const doc1 = createDoc(boundSimple)
       change(doc1, (d: any) => {
         d.title.insert(0, "Same")
       })
@@ -466,14 +493,14 @@ describe("sync primitives", () => {
         d.count.set(42)
       })
 
-      const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
+      const doc2 = createDoc(boundSimple, exportEntirety(doc1))
 
       expect(version(doc1).compare(version(doc2))).toBe("equal")
     })
 
     it("versions equal after bidirectional delta sync", () => {
-      const doc1 = createYjsDoc(SimpleSchema)
-      const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
+      const doc1 = createDoc(boundSimple)
+      const doc2 = createDoc(boundSimple, exportEntirety(doc1))
 
       const v1Before = version(doc1)
       const v2Before = version(doc2)
@@ -504,11 +531,8 @@ describe("sync primitives", () => {
 describe("full workflow", () => {
   it("create → mutate → sync → observe", () => {
     // 1. Create two docs
-    const doc1 = createYjsDoc(StructListSchema)
-    const doc2 = createYjsDocFromEntirety(
-      StructListSchema,
-      exportEntirety(doc1),
-    )
+    const doc1 = createDoc(boundStructList)
+    const doc2 = createDoc(boundStructList, exportEntirety(doc1))
 
     // 2. Set up observer on doc2
     const changes: any[] = []
@@ -559,7 +583,7 @@ describe("full workflow", () => {
 
   it("create → mutate → snapshot → reconstruct → continue", () => {
     // 1. Create and mutate
-    const doc1 = createYjsDoc(SimpleSchema)
+    const doc1 = createDoc(boundSimple)
     change(doc1, (d: any) => {
       d.title.insert(0, "Start")
     })
@@ -573,7 +597,7 @@ describe("full workflow", () => {
     const snapshot = exportEntirety(doc1)
 
     // 3. Reconstruct
-    const doc2 = createYjsDocFromEntirety(SimpleSchema, snapshot)
+    const doc2 = createDoc(boundSimple, snapshot)
     expect(doc2.title()).toBe("Start Middle")
     expect(doc2.count()).toBe(10)
     expect(doc2.items()).toEqual(["first"])
@@ -598,8 +622,8 @@ describe("full workflow", () => {
 
   it("concurrent edits converge correctly", () => {
     // 1. Create two peers from the same initial state
-    const doc1 = createYjsDoc(SimpleSchema)
-    const doc2 = createYjsDocFromEntirety(SimpleSchema, exportEntirety(doc1))
+    const doc1 = createDoc(boundSimple)
+    const doc2 = createDoc(boundSimple, exportEntirety(doc1))
 
     const v1Before = version(doc1)
     const v2Before = version(doc2)

package/src/__tests__/reader.test.ts

@@ -15,10 +15,7 @@ import { yjsReader } from "../reader.js"
  * After `ensureContainers` the doc has the correct shared types but no
  * values. We populate values via raw Yjs API within a single transact.
  */
-function setup(
-  schema: any,
-  seed?: Record<string, unknown>,
-) {
+function setup(schema: any, seed?: Record<string, unknown>) {
   const doc = new Y.Doc()
   ensureContainers(doc, schema)
   if (seed) {
@@ -166,15 +163,9 @@ function buildStructMap(
         if (Array.isArray(value)) {
           for (const item of value) {
             const itemSchema = fieldSchema.item
-            if (
-              itemSchema &&
-              itemSchema[KIND] === "product"
-            ) {
+            if (itemSchema && itemSchema[KIND] === "product") {
               arr.push([
-                buildStructMap(
-                  itemSchema,
-                  item as Record<string, unknown>,
-                ),
+                buildStructMap(itemSchema, item as Record<string, unknown>),
               ])
             } else {
               arr.push([item])
@@ -204,8 +195,6 @@ function buildStructMap(
   return map
 }
 
-
-
 /** Build a RawPath from variadic key/index segments. */
 function p(...segs: (string | number)[]): RawPath {
   let path = RawPath.empty