@kyneta/yjs-schema 1.0.0 → 1.2.0

package/src/bind-yjs.ts

@@ -1,36 +1,46 @@
-// bind-yjs — bindYjs() convenience wrapper for Yjs CRDT substrate.
+// bind-yjs — Yjs CRDT substrate namespace and factory.
 //
-// Binds a schema to the Yjs substrate with causal merge strategy.
-// The factory builder accepts { peerId } and returns a SubstrateFactory
-// that sets doc.clientID on every new Y.Doc, ensuring deterministic
-// peer identity across all documents in an exchange.
+// Provides the `yjs` substrate namespace (`yjs.bind()`, `yjs.replica()`,
+// `yjs.unwrap()`) and the internal factory builder that injects a
+// deterministic numeric Yjs clientID derived from the exchange's peerId.
 //
 // Yjs clientID is a uint32 number. We use FNV-1a hash truncated to
 // 32 bits, mirroring the Loro binding's hashPeerId pattern but
 // targeting Yjs's number type (not Loro's bigint/53-bit PeerID).
 //
 // Usage:
-//   import { bindYjs } from "@kyneta/yjs-schema"
+//   import { yjs } from "@kyneta/yjs-schema"
 //
-//   const TodoDoc = bindYjs(Schema.doc({
-//     title: Schema.annotated("text"),
+//   const TodoDoc = yjs.bind(Schema.struct({
+//     title: Schema.text(),
 //     items: Schema.list(Schema.struct({ name: Schema.string() })),
 //   }))
 //
 //   const doc = exchange.get("my-doc", TodoDoc)
 
-import { bind } from "@kyneta/schema"
-import type { BoundSchema } from "@kyneta/schema"
-import type { Schema as SchemaNode } from "@kyneta/schema"
 import type {
+  CrdtStrategy,
+  Replica,
+  Schema as SchemaNode,
   Substrate,
   SubstrateFactory,
+  SubstrateNamespace,
   SubstratePayload,
 } from "@kyneta/schema"
+import {
+  BACKING_DOC,
+  createSubstrateNamespace,
+  STRUCTURAL_YJS_CLIENT_ID,
+  unwrap,
+} from "@kyneta/schema"
 import * as Y from "yjs"
-import { createYjsSubstrate } from "./substrate.js"
-import { YjsVersion } from "./version.js"
 import { ensureContainers } from "./populate.js"
+import {
+  createYjsReplica,
+  createYjsSubstrate,
+  yjsReplicaFactory,
+} from "./substrate.js"
+import { YjsVersion } from "./version.js"
 
 // ---------------------------------------------------------------------------
 // Peer ID hashing — deterministic string → numeric Yjs clientID
@@ -55,7 +65,9 @@ function hashPeerId(peerId: string): number {
     hash = Math.imul(hash, 0x01000193)
   }
   // Ensure unsigned 32-bit integer
-  return hash >>> 0
+  const result = hash >>> 0
+  // Reserve 0 for structural ops — real peers never collide
+  return result === STRUCTURAL_YJS_CLIENT_ID ? 1 : result
 }
 
 // ---------------------------------------------------------------------------
@@ -67,36 +79,50 @@ function hashPeerId(peerId: string): number {
  * on every new Y.Doc with a deterministic uint32 clientID derived
  * from the exchange's string peerId.
  */
-function createYjsFactory(
-  peerId: string,
-): SubstrateFactory<YjsVersion> {
+function createYjsFactory(peerId: string): SubstrateFactory<YjsVersion> {
   const numericClientId = hashPeerId(peerId)
 
   return {
+    replica: yjsReplicaFactory,
+
+    createReplica(): Replica<YjsVersion> {
+      // Default random clientID — safe for hydration (no local writes).
+      // Identity is set at upgrade() time, after hydration.
+      return createYjsReplica(new Y.Doc())
+    },
+
+    upgrade(
+      replica: Replica<YjsVersion>,
+      schema: SchemaNode,
+    ): Substrate<YjsVersion> {
+      const doc = (replica as any)[BACKING_DOC] as Y.Doc
+      // Set stable identity AFTER hydration — avoids Yjs clientID
+      // conflict detection that would reassign to a random value.
+      doc.clientID = numericClientId
+      // Conditional ensureContainers: skip fields that already exist
+      // from hydrated state (each set() is a CRDT write).
+      ensureContainers(doc, schema, true)
+      return createYjsSubstrate(doc, schema)
+    },
+
     create(schema: SchemaNode): Substrate<YjsVersion> {
+      // Fresh doc — set identity immediately, unconditional containers.
       const doc = new Y.Doc()
       doc.clientID = numericClientId
-
       ensureContainers(doc, schema)
       return createYjsSubstrate(doc, schema)
     },
 
-    fromSnapshot(
+    fromEntirety(
       payload: SubstratePayload,
       schema: SchemaNode,
     ): Substrate<YjsVersion> {
-      if (
-        payload.encoding !== "binary" ||
-        !(payload.data instanceof Uint8Array)
-      ) {
-        throw new Error(
-          "YjsSubstrateFactory.fromSnapshot only supports binary-encoded payloads",
-        )
-      }
-      const doc = new Y.Doc()
-      doc.clientID = numericClientId
-      Y.applyUpdate(doc, payload.data)
-      return createYjsSubstrate(doc, schema)
+      // Two-phase path: createReplica → merge → upgrade
+      // Identity is set at upgrade() time, after hydration —
+      // avoids Yjs clientID conflict detection.
+      const replica = this.createReplica()
+      replica.merge(payload)
+      return this.upgrade(replica, schema)
     },
 
     parseVersion(serialized: string): YjsVersion {
@@ -106,42 +132,67 @@ function createYjsFactory(
 }
 
 // ---------------------------------------------------------------------------
-// bindYjs — the convenience wrapper
+// yjs — the Yjs CRDT substrate namespace
 // ---------------------------------------------------------------------------
 
 /**
- * Bind a schema to the Yjs CRDT substrate with causal merge strategy.
- *
- * This is the recommended way to declare a Yjs-backed document type.
- * The factory builder injects a deterministic numeric Yjs clientID derived
- * from the exchange's string peerId, ensuring consistent change attribution
- * across all documents and sessions.
- *
- * **Unsupported annotations:** Yjs has no native counter, movable list,
- * or tree types. Schemas passed to `bindYjs` must not contain
- * `Schema.annotated("counter")`, `Schema.annotated("movable")`, or
- * `Schema.annotated("tree")`. These will throw at construction time.
+ * The Yjs CRDT substrate namespace.
  *
- * @example
- * ```ts
- * import { bindYjs } from "@kyneta/yjs-schema"
- * import { Schema } from "@kyneta/schema"
+ * - `yjs.bind(schema)` — collaborative sync (default)
+ * - `yjs.bind(schema, "ephemeral")` — ephemeral/presence broadcast
+ * - `yjs.replica()` — collaborative replication (default)
+ * - `yjs.replica("ephemeral")` — ephemeral replication
+ * - `yjs.unwrap(ref)` — access the underlying Y.Doc
  *
- * const TodoDoc = bindYjs(Schema.doc({
- *   title: Schema.annotated("text"),
- *   items: Schema.list(Schema.struct({
- *     name: Schema.string(),
- *     done: Schema.boolean(),
- *   })),
- * }))
- *
- * const doc = exchange.get("my-todos", TodoDoc)
- * ```
+ * Strategy is constrained to `CrdtStrategy` (`"collaborative" | "ephemeral"`).
+ * Passing `"authoritative"` is a compile error.
  */
-export function bindYjs<S extends SchemaNode>(schema: S): BoundSchema<S> {
-  return bind({
-    schema,
-    factory: (ctx) => createYjsFactory(ctx.peerId),
-    strategy: "causal",
-  })
-}
+/** The closed set of capability tags that the Yjs substrate supports. */
+export type YjsCaps = "text" | "json"
+
+export const yjs: SubstrateNamespace<CrdtStrategy, YjsCaps> & {
+  /** Access the underlying `Y.Doc` backing a ref. */
+  unwrap(ref: object): Y.Doc
+} = {
+  ...createSubstrateNamespace<CrdtStrategy, YjsCaps>({
+    strategies: {
+      collaborative: {
+        factory: ctx => createYjsFactory(ctx.peerId),
+        replicaFactory: yjsReplicaFactory,
+      },
+      ephemeral: {
+        factory: ctx => createYjsFactory(ctx.peerId),
+        replicaFactory: yjsReplicaFactory,
+      },
+    },
+    defaultStrategy: "collaborative",
+  }),
+
+  unwrap(ref: object): Y.Doc {
+    let substrate: any
+    try {
+      substrate = unwrap(ref)
+    } catch {
+      throw new Error(
+        "yjs.unwrap() requires a ref backed by a Yjs substrate. " +
+          "Use a doc created by exchange.get() with a yjs.bind() schema, " +
+          "or by createYjsDoc().",
+      )
+    }
+
+    const doc = substrate[BACKING_DOC]
+    if (
+      !doc ||
+      typeof doc !== "object" ||
+      typeof (doc as any).getMap !== "function" ||
+      typeof (doc as any).clientID !== "number"
+    ) {
+      throw new Error(
+        "yjs.unwrap() requires a ref backed by a Yjs substrate. " +
+          "The ref has a substrate but it is not a Yjs substrate. " +
+          "Use a doc created with a yjs.bind() schema or createYjsDoc().",
+      )
+    }
+    return doc as Y.Doc
+  },
+}

package/src/change-mapping.ts

@@ -16,7 +16,6 @@
 // This produces a single observeDeep event with the complete struct,
 // rather than a cascade of child MapChange events.
 
-import { advanceSchema, expandMapOpsToLeaves } from "@kyneta/schema"
 import type {
   ChangeBase,
   IncrementChange,
@@ -30,7 +29,7 @@ import type {
   TextChange,
   TextInstruction,
 } from "@kyneta/schema"
-import { RawPath } from "@kyneta/schema"
+import { advanceSchema, expandMapOpsToLeaves, KIND, RawPath } from "@kyneta/schema"
 import * as Y from "yjs"
 import { resolveYjsType } from "./yjs-resolve.js"
 
@@ -75,15 +74,15 @@ export function applyChangeToYjs(
 
     case "increment":
       throw new Error(
-        "Yjs substrate does not support counter annotations. " +
-          "Use Schema.number() with ReplaceChange instead. " +
+        `Yjs substrate does not support "${change.type}" changes. ` +
+          `Counter requires a CRDT backend that supports counters (e.g. Loro). ` +
           `Attempted IncrementChange with amount=${(change as IncrementChange).amount} at path [${pathToString(path)}].`,
       )
 
     case "tree":
       throw new Error(
-        "Yjs substrate does not support tree annotations. " +
-          "Yjs has no native tree type. " +
+        `Yjs substrate does not support "${change.type}" changes. ` +
+          `Tree requires a CRDT backend that supports trees (e.g. Loro). ` +
           `Attempted TreeChange at path [${pathToString(path)}].`,
       )
 
@@ -146,7 +145,7 @@ function applySequenceChange(
       // cursor stays — deleted items shift remaining items down
     } else if ("insert" in instruction) {
       const items = instruction.insert as readonly unknown[]
-      const yjsItems = items.map((item) =>
+      const yjsItems = items.map(item =>
         maybeCreateSharedType(item, itemSchema),
       )
       resolved.insert(cursor, yjsItems)
@@ -251,26 +250,16 @@ function maybeCreateSharedType(
 ): unknown {
   if (schema === undefined) return value
 
-  const structural = unwrapAnnotations(schema)
-  const tag = schema._kind === "annotated" ? schema.tag : undefined
-
-  // Annotated text → Y.Text
-  if (tag === "text") {
-    const text = new Y.Text()
-    if (typeof value === "string" && value.length > 0) {
-      text.insert(0, value)
+  switch (schema[KIND]) {
+    // First-class text → Y.Text
+    case "text": {
+      const text = new Y.Text()
+      if (typeof value === "string" && value.length > 0) {
+        text.insert(0, value)
+      }
+      return text
     }
-    return text
-  }
 
-  // Annotated counter/movable/tree → should not reach here (thrown earlier)
-  if (tag === "counter" || tag === "movable" || tag === "tree") {
-    throw new Error(
-      `Yjs substrate does not support "${tag}" annotations.`,
-    )
-  }
-
-  switch (structural._kind) {
     case "product": {
       if (
         value === null ||
@@ -280,17 +269,14 @@ function maybeCreateSharedType(
       ) {
         return value
       }
-      return createStructuredMap(
-        value as Record<string, unknown>,
-        structural,
-      )
+      return createStructuredMap(value as Record<string, unknown>, schema)
     }
 
     case "sequence": {
       if (!Array.isArray(value)) return value
       const arr = new Y.Array()
-      const itemSchema = structural.item
-      const items = (value as unknown[]).map((item) =>
+      const itemSchema = schema.item
+      const items = (value as unknown[]).map(item =>
         maybeCreateSharedType(item, itemSchema),
       )
       arr.insert(0, items)
@@ -307,17 +293,26 @@ function maybeCreateSharedType(
         return value
       }
       const map = new Y.Map()
-      const valueSchema = structural.item
-      for (const [k, v] of Object.entries(
-        value as Record<string, unknown>,
-      )) {
+      const valueSchema = schema.item
+      for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
         map.set(k, maybeCreateSharedType(v, valueSchema))
       }
       return map
     }
 
+    // Unsupported first-class CRDT types — should not reach here
+    // (rejected at bind time by caps check)
+    case "counter":
+    case "set":
+    case "tree":
+    case "movable":
+      throw new Error(
+        `Yjs substrate does not support [KIND]="${schema[KIND]}". ` +
+          `This should have been caught at bind() time.`,
+      )
+
     default:
-      // Scalar, sum, or other — return as plain value
+      // Scalar, sum — return as plain value
       return value
   }
 }
@@ -334,9 +329,8 @@ function createStructuredMap(
   productSchema: SchemaNode,
 ): Y.Map<any> {
   const map = new Y.Map()
-  const structural = unwrapAnnotations(productSchema)
 
-  if (structural._kind !== "product") {
+  if (productSchema[KIND] !== "product") {
     // Fallback: set all values as plain
     for (const [key, val] of Object.entries(obj)) {
       map.set(key, val)
@@ -347,28 +341,22 @@ function createStructuredMap(
   // Process fields present in the value object
   for (const [key, val] of Object.entries(obj)) {
     if (val === undefined) continue
-    const fieldSchema = structural.fields[key]
-    const yjsVal = fieldSchema
-      ? maybeCreateSharedType(val, fieldSchema)
-      : val
+    const fieldSchema = productSchema.fields[key]
+    const yjsVal = fieldSchema ? maybeCreateSharedType(val, fieldSchema) : val
     map.set(key, yjsVal)
   }
 
-  // Create shared types for annotated fields declared in the schema
+  // Create shared types for first-class CRDT fields declared in the schema
   // but missing from the value object. This ensures Yjs containers
   // exist for later mutation (e.g. .insert() on a text field inside
   // a struct inside a record/list).
   for (const [key, fieldSchema] of Object.entries(
-    structural.fields as Record<string, SchemaNode>,
+    productSchema.fields as Record<string, SchemaNode>,
   )) {
     if (key in obj) continue // already processed above
-    const tag =
-      fieldSchema._kind === "annotated" ? fieldSchema.tag : undefined
-    if (tag === "text") {
+    if (fieldSchema[KIND] === "text") {
       map.set(key, new Y.Text())
     }
-    // Other annotated container types (counter, movable, tree) are
-    // unsupported in Yjs and will throw if used elsewhere.
   }
 
   return map
@@ -391,7 +379,7 @@ function createStructuredMap(
  *
  * @param events - The events from the `observeDeep` callback
  */
-export function eventsToOps(events: Y.YEvent<any>[]): Op[] {
+export function eventsToOps(events: Y.YEvent<any>[], schema: SchemaNode): Op[] {
   const ops: Op[] = []
 
   for (const event of events) {
@@ -402,7 +390,7 @@ export function eventsToOps(events: Y.YEvent<any>[]): Op[] {
     }
   }
 
-  return expandMapOpsToLeaves(ops)
+  return expandMapOpsToLeaves(ops, schema)
 }
 
 // ---------------------------------------------------------------------------
@@ -512,18 +500,16 @@ function mapEventToChange(event: Y.YEvent<any>): MapChange | null {
 
   const target = event.target as Y.Map<any>
 
-  event.changes.keys.forEach(
-    (change: { action: string }, key: string) => {
-      if (change.action === "add" || change.action === "update") {
-        const value = target.get(key)
-        set[key] = extractEventValue(value)
-        hasSet = true
-      } else if (change.action === "delete") {
-        deleteKeys.push(key)
-        hasDelete = true
-      }
-    },
-  )
+  event.changes.keys.forEach((change: { action: string }, key: string) => {
+    if (change.action === "add" || change.action === "update") {
+      const value = target.get(key)
+      set[key] = extractEventValue(value)
+      hasSet = true
+    } else if (change.action === "delete") {
+      deleteKeys.push(key)
+      hasDelete = true
+    }
+  })
 
   if (!hasSet && !hasDelete) return null
 
@@ -554,17 +540,6 @@ function extractEventValue(value: unknown): unknown {
 // Schema helpers
 // ---------------------------------------------------------------------------
 
-/**
- * Unwrap annotation wrappers to reach the structural schema node.
- */
-function unwrapAnnotations(schema: SchemaNode): SchemaNode {
-  let s = schema
-  while (s._kind === "annotated" && s.schema !== undefined) {
-    s = s.schema
-  }
-  return s
-}
-
 /**
  * Resolve the schema at a given path by walking through advanceSchema.
  */
@@ -580,8 +555,9 @@ function resolveSchemaAtPath(rootSchema: SchemaNode, path: Path): SchemaNode {
  * Get the item schema from a sequence schema, if available.
  */
 function getItemSchema(schema: SchemaNode): SchemaNode | undefined {
-  const structural = unwrapAnnotations(schema)
-  return structural._kind === "sequence" ? structural.item : undefined
+  if (schema[KIND] === "sequence") return schema.item
+  if (schema[KIND] === "movable") return schema.item
+  return undefined
 }
 
 /**
@@ -591,12 +567,14 @@ function getFieldSchema(
   schema: SchemaNode,
   key: string,
 ): SchemaNode | undefined {
-  const structural = unwrapAnnotations(schema)
-  if (structural._kind === "product") {
-    return structural.fields[key]
+  if (schema[KIND] === "product") {
+    return schema.fields[key]
+  }
+  if (schema[KIND] === "map") {
+    return schema.item
   }
-  if (structural._kind === "map") {
-    return structural.item
+  if (schema[KIND] === "set") {
+    return schema.item
   }
   return undefined
 }
@@ -606,7 +584,5 @@ function getFieldSchema(
 // ---------------------------------------------------------------------------
 
 function pathToString(path: Path): string {
-  return path.segments
-    .map((seg) => String(seg.resolve()))
-    .join(".")
+  return path.segments.map(seg => String(seg.resolve())).join(".")
 }

package/src/create.ts

@@ -1,10 +1,10 @@
 // create — batteries-included document construction backed by YjsSubstrate.
 //
-// Provides `createYjsDoc` and `createYjsDocFromSnapshot` functions that
+// Provides `createYjsDoc` and `createYjsDocFromEntirety` functions that
 // hide the interpret pipeline and layer composition behind a single call.
 //
 // Internally tracks substrates via a module-scoped WeakMap so that sync
-// primitives (`version`, `exportSnapshot`, `importDelta` in sync.ts)
+// primitives (`version`, `exportEntirety`, `merge` in sync.ts)
 // can retrieve the substrate from just a doc ref.
 //
 // `getSubstrate` is exported for use by `sync.ts` but is NOT re-exported
@@ -14,14 +14,22 @@
 //   createYjsDoc(schema, yjsDoc)    — "bring your own doc" (wrap existing)
 //   createYjsDoc(schema)            — create a fresh empty Y.Doc
 
-import { interpret, registerSubstrate } from "@kyneta/schema"
-import { changefeed, readable, writable } from "@kyneta/schema"
-import type { Ref } from "@kyneta/schema"
-import type { Schema as SchemaType } from "@kyneta/schema"
-import type { Substrate, SubstratePayload } from "@kyneta/schema"
-import * as Y from "yjs"
-import { YjsVersion } from "./version.js"
+import type {
+  Ref,
+  Schema as SchemaType,
+  Substrate,
+  SubstratePayload,
+} from "@kyneta/schema"
+import {
+  interpret,
+  observation,
+  readable,
+  registerSubstrate,
+  writable,
+} from "@kyneta/schema"
+import type * as Y from "yjs"
 import { createYjsSubstrate, yjsSubstrateFactory } from "./substrate.js"
+import type { YjsVersion } from "./version.js"
 
 // ---------------------------------------------------------------------------
 // Substrate tracking (module-scoped)
@@ -31,18 +39,18 @@ const substrates = new WeakMap<object, Substrate<YjsVersion>>()
 
 /**
  * Retrieve the substrate associated with a doc created by `createYjsDoc`
- * or `createYjsDocFromSnapshot`.
+ * or `createYjsDocFromEntirety`.
  *
  * Exported for `sync.ts` — NOT re-exported from the barrel.
  *
- * @throws If `doc` was not created by `createYjsDoc` / `createYjsDocFromSnapshot`.
+ * @throws If `doc` was not created by `createYjsDoc` / `createYjsDocFromEntirety`.
  */
 export function getSubstrate(doc: object): Substrate<YjsVersion> {
   const s = substrates.get(doc)
   if (!s) {
     throw new Error(
-      "version/exportSnapshot/importDelta called on an object without a YjsSubstrate. " +
-        "Use a doc created by createYjsDoc() or createYjsDocFromSnapshot().",
+      "version/exportEntirety/merge called on an object without a YjsSubstrate. " +
+        "Use a doc created by createYjsDoc() or createYjsDocFromEntirety().",
     )
   }
   return s
@@ -58,12 +66,12 @@ function registerDoc(
 ): any {
   // The `as any` on the builder avoids TS2589 — interpret's fluent API
   // produces deeply recursive types when S is the abstract SchemaType.
-  // The public createYjsDoc/createYjsDocFromSnapshot signatures provide
+  // The public createYjsDoc/createYjsDocFromEntirety signatures provide
   // the correct Ref<S> return type via interface call signature patterns.
   const doc: any = (interpret as any)(schema, substrate.context())
     .with(readable)
     .with(writable)
-    .with(changefeed)
+    .with(observation)
     .done()
   substrates.set(doc, substrate)
   // Also register in the general unwrap() registry so that the
@@ -123,17 +131,14 @@ function isYDoc(value: unknown): value is Y.Doc {
  * CRDT collaboration support.
  *
  * The returned ref observes **all** mutations to the underlying Y.Doc,
- * regardless of source (local kyneta writes, importDelta, external
+ * regardless of source (local kyneta writes, merge, external
  * `Y.applyUpdate()`, external raw Yjs API mutations).
  *
  * @param schema - The schema describing the document structure.
  * @param doc - Optional `Y.Doc` instance to wrap. If omitted, a fresh
  *   empty Y.Doc is created with containers matching the schema.
  */
-type CreateYjsDoc = <S extends SchemaType>(
-  schema: S,
-  doc?: Y.Doc,
-) => Ref<S>
+type CreateYjsDoc = <S extends SchemaType>(schema: S, doc?: Y.Doc) => Ref<S>
 
 export const createYjsDoc: CreateYjsDoc = (schema, doc) => {
   if (doc !== undefined && isYDoc(doc)) {
@@ -145,28 +150,28 @@ export const createYjsDoc: CreateYjsDoc = (schema, doc) => {
 }
 
 // ---------------------------------------------------------------------------
-// createYjsDocFromSnapshot
+// createYjsDocFromEntirety
 // ---------------------------------------------------------------------------
 
-type CreateYjsDocFromSnapshot = <S extends SchemaType>(
+type CreateYjsDocFromEntirety = <S extends SchemaType>(
   schema: S,
   payload: SubstratePayload,
 ) => Ref<S>
 
 /**
- * Reconstruct a live Yjs-backed document from a substrate snapshot payload.
+ * Reconstruct a live Yjs-backed document from a substrate entirety payload.
  *
- * The payload must have been produced by `exportSnapshot()` on a
+ * The payload must have been produced by `exportEntirety()` on a
  * compatible document. This is the entry point for SSR hydration
  * and reconnection past log compaction.
  *
  * ```ts
- * const payload = exportSnapshot(docA)
- * const docB = createYjsDocFromSnapshot(MySchema, payload)
+ * const payload = exportEntirety(docA)
+ * const docB = createYjsDocFromEntirety(MySchema, payload)
  * // docB has the same state as docA at the time of export
  * ```
  */
-export const createYjsDocFromSnapshot: CreateYjsDocFromSnapshot = (
+export const createYjsDocFromEntirety: CreateYjsDocFromEntirety = (
   schema,
   payload,
-) => registerDoc(schema, yjsSubstrateFactory.fromSnapshot(payload, schema))
+) => registerDoc(schema, yjsSubstrateFactory.fromEntirety(payload, schema))