@coaction/yjs 1.5.0 → 2.1.0

package/dist/index.mjs

@@ -1,592 +1,705 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+import { StateSchemaError, applyRootReplacementWithPatches, isStateSchemaError, onStoreReady } from "coaction";
+import * as Y from "yjs";
+export * from "yjs";
+//#endregion
+//#region packages/coaction-yjs/src/shared.ts
+const scheduleMicrotask = (callback) => {
+	if (typeof queueMicrotask === "function") {
+		queueMicrotask(callback);
+		return;
+	}
+	Promise.resolve().then(callback);
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-
-// index.ts
-var index_exports = {};
-__export(index_exports, {
-  __unsafeTestOnly__: () => __unsafeTestOnly__,
-  bindYjs: () => bindYjs,
-  yjs: () => yjs
-});
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  __unsafeTestOnly__: () => __unsafeTestOnly__,
-  bindYjs: () => bindYjs,
-  yjs: () => yjs
-});
-import * as Y4 from "yjs";
-
-// src/remoteOperations.ts
-import * as Y2 from "yjs";
-
-// src/shared.ts
-var scheduleMicrotask = (callback) => {
-  if (typeof queueMicrotask === "function") {
-    queueMicrotask(callback);
-    return;
-  }
-  Promise.resolve().then(callback);
+const isUnsafeKey = (key) => key === "__proto__" || key === "prototype" || key === "constructor";
+const isUnsafePathSegment = (segment) => typeof segment === "string" && isUnsafeKey(segment);
+const cloneFallback = (value, seen = /* @__PURE__ */ new WeakMap()) => {
+	if (typeof value !== "object" || value === null) return value;
+	const cached = seen.get(value);
+	if (cached) return cached;
+	if (Array.isArray(value)) {
+		const next = [];
+		seen.set(value, next);
+		for (let index = 0; index < value.length; index += 1) if (Object.prototype.hasOwnProperty.call(value, index)) next[index] = cloneFallback(value[index], seen);
+		return next;
+	}
+	if (isPlainObject(value)) {
+		const next = Object.create(Object.getPrototypeOf(value));
+		seen.set(value, next);
+		for (const key of Reflect.ownKeys(value)) if (Object.prototype.propertyIsEnumerable.call(value, key)) {
+			if (typeof key === "string" && isUnsafeKey(key)) continue;
+			next[key] = cloneFallback(value[key], seen);
+		}
+		return next;
+	}
+	return JSON.parse(JSON.stringify(value));
 };
 function clone(value) {
-  if (typeof structuredClone === "function") {
-    return structuredClone(value);
-  }
-  return JSON.parse(JSON.stringify(value));
+	if (Array.isArray(value) || isPlainObject(value)) return cloneFallback(value);
+	if (typeof structuredClone === "function") try {
+		return structuredClone(value);
+	} catch {
+		return cloneFallback(value);
+	}
+	return cloneFallback(value);
 }
 function isPlainObject(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
 }
-
-// src/yjsValue.ts
-import * as Y from "yjs";
+function sanitizePlainValue(value, seen = /* @__PURE__ */ new WeakMap()) {
+	if (typeof value !== "object" || value === null) return value;
+	const cached = seen.get(value);
+	if (cached) return cached;
+	if (Array.isArray(value)) {
+		const next = [];
+		seen.set(value, next);
+		for (let index = 0; index < value.length; index += 1) if (Object.prototype.hasOwnProperty.call(value, index)) next[index] = sanitizePlainValue(value[index], seen);
+		return next;
+	}
+	if (!isPlainObject(value)) return clone(value);
+	const next = {};
+	seen.set(value, next);
+	for (const key of Object.keys(value)) {
+		if (isUnsafeKey(key)) continue;
+		next[key] = sanitizePlainValue(value[key], seen);
+	}
+	return next;
+}
+//#endregion
+//#region packages/coaction-yjs/src/yjsValue.ts
 function toPlainObject(value) {
-  const next = {};
-  value.forEach((item, key) => {
-    next[key] = toPlainValue(item);
-  });
-  return next;
+	const next = {};
+	value.forEach((item, key) => {
+		if (isUnsafeKey(key)) return;
+		next[key] = toPlainValue(item);
+	});
+	return next;
 }
 function toPlainArray(value) {
-  return value.toArray().map((item) => toPlainValue(item));
+	return value.toArray().map((item) => toPlainValue(item));
 }
 function toPlainValue(value) {
-  if (value instanceof Y.Map) {
-    return toPlainObject(value);
-  }
-  if (value instanceof Y.Array) {
-    return toPlainArray(value);
-  }
-  return value;
+	if (value instanceof Y.Map) return toPlainObject(value);
+	if (value instanceof Y.Array) return toPlainArray(value);
+	if (value instanceof Y.AbstractType) return toPlainValue(value.toJSON());
+	if (Array.isArray(value) || isPlainObject(value)) return sanitizePlainValue(value);
+	return value;
 }
 function createYMap(value) {
-  const next = new Y.Map();
-  for (const [key, item] of Object.entries(value)) {
-    next.set(key, toYValue(item));
-  }
-  return next;
+	const next = new Y.Map();
+	for (const [key, item] of Object.entries(value)) {
+		if (isUnsafeKey(key)) continue;
+		next.set(key, toYValue(item));
+	}
+	return next;
 }
 function createYArray(value) {
-  const next = new Y.Array();
-  if (value.length > 0) {
-    next.insert(
-      0,
-      value.map((item) => toYValue(item))
-    );
-  }
-  return next;
+	const next = new Y.Array();
+	if (value.length > 0) next.insert(0, value.map((item) => toYValue(item)));
+	return next;
 }
 function toYValue(value) {
-  if (Array.isArray(value)) {
-    return createYArray(value);
-  }
-  if (isPlainObject(value)) {
-    return createYMap(value);
-  }
-  if (typeof value === "object" && value !== null) {
-    return clone(value);
-  }
-  return value;
+	if (Array.isArray(value)) return createYArray(value);
+	if (isPlainObject(value)) return createYMap(value);
+	if (typeof value === "object" && value !== null) return clone(value);
+	return value;
 }
-
-// src/remoteOperations.ts
+//#endregion
+//#region packages/coaction-yjs/src/remoteOperations.ts
 function isSetStateReentryError(error) {
-  return error instanceof Error && error.message === "setState cannot be called within the updater";
+	return error instanceof Error && error.message === "setState cannot be called within the updater";
 }
 function cloneForStore(value) {
-  if (typeof value === "object" && value !== null) {
-    return clone(value);
-  }
-  return value;
+	if (typeof value === "object" && value !== null) return sanitizePlainValue(value);
+	return value;
 }
 function toPathKey(path) {
-  return path.map((segment) => `${typeof segment}:${String(segment)}`).join("|");
+	return path.map((segment) => `${typeof segment}:${String(segment)}`).join("|");
+}
+function toArrayIndex(segment) {
+	const index = typeof segment === "number" ? segment : Number.parseInt(segment, 10);
+	if (!Number.isInteger(index) || index < 0) return;
+	if (typeof segment === "string" && String(index) !== segment) return;
+	return index;
+}
+function assertCanSetPathSegment(target, key, path) {
+	if (Object.prototype.hasOwnProperty.call(target, key)) return;
+	if (Object.isExtensible(target)) return;
+	throw new StateSchemaError(`Unknown state key '${path.map((segment) => String(segment)).join(".")}' cannot be added after store initialization. Coaction state schema is fixed.`);
+}
+function clearObjectKey(target, key) {
+	if (!Object.prototype.hasOwnProperty.call(target, key)) return;
+	const descriptor = Object.getOwnPropertyDescriptor(target, key);
+	if (descriptor?.configurable) {
+		delete target[key];
+		return;
+	}
+	if (descriptor && "set" in descriptor && descriptor.set) {
+		target[key] = void 0;
+		return;
+	}
+	if (descriptor && "writable" in descriptor && descriptor.writable) target[key] = void 0;
 }
 function compactOperations(operations) {
-  const deduplicated = /* @__PURE__ */ new Map();
-  for (const operation of operations) {
-    const key = toPathKey(operation.path);
-    if (deduplicated.has(key)) {
-      deduplicated.delete(key);
-    }
-    deduplicated.set(key, operation);
-  }
-  return Array.from(deduplicated.values()).sort(
-    (left, right) => left.path.length - right.path.length
-  );
+	const deduplicated = /* @__PURE__ */ new Map();
+	for (const operation of operations) {
+		const key = toPathKey(operation.path);
+		if (deduplicated.has(key)) deduplicated.delete(key);
+		deduplicated.set(key, operation);
+	}
+	return Array.from(deduplicated.values()).sort((left, right) => left.path.length - right.path.length);
 }
 function getYValueAtPath(root, path) {
-  let current = root;
-  for (const segment of path) {
-    if (current instanceof Y2.Map) {
-      current = current.get(String(segment));
-      continue;
-    }
-    if (current instanceof Y2.Array) {
-      const index = typeof segment === "number" ? segment : Number.parseInt(segment, 10);
-      if (!Number.isInteger(index)) {
-        return void 0;
-      }
-      current = current.get(index);
-      continue;
-    }
-    return void 0;
-  }
-  return current;
+	let current = root;
+	for (const segment of path) {
+		if (current instanceof Y.Map) {
+			current = current.get(String(segment));
+			continue;
+		}
+		if (current instanceof Y.Array) {
+			const index = toArrayIndex(segment);
+			if (typeof index === "undefined") return;
+			current = current.get(index);
+			continue;
+		}
+		return;
+	}
+	return current;
 }
 function setAtPath(target, path, value) {
-  if (path.length === 0) {
-    return;
-  }
-  let current = target;
-  for (let index = 0; index < path.length - 1; index += 1) {
-    const segment = path[index];
-    const nextSegment = path[index + 1];
-    const nextValue = current[segment];
-    if (typeof nextValue !== "object" || nextValue === null) {
-      current[segment] = typeof nextSegment === "number" ? [] : {};
-    }
-    current = current[segment];
-  }
-  const leaf = path[path.length - 1];
-  current[leaf] = cloneForStore(value);
+	if (path.length === 0) return;
+	if (path.some(isUnsafePathSegment)) return;
+	let current = target;
+	for (let index = 0; index < path.length - 1; index += 1) {
+		const segment = path[index];
+		const nextSegment = path[index + 1];
+		const segmentIndex = Array.isArray(current) ? toArrayIndex(segment) : void 0;
+		const targetKey = typeof segmentIndex === "undefined" ? segment : segmentIndex;
+		const nextValue = current[targetKey];
+		const needsArray = typeof nextSegment === "number" || Array.isArray(nextValue) && typeof toArrayIndex(nextSegment) !== "undefined";
+		if (typeof nextValue !== "object" || nextValue === null || (needsArray ? !Array.isArray(nextValue) : Array.isArray(nextValue))) {
+			assertCanSetPathSegment(current, targetKey, path.slice(0, index + 1));
+			current[targetKey] = typeof nextSegment === "number" ? [] : {};
+		}
+		current = current[targetKey];
+	}
+	const leaf = path[path.length - 1];
+	const leafIndex = Array.isArray(current) ? toArrayIndex(leaf) : void 0;
+	const leafKey = typeof leafIndex === "undefined" ? leaf : leafIndex;
+	assertCanSetPathSegment(current, leafKey, path);
+	current[leafKey] = cloneForStore(value);
 }
 function deleteAtPath(target, path) {
-  if (path.length === 0) {
-    return;
-  }
-  let current = target;
-  for (let index = 0; index < path.length - 1; index += 1) {
-    current = current[path[index]];
-    if (typeof current !== "object" || current === null) {
-      return;
-    }
-  }
-  const leaf = path[path.length - 1];
-  if (Array.isArray(current) && typeof leaf === "number") {
-    if (leaf >= 0 && leaf < current.length) {
-      current.splice(leaf, 1);
-    }
-    return;
-  }
-  delete current[leaf];
+	if (path.length === 0) return;
+	if (path.some(isUnsafePathSegment)) return;
+	let current = target;
+	for (let index = 0; index < path.length - 1; index += 1) {
+		const segment = path[index];
+		const segmentIndex = Array.isArray(current) ? toArrayIndex(segment) : void 0;
+		current = current[typeof segmentIndex === "undefined" ? segment : segmentIndex];
+		if (typeof current !== "object" || current === null) return;
+	}
+	const leaf = path[path.length - 1];
+	if (Array.isArray(current)) {
+		const leafIndex = toArrayIndex(leaf);
+		if (typeof leafIndex !== "undefined" && leafIndex >= 0 && leafIndex < current.length) current.splice(leafIndex, 1);
+		return;
+	}
+	clearObjectKey(current, leaf);
 }
 function collectRemoteOperations(events, stateMap) {
-  const operations = [];
-  for (const event of events) {
-    if (event instanceof Y2.YMapEvent) {
-      for (const changedKey of event.keysChanged) {
-        const path = [...event.path, changedKey];
-        const keyChange = event.changes.keys.get(changedKey);
-        if (keyChange?.action === "delete") {
-          operations.push({
-            type: "delete",
-            path
-          });
-          continue;
-        }
-        operations.push({
-          type: "set",
-          path,
-          value: toPlainValue(getYValueAtPath(stateMap, path))
-        });
-      }
-      continue;
-    }
-    if (event instanceof Y2.YArrayEvent) {
-      const path = [...event.path];
-      operations.push({
-        type: "set",
-        path,
-        value: toPlainValue(getYValueAtPath(stateMap, path))
-      });
-    }
-  }
-  return operations;
+	const operations = [];
+	for (const event of events) {
+		if (event instanceof Y.YMapEvent) {
+			for (const changedKey of event.keysChanged) {
+				const path = [...event.path, changedKey];
+				if (path.some(isUnsafePathSegment)) continue;
+				if (event.changes.keys.get(changedKey)?.action === "delete") {
+					operations.push({
+						type: "delete",
+						path
+					});
+					continue;
+				}
+				operations.push({
+					type: "set",
+					path,
+					value: toPlainValue(getYValueAtPath(stateMap, path))
+				});
+			}
+			continue;
+		}
+		if (event instanceof Y.YArrayEvent) {
+			const path = [...event.path];
+			operations.push({
+				type: "set",
+				path,
+				value: toPlainValue(getYValueAtPath(stateMap, path))
+			});
+		}
+	}
+	return operations;
 }
-
-// src/sync.ts
-import * as Y3 from "yjs";
+//#endregion
+//#region packages/coaction-yjs/src/sync.ts
 function isEqualValue(left, right) {
-  if (Object.is(left, right)) {
-    return true;
-  }
-  if (Array.isArray(left) && Array.isArray(right)) {
-    if (left.length !== right.length) {
-      return false;
-    }
-    for (let index = 0; index < left.length; index += 1) {
-      if (!isEqualValue(left[index], right[index])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (isPlainObject(left) && isPlainObject(right)) {
-    const leftKeys = Object.keys(left);
-    const rightKeys = Object.keys(right);
-    if (leftKeys.length !== rightKeys.length) {
-      return false;
-    }
-    for (const key of leftKeys) {
-      if (!Object.prototype.hasOwnProperty.call(right, key)) {
-        return false;
-      }
-      if (!isEqualValue(left[key], right[key])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return false;
+	if (Object.is(left, right)) return true;
+	if (Array.isArray(left) && Array.isArray(right)) {
+		if (left.length !== right.length) return false;
+		for (let index = 0; index < left.length; index += 1) if (!isEqualValue(left[index], right[index])) return false;
+		return true;
+	}
+	if (isPlainObject(left) && isPlainObject(right)) {
+		const leftKeys = Object.keys(left);
+		const rightKeys = Object.keys(right);
+		if (leftKeys.length !== rightKeys.length) return false;
+		for (const key of leftKeys) {
+			if (!Object.prototype.hasOwnProperty.call(right, key)) return false;
+			if (!isEqualValue(left[key], right[key])) return false;
+		}
+		return true;
+	}
+	return false;
 }
 function syncObjectToYMap(target, previous, source) {
-  const keys = /* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(source)]);
-  for (const key of keys) {
-    const hasPrevious = Object.prototype.hasOwnProperty.call(previous, key);
-    const hasNext = Object.prototype.hasOwnProperty.call(source, key);
-    if (!hasNext) {
-      target.delete(key);
-      continue;
-    }
-    const previousValue = hasPrevious ? previous[key] : void 0;
-    const nextValue = source[key];
-    if (hasPrevious && isEqualValue(previousValue, nextValue)) {
-      continue;
-    }
-    const current = target.get(key);
-    if (Array.isArray(nextValue)) {
-      if (Array.isArray(previousValue) && current instanceof Y3.Array) {
-        syncArrayToYArray(current, previousValue, nextValue);
-      } else {
-        target.set(key, createYArray(nextValue));
-      }
-      continue;
-    }
-    if (isPlainObject(nextValue)) {
-      if (isPlainObject(previousValue) && current instanceof Y3.Map) {
-        syncObjectToYMap(current, previousValue, nextValue);
-      } else {
-        target.set(key, createYMap(nextValue));
-      }
-      continue;
-    }
-    const normalized = typeof nextValue === "object" && nextValue !== null ? clone(nextValue) : nextValue;
-    if (!Object.is(current, normalized)) {
-      target.set(key, normalized);
-    }
-  }
+	target.forEach((_value, key) => {
+		if (isUnsafeKey(key)) target.delete(key);
+	});
+	const keys = /* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(source)]);
+	for (const key of keys) {
+		if (isUnsafeKey(key)) {
+			target.delete(key);
+			continue;
+		}
+		const hasPrevious = Object.prototype.hasOwnProperty.call(previous, key);
+		if (!Object.prototype.hasOwnProperty.call(source, key)) {
+			target.delete(key);
+			continue;
+		}
+		const previousValue = hasPrevious ? previous[key] : void 0;
+		const nextValue = source[key];
+		if (hasPrevious && isEqualValue(previousValue, nextValue)) continue;
+		const current = target.get(key);
+		if (Array.isArray(nextValue)) {
+			if (Array.isArray(previousValue) && current instanceof Y.Array) syncArrayToYArray(current, previousValue, nextValue);
+			else target.set(key, createYArray(nextValue));
+			continue;
+		}
+		if (isPlainObject(nextValue)) {
+			if (isPlainObject(previousValue) && current instanceof Y.Map) syncObjectToYMap(current, previousValue, nextValue);
+			else target.set(key, createYMap(nextValue));
+			continue;
+		}
+		const normalized = typeof nextValue === "object" && nextValue !== null ? clone(nextValue) : nextValue;
+		if (!Object.is(current, normalized)) target.set(key, normalized);
+	}
 }
 function syncArrayToYArray(target, previous, source) {
-  if (target.length > source.length) {
-    target.delete(source.length, target.length - source.length);
-  }
-  const maxLength = Math.max(previous.length, source.length);
-  for (let index = 0; index < maxLength; index += 1) {
-    const hasPrevious = index < previous.length;
-    const hasNext = index < source.length;
-    if (!hasNext) {
-      continue;
-    }
-    const previousValue = hasPrevious ? previous[index] : void 0;
-    const nextValue = source[index];
-    if (hasPrevious && isEqualValue(previousValue, nextValue)) {
-      continue;
-    }
-    if (index >= target.length) {
-      target.insert(index, [toYValue(nextValue)]);
-      continue;
-    }
-    const current = target.get(index);
-    if (Array.isArray(nextValue)) {
-      if (Array.isArray(previousValue) && current instanceof Y3.Array) {
-        syncArrayToYArray(current, previousValue, nextValue);
-      } else {
-        target.delete(index, 1);
-        target.insert(index, [createYArray(nextValue)]);
-      }
-      continue;
-    }
-    if (isPlainObject(nextValue)) {
-      if (isPlainObject(previousValue) && current instanceof Y3.Map) {
-        syncObjectToYMap(current, previousValue, nextValue);
-      } else {
-        target.delete(index, 1);
-        target.insert(index, [createYMap(nextValue)]);
-      }
-      continue;
-    }
-    const normalized = typeof nextValue === "object" && nextValue !== null ? clone(nextValue) : nextValue;
-    if (!Object.is(current, normalized)) {
-      target.delete(index, 1);
-      target.insert(index, [normalized]);
-    }
-  }
+	if (target.length > source.length) target.delete(source.length, target.length - source.length);
+	const maxLength = Math.max(previous.length, source.length);
+	for (let index = 0; index < maxLength; index += 1) {
+		const hasPrevious = index < previous.length;
+		if (!(index < source.length)) continue;
+		const previousValue = hasPrevious ? previous[index] : void 0;
+		const nextValue = source[index];
+		if (hasPrevious && isEqualValue(previousValue, nextValue)) continue;
+		if (index >= target.length) {
+			target.insert(index, [toYValue(nextValue)]);
+			continue;
+		}
+		const current = target.get(index);
+		if (Array.isArray(nextValue)) {
+			if (Array.isArray(previousValue) && current instanceof Y.Array) syncArrayToYArray(current, previousValue, nextValue);
+			else {
+				target.delete(index, 1);
+				target.insert(index, [createYArray(nextValue)]);
+			}
+			continue;
+		}
+		if (isPlainObject(nextValue)) {
+			if (isPlainObject(previousValue) && current instanceof Y.Map) syncObjectToYMap(current, previousValue, nextValue);
+			else {
+				target.delete(index, 1);
+				target.insert(index, [createYMap(nextValue)]);
+			}
+			continue;
+		}
+		const normalized = typeof nextValue === "object" && nextValue !== null ? clone(nextValue) : nextValue;
+		if (!Object.is(current, normalized)) {
+			target.delete(index, 1);
+			target.insert(index, [normalized]);
+		}
+	}
 }
-
-// src/index.ts
-__reExport(src_exports, yjs_star);
-import * as yjs_star from "yjs";
-var STATE_KEY = "state";
-var __unsafeTestOnly__ = {
-  getYValueAtPath: (root, path) => getYValueAtPath(root, path),
-  setAtPath: (target, path, value) => {
-    setAtPath(target, path, value);
-  },
-  deleteAtPath: (target, path) => {
-    deleteAtPath(target, path);
-  }
+//#endregion
+//#region packages/coaction-yjs/src/index.ts
+const STATE_KEY = "state";
+const historySuppressionSymbol = Symbol.for("coaction.history.suppress");
+const runWithoutHistoryRecording = (store, callback) => {
+	const runner = store[historySuppressionSymbol];
+	return typeof runner === "function" ? runner(callback) : callback();
+};
+const getOwnEnumerableKeys = (value) => Reflect.ownKeys(value).filter((key) => Object.prototype.propertyIsEnumerable.call(value, key) && !(typeof key === "string" && isUnsafeKey(key)));
+const formatPropertyPath = (path) => path.length ? path.map((key) => String(key)).join(".") : "<root>";
+var YjsSerializableStateError = class extends Error {};
+const isYjsSerializableStateError = (error) => error instanceof YjsSerializableStateError;
+const isArrayIndexKey = (key, length) => {
+	if (key === "") return false;
+	const index = Number(key);
+	return Number.isInteger(index) && index >= 0 && index < length && String(index) === key;
+};
+const findYjsStateViolation = (value, path = [], ancestors = /* @__PURE__ */ new WeakSet()) => {
+	switch (typeof value) {
+		case "symbol": return {
+			type: "symbol-value",
+			path
+		};
+		case "function": return {
+			type: "function",
+			path
+		};
+		default: break;
+	}
+	if (typeof value !== "object" || value === null) return;
+	if (ancestors.has(value)) return {
+		type: "circular-reference",
+		path
+	};
+	if (Array.isArray(value)) {
+		ancestors.add(value);
+		for (let index = 0; index < value.length; index += 1) if (!Object.prototype.hasOwnProperty.call(value, index)) return {
+			type: "array-hole",
+			path: [...path, index]
+		};
+		for (const key of getOwnEnumerableKeys(value)) {
+			const nextPath = [...path, key];
+			if (typeof key === "symbol") return {
+				type: "symbol-key",
+				path: nextPath
+			};
+			if (!isArrayIndexKey(key, value.length)) return {
+				type: "array-property",
+				path: nextPath
+			};
+			const violation = findYjsStateViolation(value[Number(key)], nextPath, ancestors);
+			if (violation) return violation;
+		}
+		ancestors.delete(value);
+		return;
+	}
+	if (!isPlainObject(value)) return {
+		type: "non-plain-object",
+		path
+	};
+	ancestors.add(value);
+	for (const key of getOwnEnumerableKeys(value)) {
+		const nextPath = [...path, key];
+		if (typeof key === "symbol") return {
+			type: "symbol-key",
+			path: nextPath
+		};
+		const child = value[key];
+		const violation = findYjsStateViolation(child, nextPath, ancestors);
+		if (violation) return violation;
+	}
+	ancestors.delete(value);
+};
+const assertYjsSerializableState = (state, path = []) => {
+	const violation = findYjsStateViolation(state, path);
+	if (!violation) return;
+	if (violation.type === "symbol-key") throw new YjsSerializableStateError(`Yjs binding does not support symbol-keyed state because Y.Map keys are strings. Found symbol key at ${formatPropertyPath(violation.path)}.`);
+	if (violation.type === "symbol-value") throw new YjsSerializableStateError(`Yjs binding does not support symbol-valued state because symbols cannot be cloned into Yjs documents. Found symbol value at ${formatPropertyPath(violation.path)}.`);
+	throw new YjsSerializableStateError(`Yjs binding does not support ${violation.type} state because only plain objects, arrays, and primitive values round-trip through Yjs updates. Found unsupported value at ${formatPropertyPath(violation.path)}.`);
+};
+const assertRemoteOperationsSerializable = (operations) => {
+	for (const operation of operations) if (operation.type === "set") assertYjsSerializableState(operation.value, operation.path);
 };
-var bindYjs = (store, options = {}) => {
-  if (store.share === "client") {
-    throw new Error("Yjs binding is not supported in client store mode.");
-  }
-  const doc = options.doc ?? new Y4.Doc();
-  const key = options.key ?? `coaction:${store.name}`;
-  const map = doc.getMap(key);
-  const localOrigin = /* @__PURE__ */ Symbol(`coaction-yjs:${store.name}`);
-  let destroyed = false;
-  let syncingFromYjs = false;
-  let lastSyncedState = (() => {
-    const pureState = clone(store.getPureState());
-    return isPlainObject(pureState) ? pureState : {};
-  })();
-  let flushScheduled = false;
-  let pendingSnapshot = null;
-  let pendingOperations = [];
-  const applyRemoteState = (state) => {
-    const next = clone(state);
-    syncingFromYjs = true;
-    try {
-      store.setState(next);
-      const pureState = clone(store.getPureState());
-      lastSyncedState = isPlainObject(pureState) ? pureState : {};
-    } finally {
-      syncingFromYjs = false;
-    }
-  };
-  const applyRemoteOperations = (operations) => {
-    if (operations.length === 0) {
-      return;
-    }
-    syncingFromYjs = true;
-    try {
-      store.setState((draft) => {
-        const mutableDraft = draft;
-        for (const operation of operations) {
-          if (operation.type === "set") {
-            setAtPath(mutableDraft, operation.path, operation.value);
-          } else {
-            deleteAtPath(mutableDraft, operation.path);
-          }
-        }
-      });
-      const pureState = clone(store.getPureState());
-      lastSyncedState = isPlainObject(pureState) ? pureState : {};
-    } finally {
-      syncingFromYjs = false;
-    }
-  };
-  const getStateMap = () => {
-    const state = map.get(STATE_KEY);
-    if (state instanceof Y4.Map) {
-      return state;
-    }
-    return null;
-  };
-  const scheduleFlushFromYjs = () => {
-    if (destroyed || flushScheduled) {
-      return;
-    }
-    flushScheduled = true;
-    scheduleMicrotask(flushFromYjs);
-  };
-  const flushFromYjs = () => {
-    flushScheduled = false;
-    if (destroyed) {
-      return;
-    }
-    if (pendingSnapshot) {
-      const snapshot = pendingSnapshot;
-      pendingSnapshot = null;
-      pendingOperations = [];
-      try {
-        applyRemoteState(snapshot);
-      } catch (error) {
-        if (isSetStateReentryError(error)) {
-          pendingSnapshot = snapshot;
-          setTimeout(scheduleFlushFromYjs, 0);
-          return;
-        }
-        throw error;
-      }
-    }
-    if (pendingOperations.length === 0) {
-      return;
-    }
-    const operations = compactOperations(pendingOperations);
-    pendingOperations = [];
-    try {
-      applyRemoteOperations(operations);
-    } catch (error) {
-      if (isSetStateReentryError(error)) {
-        pendingOperations = [...operations, ...pendingOperations];
-        setTimeout(scheduleFlushFromYjs, 0);
-        return;
-      }
-      throw error;
-    }
-  };
-  const enqueueSnapshot = (snapshot) => {
-    pendingSnapshot = snapshot;
-    pendingOperations = [];
-    scheduleFlushFromYjs();
-  };
-  const enqueueOperations = (operations) => {
-    if (operations.length === 0) {
-      return;
-    }
-    if (!pendingSnapshot) {
-      pendingOperations.push(...operations);
-    }
-    scheduleFlushFromYjs();
-  };
-  const syncNow = () => {
-    if (destroyed || syncingFromYjs) {
-      return;
-    }
-    const pureState = clone(store.getPureState());
-    if (!isPlainObject(pureState)) {
-      return;
-    }
-    doc.transact(() => {
-      syncObjectToYMap(stateMap, lastSyncedState, pureState);
-    }, localOrigin);
-    lastSyncedState = pureState;
-  };
-  const stateObserver = (events, transaction) => {
-    if (transaction.origin === localOrigin) {
-      return;
-    }
-    enqueueOperations(collectRemoteOperations(events, stateMap));
-  };
-  let stateMap;
-  const existingStateMap = getStateMap();
-  if (existingStateMap) {
-    stateMap = existingStateMap;
-    applyRemoteState(toPlainObject(stateMap));
-  } else {
-    const currentState = map.get(STATE_KEY);
-    if (isPlainObject(currentState)) {
-      stateMap = createYMap(currentState);
-      doc.transact(() => {
-        map.set(STATE_KEY, stateMap);
-      }, localOrigin);
-      applyRemoteState(currentState);
-    } else {
-      const pureState = clone(store.getPureState());
-      stateMap = createYMap(isPlainObject(pureState) ? pureState : {});
-      doc.transact(() => {
-        map.set(STATE_KEY, stateMap);
-      }, localOrigin);
-    }
-  }
-  stateMap.observeDeep(stateObserver);
-  const observer = (event) => {
-    if (event.transaction.origin === localOrigin) {
-      return;
-    }
-    if (!event.keysChanged.has(STATE_KEY)) {
-      return;
-    }
-    const nextStateMap = getStateMap();
-    if (nextStateMap) {
-      if (stateMap !== nextStateMap) {
-        stateMap.unobserveDeep(stateObserver);
-        stateMap = nextStateMap;
-        stateMap.observeDeep(stateObserver);
-      }
-      enqueueSnapshot(toPlainObject(nextStateMap));
-      return;
-    }
-    const currentState = map.get(STATE_KEY);
-    if (isPlainObject(currentState)) {
-      const migrated = createYMap(currentState);
-      doc.transact(() => {
-        map.set(STATE_KEY, migrated);
-      }, localOrigin);
-      if (stateMap !== migrated) {
-        stateMap.unobserveDeep(stateObserver);
-        stateMap = migrated;
-        stateMap.observeDeep(stateObserver);
-      }
-      enqueueSnapshot(currentState);
-    }
-  };
-  map.observe(observer);
-  const unsubscribe = store.subscribe(() => {
-    syncNow();
-  });
-  const binding = {
-    doc,
-    map,
-    syncNow,
-    destroy: () => {
-      if (destroyed) {
-        return;
-      }
-      destroyed = true;
-      unsubscribe();
-      map.unobserve(observer);
-      stateMap.unobserveDeep(stateObserver);
-      if (!options.doc) {
-        doc.destroy();
-      }
-    }
-  };
-  if (process.env.NODE_ENV === "test") {
-    binding.__unsafeTestOnly__ = {
-      applyRemoteOperations: (operations) => {
-        applyRemoteOperations(operations);
-      }
-    };
-  }
-  return binding;
+const __unsafeTestOnly__ = {
+	getYValueAtPath: (root, path) => getYValueAtPath(root, path),
+	setAtPath: (target, path, value) => {
+		setAtPath(target, path, value);
+	},
+	deleteAtPath: (target, path) => {
+		deleteAtPath(target, path);
+	}
 };
-var yjs = (options = {}) => (store) => {
-  const binding = bindYjs(store, options);
-  const baseDestroy = store.destroy;
-  store.destroy = () => {
-    binding.destroy();
-    baseDestroy();
-  };
-  return store;
+const bindYjs = (store, options = {}) => {
+	if (store.share === "client") throw new Error("Yjs binding is not supported in client store mode.");
+	const doc = options.doc ?? new Y.Doc();
+	const key = options.key ?? `coaction:${store.name}`;
+	const map = doc.getMap(key);
+	const localOrigin = Symbol(`coaction-yjs:${store.name}`);
+	let destroyed = false;
+	let syncingFromYjs = false;
+	assertYjsSerializableState(store.getPureState());
+	let lastSyncedState = (() => {
+		const pureState = clone(store.getPureState());
+		return isPlainObject(pureState) ? pureState : {};
+	})();
+	let flushScheduled = false;
+	let pendingSnapshot = null;
+	let pendingOperations = [];
+	const restoreLastSyncedState = () => {
+		syncingFromYjs = true;
+		try {
+			store.apply(lastSyncedState);
+		} finally {
+			syncingFromYjs = false;
+		}
+	};
+	const applyReplacementState = (next) => {
+		if (store.share === "main") {
+			store.setState(next, () => {
+				return applyRootReplacementWithPatches(store, next);
+			});
+			return;
+		}
+		store.setState(null);
+		store.apply(next);
+	};
+	const applyRemoteState = (state) => {
+		assertYjsSerializableState(state);
+		const next = sanitizePlainValue(state);
+		syncingFromYjs = true;
+		try {
+			applyReplacementState(next);
+			const pureState = clone(store.getPureState());
+			lastSyncedState = isPlainObject(pureState) ? pureState : {};
+		} finally {
+			syncingFromYjs = false;
+		}
+	};
+	const applyRemoteOperations = (operations) => {
+		if (operations.length === 0) return;
+		assertRemoteOperationsSerializable(operations);
+		syncingFromYjs = true;
+		try {
+			if (operations.some((operation) => operation.type === "delete" && operation.path.length === 1)) {
+				const next = clone(store.getPureState());
+				if (!isPlainObject(next)) return;
+				for (const operation of operations) if (operation.type === "set") setAtPath(next, operation.path, operation.value);
+				else deleteAtPath(next, operation.path);
+				applyReplacementState(next);
+				const pureState = clone(store.getPureState());
+				lastSyncedState = isPlainObject(pureState) ? pureState : {};
+				return;
+			}
+			store.setState((draft) => {
+				const mutableDraft = draft;
+				for (const operation of operations) if (operation.type === "set") setAtPath(mutableDraft, operation.path, operation.value);
+				else deleteAtPath(mutableDraft, operation.path);
+			});
+			const pureState = clone(store.getPureState());
+			lastSyncedState = isPlainObject(pureState) ? pureState : {};
+		} finally {
+			syncingFromYjs = false;
+		}
+	};
+	const getStateMap = () => {
+		const state = map.get(STATE_KEY);
+		if (state instanceof Y.Map) return state;
+		return null;
+	};
+	const scheduleFlushFromYjs = () => {
+		if (destroyed || flushScheduled) return;
+		flushScheduled = true;
+		scheduleMicrotask(flushFromYjs);
+	};
+	const flushFromYjs = () => {
+		flushScheduled = false;
+		if (destroyed) return;
+		if (pendingSnapshot) {
+			const snapshot = pendingSnapshot;
+			pendingSnapshot = null;
+			pendingOperations = [];
+			try {
+				applyRemoteState(snapshot);
+			} catch (error) {
+				if (isSetStateReentryError(error)) {
+					pendingSnapshot = snapshot;
+					setTimeout(scheduleFlushFromYjs, 0);
+					return;
+				}
+				if (isYjsSerializableStateError(error) || isStateSchemaError(error)) {
+					restoreRootState();
+					return;
+				}
+				throw error;
+			}
+		}
+		if (pendingOperations.length === 0) return;
+		const operations = compactOperations(pendingOperations);
+		pendingOperations = [];
+		try {
+			applyRemoteOperations(operations);
+		} catch (error) {
+			if (isSetStateReentryError(error)) {
+				pendingOperations = [...operations, ...pendingOperations];
+				setTimeout(scheduleFlushFromYjs, 0);
+				return;
+			}
+			if (isYjsSerializableStateError(error) || isStateSchemaError(error)) {
+				restoreRootState();
+				return;
+			}
+			throw error;
+		}
+	};
+	const enqueueSnapshot = (snapshot) => {
+		pendingSnapshot = snapshot;
+		pendingOperations = [];
+		scheduleFlushFromYjs();
+	};
+	const enqueueOperations = (operations) => {
+		if (operations.length === 0) return;
+		if (!pendingSnapshot) pendingOperations.push(...operations);
+		scheduleFlushFromYjs();
+	};
+	const syncNow = () => {
+		if (destroyed || syncingFromYjs) return;
+		try {
+			assertYjsSerializableState(store.getPureState());
+		} catch (error) {
+			restoreLastSyncedState();
+			throw error;
+		}
+		const pureState = clone(store.getPureState());
+		if (!isPlainObject(pureState)) return;
+		doc.transact(() => {
+			syncObjectToYMap(stateMap, lastSyncedState, pureState);
+		}, localOrigin);
+		lastSyncedState = pureState;
+	};
+	const stateObserver = (events, transaction) => {
+		if (transaction.origin === localOrigin) return;
+		enqueueOperations(collectRemoteOperations(events, stateMap));
+	};
+	let stateMap;
+	let stateMapObserved = false;
+	const unobserveStateMap = () => {
+		if (!stateMapObserved) return;
+		stateMap.unobserveDeep(stateObserver);
+		stateMapObserved = false;
+	};
+	const observeStateMap = (nextStateMap) => {
+		if (stateMap === nextStateMap && stateMapObserved) return;
+		unobserveStateMap();
+		stateMap = nextStateMap;
+		stateMap.observeDeep(stateObserver);
+		stateMapObserved = true;
+	};
+	const migrateRootState = (nextState) => {
+		const migrated = createYMap(nextState);
+		doc.transact(() => {
+			map.set(STATE_KEY, migrated);
+		}, localOrigin);
+		observeStateMap(migrated);
+		enqueueSnapshot(nextState);
+	};
+	const restoreRootState = () => {
+		const pureState = clone(store.getPureState());
+		const nextState = isPlainObject(pureState) ? pureState : lastSyncedState;
+		const restored = createYMap(nextState);
+		doc.transact(() => {
+			map.set(STATE_KEY, restored);
+		}, localOrigin);
+		observeStateMap(restored);
+		lastSyncedState = nextState;
+	};
+	const applyInitialRemoteState = (state) => {
+		runWithoutHistoryRecording(store, () => {
+			try {
+				applyRemoteState(state);
+			} catch (error) {
+				if (isYjsSerializableStateError(error) || isStateSchemaError(error)) {
+					restoreRootState();
+					return;
+				}
+				throw error;
+			}
+		});
+	};
+	const existingStateMap = getStateMap();
+	if (existingStateMap) {
+		stateMap = existingStateMap;
+		applyInitialRemoteState(toPlainObject(stateMap));
+	} else {
+		const currentState = map.get(STATE_KEY);
+		if (isPlainObject(currentState)) {
+			stateMap = createYMap(currentState);
+			doc.transact(() => {
+				map.set(STATE_KEY, stateMap);
+			}, localOrigin);
+			applyInitialRemoteState(currentState);
+		} else {
+			const pureState = clone(store.getPureState());
+			stateMap = createYMap(isPlainObject(pureState) ? pureState : {});
+			doc.transact(() => {
+				map.set(STATE_KEY, stateMap);
+			}, localOrigin);
+		}
+	}
+	observeStateMap(stateMap);
+	const observer = (event) => {
+		if (event.transaction.origin === localOrigin) return;
+		if (!event.keysChanged.has(STATE_KEY)) return;
+		const stateChange = event.changes.keys.get(STATE_KEY);
+		const nextStateMap = getStateMap();
+		if (nextStateMap) {
+			observeStateMap(nextStateMap);
+			enqueueSnapshot(toPlainObject(nextStateMap));
+			return;
+		}
+		const currentState = map.get(STATE_KEY);
+		if (isPlainObject(currentState)) {
+			migrateRootState(currentState);
+			return;
+		}
+		if (stateChange?.action === "delete") {
+			migrateRootState({});
+			return;
+		}
+		restoreRootState();
+	};
+	map.observe(observer);
+	const unsubscribe = store.subscribe(() => {
+		syncNow();
+	});
+	const binding = {
+		doc,
+		map,
+		syncNow,
+		destroy: () => {
+			if (destroyed) return;
+			destroyed = true;
+			unsubscribe();
+			map.unobserve(observer);
+			unobserveStateMap();
+			if (!options.doc) doc.destroy();
+		}
+	};
+	if (process.env.NODE_ENV === "test") binding.__unsafeTestOnly__ = { applyRemoteOperations: (operations) => {
+		applyRemoteOperations(operations);
+	} };
+	return binding;
 };
-
-// index.ts
-__reExport(index_exports, src_exports);
-export {
-  __unsafeTestOnly__,
-  bindYjs,
-  yjs
+const yjs = (options = {}) => (store) => {
+	let binding;
+	const cancelBinding = onStoreReady(store, () => {
+		binding = bindYjs(store, options);
+	});
+	const baseDestroy = store.destroy;
+	let destroyed = false;
+	store.destroy = () => {
+		if (destroyed) return;
+		destroyed = true;
+		cancelBinding();
+		binding?.destroy();
+		binding = void 0;
+		baseDestroy();
+	};
+	return store;
 };
+//#endregion
+export { __unsafeTestOnly__, bindYjs, yjs };