@kyneta/yjs-schema 1.0.0

package/dist/index.js

@@ -0,0 +1,865 @@
+// src/create.ts
+import { interpret, registerSubstrate } from "@kyneta/schema";
+import { changefeed, readable, writable } from "@kyneta/schema";
+
+// src/substrate.ts
+import { buildWritableContext, executeBatch } from "@kyneta/schema";
+import * as Y5 from "yjs";
+
+// src/change-mapping.ts
+import { advanceSchema as advanceSchema2, expandMapOpsToLeaves } from "@kyneta/schema";
+import { RawPath } from "@kyneta/schema";
+import * as Y2 from "yjs";
+
+// src/yjs-resolve.ts
+import { advanceSchema } from "@kyneta/schema";
+import * as Y from "yjs";
+function stepIntoYjs(current, segment) {
+  const resolved = segment.resolve();
+  if (current instanceof Y.Map) {
+    return current.get(resolved);
+  }
+  if (current instanceof Y.Array) {
+    return current.get(resolved);
+  }
+  if (current instanceof Y.Text) {
+    throw new Error(
+      `yjs-resolve: cannot step into Y.Text`
+    );
+  }
+  return void 0;
+}
+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);
+    current = stepIntoYjs(current, seg);
+    schema = nextSchema;
+  }
+  return current;
+}
+
+// src/change-mapping.ts
+function applyChangeToYjs(rootMap, rootSchema, path, change2) {
+  switch (change2.type) {
+    case "text":
+      applyTextChange(rootMap, rootSchema, path, change2);
+      return;
+    case "sequence":
+      applySequenceChange(rootMap, rootSchema, path, change2);
+      return;
+    case "map":
+      applyMapChange(rootMap, rootSchema, path, change2);
+      return;
+    case "replace":
+      applyReplaceChange(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)}].`
+      );
+    case "tree":
+      throw new Error(
+        `Yjs substrate does not support tree annotations. Yjs has no native tree type. Attempted TreeChange at path [${pathToString(path)}].`
+      );
+    default:
+      throw new Error(
+        `applyChangeToYjs: unsupported change type "${change2.type}"`
+      );
+  }
+}
+function applyTextChange(rootMap, rootSchema, path, change2) {
+  const resolved = resolveYjsType(rootMap, rootSchema, path);
+  if (!(resolved instanceof Y2.Text)) {
+    throw new Error(
+      `applyChangeToYjs: TextChange target at path [${pathToString(path)}] is not a Y.Text`
+    );
+  }
+  resolved.applyDelta(change2.instructions);
+}
+function applySequenceChange(rootMap, rootSchema, path, change2) {
+  const resolved = resolveYjsType(rootMap, rootSchema, path);
+  if (!(resolved instanceof Y2.Array)) {
+    throw new Error(
+      `applyChangeToYjs: SequenceChange target at path [${pathToString(path)}] is not a Y.Array`
+    );
+  }
+  const targetSchema = resolveSchemaAtPath(rootSchema, path);
+  const itemSchema = getItemSchema(targetSchema);
+  let cursor = 0;
+  for (const instruction of change2.instructions) {
+    if ("retain" in instruction) {
+      cursor += instruction.retain;
+    } else if ("delete" in instruction) {
+      resolved.delete(cursor, instruction.delete);
+    } else if ("insert" in instruction) {
+      const items = instruction.insert;
+      const yjsItems = items.map(
+        (item) => maybeCreateSharedType(item, itemSchema)
+      );
+      resolved.insert(cursor, yjsItems);
+      cursor += items.length;
+    }
+  }
+}
+function applyMapChange(rootMap, rootSchema, path, change2) {
+  const resolved = resolveYjsType(rootMap, rootSchema, path);
+  if (!(resolved instanceof Y2.Map)) {
+    throw new Error(
+      `applyChangeToYjs: MapChange target at path [${pathToString(path)}] is not a Y.Map`
+    );
+  }
+  const targetSchema = resolveSchemaAtPath(rootSchema, path);
+  if (change2.delete) {
+    for (const key of change2.delete) {
+      resolved.delete(key);
+    }
+  }
+  if (change2.set) {
+    for (const [key, value] of Object.entries(change2.set)) {
+      const fieldSchema = getFieldSchema(targetSchema, key);
+      const yjsValue = maybeCreateSharedType(value, fieldSchema);
+      resolved.set(key, yjsValue);
+    }
+  }
+}
+function applyReplaceChange(rootMap, rootSchema, path, change2) {
+  if (path.length === 0) {
+    throw new Error(
+      "applyChangeToYjs: ReplaceChange at root path is not supported"
+    );
+  }
+  const lastSeg = path.segments[path.segments.length - 1];
+  const parentPath = path.slice(0, -1);
+  const parent = resolveYjsType(rootMap, rootSchema, parentPath);
+  const resolved = lastSeg.resolve();
+  if (parent instanceof Y2.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") {
+    const targetSchema = resolveSchemaAtPath(rootSchema, path);
+    const yjsValue = maybeCreateSharedType(change2.value, targetSchema);
+    parent.delete(resolved, 1);
+    parent.insert(resolved, [yjsValue]);
+  } else {
+    throw new Error(
+      `applyChangeToYjs: ReplaceChange parent at path [${pathToString(parentPath)}] is not a Y.Map or Y.Array (got ${typeof parent})`
+    );
+  }
+}
+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);
+    }
+    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
+      );
+    }
+    case "sequence": {
+      if (!Array.isArray(value)) return value;
+      const arr = new Y2.Array();
+      const itemSchema = structural.item;
+      const items = value.map(
+        (item) => maybeCreateSharedType(item, itemSchema)
+      );
+      arr.insert(0, items);
+      return arr;
+    }
+    case "map": {
+      if (value === null || value === void 0 || typeof value !== "object" || Array.isArray(value)) {
+        return value;
+      }
+      const map = new Y2.Map();
+      const valueSchema = structural.item;
+      for (const [k, v] of Object.entries(
+        value
+      )) {
+        map.set(k, maybeCreateSharedType(v, valueSchema));
+      }
+      return map;
+    }
+    default:
+      return value;
+  }
+}
+function createStructuredMap(obj, productSchema) {
+  const map = new Y2.Map();
+  const structural = unwrapAnnotations(productSchema);
+  if (structural._kind !== "product") {
+    for (const [key, val] of Object.entries(obj)) {
+      map.set(key, val);
+    }
+    return map;
+  }
+  for (const [key, val] of Object.entries(obj)) {
+    if (val === void 0) continue;
+    const fieldSchema = structural.fields[key];
+    const yjsVal = fieldSchema ? maybeCreateSharedType(val, fieldSchema) : val;
+    map.set(key, yjsVal);
+  }
+  for (const [key, fieldSchema] of Object.entries(
+    structural.fields
+  )) {
+    if (key in obj) continue;
+    const tag = fieldSchema._kind === "annotated" ? fieldSchema.tag : void 0;
+    if (tag === "text") {
+      map.set(key, new Y2.Text());
+    }
+  }
+  return map;
+}
+function eventsToOps(events) {
+  const ops = [];
+  for (const event of events) {
+    const kynetaPath = yjsPathToKynetaPath(event.path);
+    const change2 = eventToChange(event);
+    if (change2) {
+      ops.push({ path: kynetaPath, change: change2 });
+    }
+  }
+  return expandMapOpsToLeaves(ops);
+}
+function yjsPathToKynetaPath(yjsPath) {
+  let path = RawPath.empty;
+  for (const segment of yjsPath) {
+    if (typeof segment === "string") {
+      path = path.field(segment);
+    } else if (typeof segment === "number") {
+      path = path.item(segment);
+    }
+  }
+  return path;
+}
+function eventToChange(event) {
+  if (event.target instanceof Y2.Text) {
+    return textEventToChange(event);
+  }
+  if (event.target instanceof Y2.Array) {
+    return arrayEventToChange(event);
+  }
+  if (event.target instanceof Y2.Map) {
+    return mapEventToChange(event);
+  }
+  return null;
+}
+function textEventToChange(event) {
+  const instructions = [];
+  for (const delta of event.delta) {
+    if (delta.retain !== void 0) {
+      instructions.push({ retain: delta.retain });
+    } else if (delta.insert !== void 0) {
+      instructions.push({ insert: delta.insert });
+    } else if (delta.delete !== void 0) {
+      instructions.push({ delete: delta.delete });
+    }
+  }
+  return { type: "text", instructions };
+}
+function arrayEventToChange(event) {
+  const instructions = [];
+  for (const delta of event.changes.delta) {
+    if (delta.retain !== void 0) {
+      instructions.push({ retain: delta.retain });
+    } else if (delta.delete !== void 0) {
+      instructions.push({ delete: delta.delete });
+    } else if (delta.insert !== void 0) {
+      const items = delta.insert.map(
+        (item) => extractEventValue(item)
+      );
+      instructions.push({ insert: items });
+    }
+  }
+  return { type: "sequence", instructions };
+}
+function mapEventToChange(event) {
+  const set = {};
+  const deleteKeys = [];
+  let hasSet = false;
+  let hasDelete = false;
+  const target = event.target;
+  event.changes.keys.forEach(
+    (change2, key) => {
+      if (change2.action === "add" || change2.action === "update") {
+        const value = target.get(key);
+        set[key] = extractEventValue(value);
+        hasSet = true;
+      } else if (change2.action === "delete") {
+        deleteKeys.push(key);
+        hasDelete = true;
+      }
+    }
+  );
+  if (!hasSet && !hasDelete) return null;
+  return {
+    type: "map",
+    ...hasSet ? { set } : {},
+    ...hasDelete ? { delete: deleteKeys } : {}
+  };
+}
+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();
+  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) {
+    schema = advanceSchema2(schema, seg);
+  }
+  return schema;
+}
+function getItemSchema(schema) {
+  const structural = unwrapAnnotations(schema);
+  return structural._kind === "sequence" ? structural.item : void 0;
+}
+function getFieldSchema(schema, key) {
+  const structural = unwrapAnnotations(schema);
+  if (structural._kind === "product") {
+    return structural.fields[key];
+  }
+  if (structural._kind === "map") {
+    return structural.item;
+  }
+  return void 0;
+}
+function pathToString(path) {
+  return path.segments.map((seg) => String(seg.resolve())).join(".");
+}
+
+// src/populate.ts
+import { Zero } from "@kyneta/schema";
+import * as Y3 from "yjs";
+function ensureContainers(doc, schema) {
+  const rootMap = doc.getMap("root");
+  let rootProduct = schema;
+  while (rootProduct._kind === "annotated" && rootProduct.schema !== void 0) {
+    rootProduct = rootProduct.schema;
+  }
+  if (rootProduct._kind !== "product") {
+    return;
+  }
+  doc.transact(() => {
+    for (const [key, fieldSchema] of Object.entries(rootProduct.fields)) {
+      ensureRootField(rootMap, key, fieldSchema);
+    }
+  });
+}
+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
+  )) {
+    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/store-reader.ts
+import * as Y4 from "yjs";
+function extractValue(resolved) {
+  if (resolved instanceof Y4.Text) {
+    return resolved.toJSON();
+  }
+  if (resolved instanceof Y4.Map) {
+    return resolved.toJSON();
+  }
+  if (resolved instanceof Y4.Array) {
+    return resolved.toJSON();
+  }
+  return resolved;
+}
+function yjsStoreReader(doc, schema) {
+  const rootMap = doc.getMap("root");
+  return {
+    read(path) {
+      if (path.length === 0) {
+        return rootMap.toJSON();
+      }
+      const resolved = resolveYjsType(rootMap, schema, path);
+      return extractValue(resolved);
+    },
+    arrayLength(path) {
+      const resolved = resolveYjsType(rootMap, schema, path);
+      if (resolved instanceof Y4.Array) {
+        return resolved.length;
+      }
+      if (Array.isArray(resolved)) {
+        return resolved.length;
+      }
+      return 0;
+    },
+    keys(path) {
+      const resolved = resolveYjsType(rootMap, schema, path);
+      if (resolved instanceof Y4.Map) {
+        return Array.from(resolved.keys());
+      }
+      if (resolved !== null && resolved !== void 0 && typeof resolved === "object" && !Array.isArray(resolved)) {
+        return Object.keys(resolved);
+      }
+      return [];
+    },
+    hasKey(path, key) {
+      const resolved = resolveYjsType(rootMap, schema, path);
+      if (resolved instanceof Y4.Map) {
+        return resolved.has(key);
+      }
+      if (resolved !== null && resolved !== void 0 && typeof resolved === "object" && !Array.isArray(resolved)) {
+        return key in resolved;
+      }
+      return false;
+    }
+  };
+}
+
+// src/version.ts
+import { decodeStateVector } from "yjs";
+function uint8ArrayToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  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);
+  }
+  return bytes;
+}
+var YjsVersion = class _YjsVersion {
+  sv;
+  constructor(sv) {
+    this.sv = sv;
+  }
+  /**
+   * Serialize the state vector to a base64 string.
+   *
+   * The encoding is: raw state vector bytes → base64.
+   * This is text-safe for embedding in HTML meta tags, URL parameters, etc.
+   */
+  serialize() {
+    return uint8ArrayToBase64(this.sv);
+  }
+  /**
+   * 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:
+   *
+   * - 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`.
+   */
+  compare(other) {
+    if (!(other instanceof _YjsVersion)) {
+      throw new Error(
+        "YjsVersion can only be compared 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";
+  }
+  /**
+   * Parse a serialized YjsVersion string back into a YjsVersion.
+   *
+   * The inverse of `serialize()`: base64 → `Uint8Array`.
+   */
+  static parse(serialized) {
+    if (serialized === "") {
+      throw new Error("Invalid YjsVersion value: (empty string)");
+    }
+    const bytes = base64ToUint8Array(serialized);
+    return new _YjsVersion(bytes);
+  }
+};
+
+// src/yjs-escape.ts
+import { unwrap } from "@kyneta/schema";
+var substrateToYjsDoc = /* @__PURE__ */ new WeakMap();
+function registerYjsSubstrate(substrate, doc) {
+  substrateToYjsDoc.set(substrate, doc);
+}
+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 = substrateToYjsDoc.get(substrate);
+  if (!doc) {
+    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/substrate.ts
+var KYNETA_ORIGIN = "kyneta-prepare";
+function createYjsSubstrate(doc, schema) {
+  const pendingChanges = [];
+  let inOurTransaction = false;
+  let pendingImportOrigin;
+  let cachedCtx;
+  const rootMap = doc.getMap("root");
+  const reader = yjsStoreReader(doc, schema);
+  const substrate = {
+    store: reader,
+    prepare(path, change2) {
+      if (!inOurTransaction) {
+        pendingChanges.push({ path, change: change2 });
+      }
+    },
+    onFlush(origin) {
+      if (!inOurTransaction && pendingChanges.length > 0) {
+        inOurTransaction = true;
+        try {
+          doc.transact(() => {
+            for (const { path, change: change2 } of pendingChanges) {
+              applyChangeToYjs(rootMap, schema, path, change2);
+            }
+          }, KYNETA_ORIGIN);
+          pendingChanges.length = 0;
+        } finally {
+          inOurTransaction = false;
+        }
+      }
+    },
+    context() {
+      if (!cachedCtx) {
+        cachedCtx = buildWritableContext(substrate);
+      }
+      return cachedCtx;
+    },
+    version() {
+      return new YjsVersion(Y5.encodeStateVector(doc));
+    },
+    exportSnapshot() {
+      return {
+        encoding: "binary",
+        data: Y5.encodeStateAsUpdate(doc)
+      };
+    },
+    exportSince(since) {
+      try {
+        const bytes = Y5.encodeStateAsUpdate(doc, since.sv);
+        return { encoding: "binary", data: bytes };
+      } catch {
+        return null;
+      }
+    },
+    importDelta(payload, origin) {
+      if (payload.encoding !== "binary" || !(payload.data instanceof Uint8Array)) {
+        throw new Error(
+          "YjsSubstrate.importDelta only supports binary-encoded payloads"
+        );
+      }
+      pendingImportOrigin = origin;
+      try {
+        Y5.applyUpdate(doc, payload.data, origin ?? "remote");
+      } finally {
+        pendingImportOrigin = void 0;
+      }
+    }
+  };
+  rootMap.observeDeep((events, transaction) => {
+    if (transaction.origin === KYNETA_ORIGIN) {
+      return;
+    }
+    const ops = eventsToOps(events);
+    if (ops.length === 0) {
+      return;
+    }
+    const origin = pendingImportOrigin ?? (typeof transaction.origin === "string" ? transaction.origin : void 0);
+    const ctx = substrate.context();
+    inOurTransaction = true;
+    try {
+      executeBatch(ctx, ops, origin);
+    } finally {
+      inOurTransaction = false;
+    }
+  });
+  registerYjsSubstrate(substrate, doc);
+  return substrate;
+}
+var yjsSubstrateFactory = {
+  create(schema) {
+    const doc = new Y5.Doc();
+    ensureContainers(doc, schema);
+    return createYjsSubstrate(doc, schema);
+  },
+  fromSnapshot(payload, schema) {
+    if (payload.encoding !== "binary" || !(payload.data instanceof Uint8Array)) {
+      throw new Error(
+        "YjsSubstrateFactory.fromSnapshot only supports binary-encoded payloads"
+      );
+    }
+    const doc = new Y5.Doc();
+    Y5.applyUpdate(doc, payload.data);
+    return createYjsSubstrate(doc, schema);
+  },
+  parseVersion(serialized) {
+    return YjsVersion.parse(serialized);
+  }
+};
+
+// src/create.ts
+var substrates = /* @__PURE__ */ new WeakMap();
+function getSubstrate(doc) {
+  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()."
+    );
+  }
+  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 createYjsDocFromSnapshot = (schema, payload) => registerDoc(schema, yjsSubstrateFactory.fromSnapshot(payload, schema));
+
+// src/sync.ts
+function version(doc) {
+  return getSubstrate(doc).version();
+}
+function exportSnapshot(doc) {
+  return getSubstrate(doc).exportSnapshot();
+}
+function exportSince(doc, since) {
+  return getSubstrate(doc).exportSince(since);
+}
+function importDelta(doc, payload, origin) {
+  getSubstrate(doc).importDelta(payload, origin);
+}
+
+// src/index.ts
+import { applyChanges, change } from "@kyneta/schema";
+import { subscribe, subscribeNode } from "@kyneta/schema";
+import { Schema } from "@kyneta/schema";
+import { Schema as Schema2 } from "@kyneta/schema";
+
+// src/bind-yjs.ts
+import { bind } from "@kyneta/schema";
+import * as Y6 from "yjs";
+function hashPeerId(peerId) {
+  let hash = 2166136261;
+  for (let i = 0; i < peerId.length; i++) {
+    hash ^= peerId.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function createYjsFactory(peerId) {
+  const numericClientId = hashPeerId(peerId);
+  return {
+    create(schema) {
+      const doc = new Y6.Doc();
+      doc.clientID = numericClientId;
+      ensureContainers(doc, schema);
+      return createYjsSubstrate(doc, schema);
+    },
+    fromSnapshot(payload, schema) {
+      if (payload.encoding !== "binary" || !(payload.data instanceof Uint8Array)) {
+        throw new Error(
+          "YjsSubstrateFactory.fromSnapshot only supports binary-encoded payloads"
+        );
+      }
+      const doc = new Y6.Doc();
+      doc.clientID = numericClientId;
+      Y6.applyUpdate(doc, payload.data);
+      return createYjsSubstrate(doc, schema);
+    },
+    parseVersion(serialized) {
+      return YjsVersion.parse(serialized);
+    }
+  };
+}
+function bindYjs(schema) {
+  return bind({
+    schema,
+    factory: (ctx) => createYjsFactory(ctx.peerId),
+    strategy: "causal"
+  });
+}
+
+// src/index.ts
+function text() {
+  return Schema2.annotated("text");
+}
+export {
+  Schema,
+  YjsVersion,
+  applyChangeToYjs,
+  applyChanges,
+  bindYjs,
+  change,
+  createYjsDoc,
+  createYjsDocFromSnapshot,
+  createYjsSubstrate,
+  ensureContainers,
+  eventsToOps,
+  exportSince,
+  exportSnapshot,
+  importDelta,
+  resolveYjsType,
+  stepIntoYjs,
+  subscribe,
+  subscribeNode,
+  text,
+  version,
+  yjs,
+  yjsStoreReader,
+  yjsSubstrateFactory
+};
+//# sourceMappingURL=index.js.map