@kyneta/yjs-schema 1.1.0 → 1.3.0

package/dist/index.js

@@ -2,40 +2,150 @@
 import {
   applyChanges,
   change,
+  createDoc,
+  createRef,
+  exportEntirety,
+  exportSince,
+  merge,
+  NATIVE,
   Schema,
   subscribe,
-  subscribeNode
+  subscribeNode,
+  unwrap,
+  version
 } from "@kyneta/schema";
 
-// src/create.ts
+// src/bind-yjs.ts
 import {
-  changefeed,
-  interpret,
-  readable,
-  registerSubstrate,
-  writable
+  BACKING_DOC as BACKING_DOC2,
+  createSubstrateNamespace,
+  STRUCTURAL_YJS_CLIENT_ID as STRUCTURAL_YJS_CLIENT_ID2
 } from "@kyneta/schema";
+import * as Y6 from "yjs";
+
+// src/populate.ts
+import { KIND, STRUCTURAL_YJS_CLIENT_ID, Zero } from "@kyneta/schema";
+import * as Y from "yjs";
+function ensureContainers(doc, schema, conditional = false) {
+  const rootMap = doc.getMap("root");
+  if (schema[KIND] !== "product") {
+    return;
+  }
+  const savedClientID = doc.clientID;
+  doc.clientID = STRUCTURAL_YJS_CLIENT_ID;
+  try {
+    doc.transact(() => {
+      for (const [key, fieldSchema] of Object.entries(schema.fields).sort(
+        ([a], [b]) => a.localeCompare(b)
+      )) {
+        if (conditional && rootMap.has(key)) continue;
+        ensureRootField(rootMap, key, fieldSchema);
+      }
+    });
+  } finally {
+    doc.clientID = savedClientID;
+  }
+}
+function ensureRootField(rootMap, key, fieldSchema) {
+  switch (fieldSchema[KIND]) {
+    case "text":
+      rootMap.set(key, new Y.Text());
+      return;
+    case "product":
+      rootMap.set(key, ensureMapContainers(fieldSchema));
+      return;
+    case "sequence":
+      rootMap.set(key, new Y.Array());
+      return;
+    case "map":
+      rootMap.set(key, new Y.Map());
+      return;
+    case "scalar":
+    case "sum": {
+      const zero = Zero.structural(fieldSchema);
+      if (zero !== void 0) {
+        rootMap.set(key, zero);
+      }
+      return;
+    }
+    case "counter":
+    case "set":
+    case "tree":
+    case "movable":
+      throw new Error(
+        `Yjs substrate does not support [KIND]="${fieldSchema[KIND]}". Supported kinds: text, product, sequence, map, scalar, sum. Encountered unsupported kind at root field "${key}".`
+      );
+  }
+}
+function ensureMapContainers(schema) {
+  const map = new Y.Map();
+  if (schema[KIND] !== "product") return map;
+  for (const [key, fieldSchema] of Object.entries(
+    schema.fields
+  ).sort(([a], [b]) => a.localeCompare(b))) {
+    switch (fieldSchema[KIND]) {
+      case "text":
+        map.set(key, new Y.Text());
+        break;
+      case "product":
+        map.set(key, ensureMapContainers(fieldSchema));
+        break;
+      case "sequence":
+        map.set(key, new Y.Array());
+        break;
+      case "map":
+        map.set(key, new Y.Map());
+        break;
+      case "scalar":
+      case "sum": {
+        const zero = Zero.structural(fieldSchema);
+        if (zero !== void 0) {
+          map.set(key, zero);
+        }
+        break;
+      }
+      case "counter":
+      case "set":
+      case "tree":
+      case "movable":
+        throw new Error(
+          `Yjs substrate does not support [KIND]="${fieldSchema[KIND]}". Supported kinds: text, product, sequence, map, scalar, sum. Encountered unsupported kind at nested field "${key}".`
+        );
+    }
+  }
+  return map;
+}
 
 // src/substrate.ts
-import { BACKING_DOC, buildWritableContext, executeBatch } from "@kyneta/schema";
+import {
+  BACKING_DOC,
+  buildWritableContext,
+  executeBatch,
+  KIND as KIND3
+} from "@kyneta/schema";
 import * as Y5 from "yjs";
 
 // src/change-mapping.ts
-import { advanceSchema as advanceSchema2, expandMapOpsToLeaves, RawPath } from "@kyneta/schema";
-import * as Y2 from "yjs";
+import {
+  advanceSchema as advanceSchema2,
+  expandMapOpsToLeaves,
+  KIND as KIND2,
+  RawPath
+} from "@kyneta/schema";
+import * as Y3 from "yjs";
 
 // src/yjs-resolve.ts
 import { advanceSchema } from "@kyneta/schema";
-import * as Y from "yjs";
+import * as Y2 from "yjs";
 function stepIntoYjs(current, segment) {
   const resolved = segment.resolve();
-  if (current instanceof Y.Map) {
+  if (current instanceof Y2.Map) {
     return current.get(resolved);
   }
-  if (current instanceof Y.Array) {
+  if (current instanceof Y2.Array) {
     return current.get(resolved);
   }
-  if (current instanceof Y.Text) {
+  if (current instanceof Y2.Text) {
     throw new Error(`yjs-resolve: cannot step into Y.Text`);
   }
   return void 0;
@@ -43,10 +153,6 @@ function stepIntoYjs(current, segment) {
 function resolveYjsType(rootMap, rootSchema, path) {
   let current = rootMap;
   let schema = rootSchema;
-  let rootProduct = rootSchema;
-  while (rootProduct._kind === "annotated" && rootProduct.schema !== void 0) {
-    rootProduct = rootProduct.schema;
-  }
   for (let i = 0; i < path.length; i++) {
     const seg = path.segments[i];
     const nextSchema = advanceSchema(schema, seg);
@@ -73,11 +179,11 @@ function applyChangeToYjs(rootMap, rootSchema, path, change2) {
       return;
     case "increment":
       throw new Error(
-        `Yjs substrate does not support counter annotations. Use Schema.number() with ReplaceChange instead. Attempted IncrementChange with amount=${change2.amount} at path [${pathToString(path)}].`
+        `Yjs substrate does not support "${change2.type}" changes. Counter requires a CRDT backend that supports counters (e.g. Loro). Attempted IncrementChange with amount=${change2.amount} at path [${pathToString(path)}].`
       );
     case "tree":
       throw new Error(
-        `Yjs substrate does not support tree annotations. Yjs has no native tree type. Attempted TreeChange at path [${pathToString(path)}].`
+        `Yjs substrate does not support "${change2.type}" changes. Tree requires a CRDT backend that supports trees (e.g. Loro). Attempted TreeChange at path [${pathToString(path)}].`
       );
     default:
       throw new Error(
@@ -87,7 +193,7 @@ function applyChangeToYjs(rootMap, rootSchema, path, change2) {
 }
 function applyTextChange(rootMap, rootSchema, path, change2) {
   const resolved = resolveYjsType(rootMap, rootSchema, path);
-  if (!(resolved instanceof Y2.Text)) {
+  if (!(resolved instanceof Y3.Text)) {
     throw new Error(
       `applyChangeToYjs: TextChange target at path [${pathToString(path)}] is not a Y.Text`
     );
@@ -96,7 +202,7 @@ function applyTextChange(rootMap, rootSchema, path, change2) {
 }
 function applySequenceChange(rootMap, rootSchema, path, change2) {
   const resolved = resolveYjsType(rootMap, rootSchema, path);
-  if (!(resolved instanceof Y2.Array)) {
+  if (!(resolved instanceof Y3.Array)) {
     throw new Error(
       `applyChangeToYjs: SequenceChange target at path [${pathToString(path)}] is not a Y.Array`
     );
@@ -121,7 +227,7 @@ function applySequenceChange(rootMap, rootSchema, path, change2) {
 }
 function applyMapChange(rootMap, rootSchema, path, change2) {
   const resolved = resolveYjsType(rootMap, rootSchema, path);
-  if (!(resolved instanceof Y2.Map)) {
+  if (!(resolved instanceof Y3.Map)) {
     throw new Error(
       `applyChangeToYjs: MapChange target at path [${pathToString(path)}] is not a Y.Map`
     );
@@ -150,11 +256,11 @@ function applyReplaceChange(rootMap, rootSchema, path, change2) {
   const parentPath = path.slice(0, -1);
   const parent = resolveYjsType(rootMap, rootSchema, parentPath);
   const resolved = lastSeg.resolve();
-  if (parent instanceof Y2.Map && lastSeg.role === "key") {
+  if (parent instanceof Y3.Map && lastSeg.role === "key") {
     const targetSchema = resolveSchemaAtPath(rootSchema, path);
     const yjsValue = maybeCreateSharedType(change2.value, targetSchema);
     parent.set(resolved, yjsValue);
-  } else if (parent instanceof Y2.Array && lastSeg.role === "index") {
+  } else if (parent instanceof Y3.Array && lastSeg.role === "index") {
     const targetSchema = resolveSchemaAtPath(rootSchema, path);
     const yjsValue = maybeCreateSharedType(change2.value, targetSchema);
     parent.delete(resolved, 1);
@@ -167,29 +273,25 @@ function applyReplaceChange(rootMap, rootSchema, path, change2) {
 }
 function maybeCreateSharedType(value, schema) {
   if (schema === void 0) return value;
-  const structural = unwrapAnnotations(schema);
-  const tag = schema._kind === "annotated" ? schema.tag : void 0;
-  if (tag === "text") {
-    const text2 = new Y2.Text();
-    if (typeof value === "string" && value.length > 0) {
-      text2.insert(0, value);
+  switch (schema[KIND2]) {
+    // First-class text → Y.Text
+    case "text": {
+      const text = new Y3.Text();
+      if (typeof value === "string" && value.length > 0) {
+        text.insert(0, value);
+      }
+      return text;
     }
-    return text2;
-  }
-  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 || value === void 0 || typeof value !== "object" || Array.isArray(value)) {
         return value;
       }
-      return createStructuredMap(value, structural);
+      return createStructuredMap(value, schema);
     }
     case "sequence": {
       if (!Array.isArray(value)) return value;
-      const arr = new Y2.Array();
-      const itemSchema = structural.item;
+      const arr = new Y3.Array();
+      const itemSchema = schema.item;
       const items = value.map(
         (item) => maybeCreateSharedType(item, itemSchema)
       );
@@ -200,21 +302,29 @@ function maybeCreateSharedType(value, schema) {
       if (value === null || value === void 0 || typeof value !== "object" || Array.isArray(value)) {
         return value;
       }
-      const map = new Y2.Map();
-      const valueSchema = structural.item;
+      const map = new Y3.Map();
+      const valueSchema = schema.item;
       for (const [k, v] of Object.entries(value)) {
         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[KIND2]}". This should have been caught at bind() time.`
+      );
     default:
       return value;
   }
 }
 function createStructuredMap(obj, productSchema) {
-  const map = new Y2.Map();
-  const structural = unwrapAnnotations(productSchema);
-  if (structural._kind !== "product") {
+  const map = new Y3.Map();
+  if (productSchema[KIND2] !== "product") {
     for (const [key, val] of Object.entries(obj)) {
       map.set(key, val);
     }
@@ -222,22 +332,21 @@ function createStructuredMap(obj, productSchema) {
   }
   for (const [key, val] of Object.entries(obj)) {
     if (val === void 0) continue;
-    const fieldSchema = structural.fields[key];
+    const fieldSchema = productSchema.fields[key];
     const yjsVal = fieldSchema ? maybeCreateSharedType(val, fieldSchema) : val;
     map.set(key, yjsVal);
   }
   for (const [key, fieldSchema] of Object.entries(
-    structural.fields
+    productSchema.fields
   )) {
     if (key in obj) continue;
-    const tag = fieldSchema._kind === "annotated" ? fieldSchema.tag : void 0;
-    if (tag === "text") {
-      map.set(key, new Y2.Text());
+    if (fieldSchema[KIND2] === "text") {
+      map.set(key, new Y3.Text());
     }
   }
   return map;
 }
-function eventsToOps(events) {
+function eventsToOps(events, schema) {
   const ops = [];
   for (const event of events) {
     const kynetaPath = yjsPathToKynetaPath(event.path);
@@ -246,7 +355,7 @@ function eventsToOps(events) {
       ops.push({ path: kynetaPath, change: change2 });
     }
   }
-  return expandMapOpsToLeaves(ops);
+  return expandMapOpsToLeaves(ops, schema);
 }
 function yjsPathToKynetaPath(yjsPath) {
   let path = RawPath.empty;
@@ -260,13 +369,13 @@ function yjsPathToKynetaPath(yjsPath) {
   return path;
 }
 function eventToChange(event) {
-  if (event.target instanceof Y2.Text) {
+  if (event.target instanceof Y3.Text) {
     return textEventToChange(event);
   }
-  if (event.target instanceof Y2.Array) {
+  if (event.target instanceof Y3.Array) {
     return arrayEventToChange(event);
   }
-  if (event.target instanceof Y2.Map) {
+  if (event.target instanceof Y3.Map) {
     return mapEventToChange(event);
   }
   return null;
@@ -324,18 +433,11 @@ function mapEventToChange(event) {
   };
 }
 function extractEventValue(value) {
-  if (value instanceof Y2.Map) return value.toJSON();
-  if (value instanceof Y2.Array) return value.toJSON();
-  if (value instanceof Y2.Text) return value.toJSON();
+  if (value instanceof Y3.Map) return value.toJSON();
+  if (value instanceof Y3.Array) return value.toJSON();
+  if (value instanceof Y3.Text) return value.toJSON();
   return value;
 }
-function unwrapAnnotations(schema) {
-  let s = schema;
-  while (s._kind === "annotated" && s.schema !== void 0) {
-    s = s.schema;
-  }
-  return s;
-}
 function resolveSchemaAtPath(rootSchema, path) {
   let schema = rootSchema;
   for (const seg of path.segments) {
@@ -344,16 +446,19 @@ function resolveSchemaAtPath(rootSchema, path) {
   return schema;
 }
 function getItemSchema(schema) {
-  const structural = unwrapAnnotations(schema);
-  return structural._kind === "sequence" ? structural.item : void 0;
+  if (schema[KIND2] === "sequence") return schema.item;
+  if (schema[KIND2] === "movable") return schema.item;
+  return void 0;
 }
 function getFieldSchema(schema, key) {
-  const structural = unwrapAnnotations(schema);
-  if (structural._kind === "product") {
-    return structural.fields[key];
+  if (schema[KIND2] === "product") {
+    return schema.fields[key];
+  }
+  if (schema[KIND2] === "map") {
+    return schema.item;
   }
-  if (structural._kind === "map") {
-    return structural.item;
+  if (schema[KIND2] === "set") {
+    return schema.item;
   }
   return void 0;
 }
@@ -361,116 +466,6 @@ function pathToString(path) {
   return path.segments.map((seg) => String(seg.resolve())).join(".");
 }
 
-// src/populate.ts
-import { STRUCTURAL_YJS_CLIENT_ID, Zero } from "@kyneta/schema";
-import * as Y3 from "yjs";
-function ensureContainers(doc, schema, conditional = false) {
-  const rootMap = doc.getMap("root");
-  let rootProduct = schema;
-  while (rootProduct._kind === "annotated" && rootProduct.schema !== void 0) {
-    rootProduct = rootProduct.schema;
-  }
-  if (rootProduct._kind !== "product") {
-    return;
-  }
-  const savedClientID = doc.clientID;
-  doc.clientID = STRUCTURAL_YJS_CLIENT_ID;
-  try {
-    doc.transact(() => {
-      for (const [key, fieldSchema] of Object.entries(rootProduct.fields).sort(
-        ([a], [b]) => a.localeCompare(b)
-      )) {
-        if (conditional && rootMap.has(key)) continue;
-        ensureRootField(rootMap, key, fieldSchema);
-      }
-    });
-  } finally {
-    doc.clientID = savedClientID;
-  }
-}
-function ensureRootField(rootMap, key, fieldSchema) {
-  const tag = fieldSchema._kind === "annotated" ? fieldSchema.tag : void 0;
-  switch (tag) {
-    case "text":
-      rootMap.set(key, new Y3.Text());
-      return;
-    case "counter":
-      throw new Error(
-        `Yjs substrate does not support counter annotations. Use Schema.number() with ReplaceChange instead. Encountered counter annotation at root field "${key}".`
-      );
-    case "movable":
-      throw new Error(
-        `Yjs substrate does not support movable list annotations. Yjs has no native movable list type. Encountered movable annotation at root field "${key}".`
-      );
-    case "tree":
-      throw new Error(
-        `Yjs substrate does not support tree annotations. Yjs has no native tree type. Encountered tree annotation at root field "${key}".`
-      );
-  }
-  const structural = unwrapAnnotations2(fieldSchema);
-  switch (structural._kind) {
-    case "product":
-      rootMap.set(key, ensureMapContainers(structural));
-      return;
-    case "sequence":
-      rootMap.set(key, new Y3.Array());
-      return;
-    case "map":
-      rootMap.set(key, new Y3.Map());
-      return;
-    case "scalar":
-    case "sum": {
-      const zero = Zero.structural(fieldSchema);
-      if (zero !== void 0) {
-        rootMap.set(key, zero);
-      }
-      return;
-    }
-  }
-}
-function ensureMapContainers(schema) {
-  const map = new Y3.Map();
-  const structural = unwrapAnnotations2(schema);
-  if (structural._kind !== "product") return map;
-  for (const [key, fieldSchema] of Object.entries(
-    structural.fields
-  ).sort(([a], [b]) => a.localeCompare(b))) {
-    const tag = fieldSchema._kind === "annotated" ? fieldSchema.tag : void 0;
-    if (tag === "text") {
-      map.set(key, new Y3.Text());
-      continue;
-    }
-    const fs = unwrapAnnotations2(fieldSchema);
-    switch (fs._kind) {
-      case "product":
-        map.set(key, ensureMapContainers(fieldSchema));
-        break;
-      case "sequence":
-        map.set(key, new Y3.Array());
-        break;
-      case "map":
-        map.set(key, new Y3.Map());
-        break;
-      case "scalar":
-      case "sum": {
-        const zero = Zero.structural(fieldSchema);
-        if (zero !== void 0) {
-          map.set(key, zero);
-        }
-        break;
-      }
-    }
-  }
-  return map;
-}
-function unwrapAnnotations2(schema) {
-  let s = schema;
-  while (s._kind === "annotated" && s.schema !== void 0) {
-    s = s.schema;
-  }
-  return s;
-}
-
 // src/reader.ts
 import * as Y4 from "yjs";
 function extractValue(resolved) {
@@ -529,21 +524,28 @@ function yjsReader(doc, schema) {
 }
 
 // src/version.ts
+import {
+  base64ToUint8Array,
+  uint8ArrayToBase64,
+  versionVectorCompare,
+  versionVectorMeet
+} from "@kyneta/schema";
 import { decodeStateVector } from "yjs";
-function uint8ArrayToBase64(bytes) {
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) {
-    binary += String.fromCharCode(bytes[i]);
+function encodeStateVector(map) {
+  const bytes = [];
+  function writeVarUint(value) {
+    while (value > 127) {
+      bytes.push(value & 127 | 128);
+      value >>>= 7;
+    }
+    bytes.push(value & 127);
   }
-  return btoa(binary);
-}
-function base64ToUint8Array(base64) {
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
+  writeVarUint(map.size);
+  for (const [clientId, clock] of map) {
+    writeVarUint(clientId);
+    writeVarUint(clock);
   }
-  return bytes;
+  return new Uint8Array(bytes);
 }
 var YjsVersion = class _YjsVersion {
   sv;
@@ -562,45 +564,37 @@ var YjsVersion = class _YjsVersion {
   /**
    * Compare with another version using version-vector partial order.
    *
-   * Decodes both state vectors via `Y.decodeStateVector()` to get
-   * `Map<number, number>` (clientID → clock), then compares:
+   * Delegates to the shared `versionVectorCompare` utility after decoding
+   * both state vectors via `Y.decodeStateVector()`.
    *
-   * - Collect the union of all client IDs from both maps.
-   * - For each client, compare clocks (missing client = clock 0).
-   * - If all clocks in `this` ≤ `other` and at least one strictly less → `"behind"`
-   * - If all clocks in `this` ≥ `other` and at least one strictly greater → `"ahead"`
-   * - If all clocks equal → `"equal"`
-   * - Otherwise → `"concurrent"`
-   *
-   * Throws if `other` is not a `YjsVersion`.
+   * @throws If `other` is not a `YjsVersion`.
    */
   compare(other) {
     if (!(other instanceof _YjsVersion)) {
       throw new Error("YjsVersion can only be compared with another YjsVersion");
     }
+    return versionVectorCompare(
+      decodeStateVector(this.sv),
+      decodeStateVector(other.sv)
+    );
+  }
+  /**
+   * Greatest lower bound (lattice meet) of two Yjs versions.
+   *
+   * Decodes both state vectors, computes the component-wise minimum
+   * via the shared `versionVectorMeet` utility, and encodes the result
+   * back to a Yjs state vector.
+   *
+   * @throws If `other` is not a `YjsVersion`.
+   */
+  meet(other) {
+    if (!(other instanceof _YjsVersion)) {
+      throw new Error("YjsVersion can only be meet'd with another YjsVersion");
+    }
     const thisMap = decodeStateVector(this.sv);
     const otherMap = decodeStateVector(other.sv);
-    const allClients = /* @__PURE__ */ new Set();
-    for (const id of thisMap.keys()) allClients.add(id);
-    for (const id of otherMap.keys()) allClients.add(id);
-    let hasLess = false;
-    let hasGreater = false;
-    for (const clientId of allClients) {
-      const thisClock = thisMap.get(clientId) ?? 0;
-      const otherClock = otherMap.get(clientId) ?? 0;
-      if (thisClock < otherClock) {
-        hasLess = true;
-      }
-      if (thisClock > otherClock) {
-        hasGreater = true;
-      }
-      if (hasLess && hasGreater) {
-        return "concurrent";
-      }
-    }
-    if (hasLess && !hasGreater) return "behind";
-    if (hasGreater && !hasLess) return "ahead";
-    return "equal";
+    const result = versionVectorMeet(thisMap, otherMap);
+    return new _YjsVersion(encodeStateVector(result));
   }
   /**
    * Parse a serialized YjsVersion string back into a YjsVersion.
@@ -633,7 +627,7 @@ function createYjsSubstrate(doc, schema) {
         pendingChanges.push({ path, change: change2 });
       }
     },
-    onFlush(origin) {
+    onFlush(_origin) {
       if (!inOurTransaction && pendingChanges.length > 0) {
         inOurTransaction = true;
         try {
@@ -651,12 +645,26 @@ function createYjsSubstrate(doc, schema) {
     context() {
       if (!cachedCtx) {
         cachedCtx = buildWritableContext(substrate);
+        cachedCtx.nativeResolver = (nodeSchema, path) => {
+          if (path.segments.length === 0) return doc;
+          if (nodeSchema[KIND3] === "scalar" || nodeSchema[KIND3] === "sum")
+            return void 0;
+          return resolveYjsType(rootMap, schema, path);
+        };
       }
       return cachedCtx;
     },
     version() {
       return new YjsVersion(Y5.encodeStateVector(doc));
     },
+    baseVersion() {
+      return new YjsVersion(new Uint8Array([0]));
+    },
+    advance(_to) {
+      throw new Error(
+        "advance() on a live Yjs substrate is not yet supported. Use advance() on a YjsReplica instead."
+      );
+    },
     exportEntirety() {
       return {
         kind: "entirety",
@@ -690,7 +698,7 @@ function createYjsSubstrate(doc, schema) {
     if (transaction.origin === KYNETA_ORIGIN) {
       return;
     }
-    const ops = eventsToOps(events);
+    const ops = eventsToOps(events, schema);
     if (ops.length === 0) {
       return;
     }
@@ -706,21 +714,44 @@ function createYjsSubstrate(doc, schema) {
   return substrate;
 }
 function createYjsReplica(doc) {
+  let currentDoc = doc;
+  let currentBase = new YjsVersion(Y5.encodeStateVector(new Y5.Doc()));
   return {
-    [BACKING_DOC]: doc,
+    get [BACKING_DOC]() {
+      return currentDoc;
+    },
     version() {
-      return new YjsVersion(Y5.encodeStateVector(doc));
+      return new YjsVersion(Y5.encodeStateVector(currentDoc));
+    },
+    baseVersion() {
+      return currentBase;
+    },
+    advance(to) {
+      const baseCmp = currentBase.compare(to);
+      if (baseCmp === "ahead") {
+        throw new Error("advance(): target is behind base version");
+      }
+      const currentCmp = to.compare(this.version());
+      if (currentCmp === "ahead") {
+        throw new Error("advance(): target is ahead of current version");
+      }
+      if (currentCmp !== "equal") return;
+      const update = Y5.encodeStateAsUpdate(currentDoc);
+      const newDoc = new Y5.Doc();
+      Y5.applyUpdate(newDoc, update);
+      currentDoc = newDoc;
+      currentBase = new YjsVersion(Y5.encodeStateVector(currentDoc));
     },
     exportEntirety() {
       return {
         kind: "entirety",
         encoding: "binary",
-        data: Y5.encodeStateAsUpdate(doc)
+        data: Y5.encodeStateAsUpdate(currentDoc)
       };
     },
     exportSince(since) {
       try {
-        const bytes = Y5.encodeStateAsUpdate(doc, since.sv);
+        const bytes = Y5.encodeStateAsUpdate(currentDoc, since.sv);
         return { kind: "since", encoding: "binary", data: bytes };
       } catch {
         return null;
@@ -732,7 +763,7 @@ function createYjsReplica(doc) {
           "YjsReplica.merge expects binary-encoded payloads. If you recently switched CRDT backends, stale clients may be sending incompatible data."
         );
       }
-      Y5.applyUpdate(doc, payload.data);
+      Y5.applyUpdate(currentDoc, payload.data);
     }
   };
 }
@@ -780,55 +811,7 @@ var yjsSubstrateFactory = {
   }
 };
 
-// src/create.ts
-var substrates = /* @__PURE__ */ new WeakMap();
-function getSubstrate(doc) {
-  const s = substrates.get(doc);
-  if (!s) {
-    throw new Error(
-      "version/exportEntirety/merge called on an object without a YjsSubstrate. Use a doc created by createYjsDoc() or createYjsDocFromEntirety()."
-    );
-  }
-  return s;
-}
-function registerDoc(schema, substrate) {
-  const doc = interpret(schema, substrate.context()).with(readable).with(writable).with(changefeed).done();
-  substrates.set(doc, substrate);
-  registerSubstrate(doc, substrate);
-  return doc;
-}
-function isYDoc(value) {
-  return value !== null && value !== void 0 && typeof value === "object" && "getMap" in value && "getText" in value && "getArray" in value && "transact" in value && typeof value.transact === "function" && // Y.Doc has clientID; distinguish from other objects
-  "clientID" in value && typeof value.clientID === "number";
-}
-var createYjsDoc = (schema, doc) => {
-  if (doc !== void 0 && isYDoc(doc)) {
-    return registerDoc(schema, createYjsSubstrate(doc, schema));
-  }
-  return registerDoc(schema, yjsSubstrateFactory.create(schema));
-};
-var createYjsDocFromEntirety = (schema, payload) => registerDoc(schema, yjsSubstrateFactory.fromEntirety(payload, schema));
-
-// src/sync.ts
-function version(doc) {
-  return getSubstrate(doc).version();
-}
-function exportEntirety(doc) {
-  return getSubstrate(doc).exportEntirety();
-}
-function exportSince(doc, since) {
-  return getSubstrate(doc).exportSince(since);
-}
-function merge(doc, payload, origin) {
-  getSubstrate(doc).merge(payload, origin);
-}
-
-// src/index.ts
-import { Schema as Schema2 } from "@kyneta/schema";
-
 // src/bind-yjs.ts
-import { BACKING_DOC as BACKING_DOC2, bind, STRUCTURAL_YJS_CLIENT_ID as STRUCTURAL_YJS_CLIENT_ID2 } from "@kyneta/schema";
-import * as Y6 from "yjs";
 function hashPeerId(peerId) {
   let hash = 2166136261;
   for (let i = 0; i < peerId.length; i++) {
@@ -867,47 +850,28 @@ function createYjsFactory(peerId) {
     }
   };
 }
-function bindYjs(schema) {
-  return bind({
-    schema,
-    factory: (ctx) => createYjsFactory(ctx.peerId),
-    strategy: "causal"
-  });
-}
-
-// src/yjs-escape.ts
-import { BACKING_DOC as BACKING_DOC3, unwrap } from "@kyneta/schema";
-function yjs(ref) {
-  let substrate;
-  try {
-    substrate = unwrap(ref);
-  } catch {
-    throw new Error(
-      "yjs() requires a ref backed by a Yjs substrate. Use a doc created by exchange.get() with a bindYjs() schema, or by createYjsDoc()."
-    );
-  }
-  const doc = substrate[BACKING_DOC3];
-  if (!doc || typeof doc !== "object" || typeof doc.getMap !== "function" || typeof doc.clientID !== "number") {
-    throw new Error(
-      "yjs() 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 bindYjs() schema or createYjsDoc()."
-    );
-  }
-  return doc;
-}
-
-// src/index.ts
-function text() {
-  return Schema2.annotated("text");
-}
+var yjs = createSubstrateNamespace({
+  strategies: {
+    collaborative: {
+      factory: (ctx) => createYjsFactory(ctx.peerId),
+      replicaFactory: yjsReplicaFactory
+    },
+    ephemeral: {
+      factory: (ctx) => createYjsFactory(ctx.peerId),
+      replicaFactory: yjsReplicaFactory
+    }
+  },
+  defaultStrategy: "collaborative"
+});
 export {
+  NATIVE,
   Schema,
   YjsVersion,
   applyChangeToYjs,
   applyChanges,
-  bindYjs,
   change,
-  createYjsDoc,
-  createYjsDocFromEntirety,
+  createDoc,
+  createRef,
   createYjsSubstrate,
   ensureContainers,
   eventsToOps,
@@ -918,10 +882,11 @@ export {
   stepIntoYjs,
   subscribe,
   subscribeNode,
-  text,
+  unwrap,
   version,
   yjs,
   yjsReader,
+  yjsReplicaFactory,
   yjsSubstrateFactory
 };
 //# sourceMappingURL=index.js.map