@voidhash/mimic 0.0.1-alpha.1 → 0.0.1-alpha.2

package/dist/index.mjs

@@ -0,0 +1,2550 @@
+import { t as __export } from "./chunk-C6wwvPpM.mjs";
+import { Effect, Schema } from "effect";
+import * as Schema$1 from "effect/Schema";
+
+//#region \0@oxc-project+runtime@0.103.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/primitives/shared.ts
+var ValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "_tag", "ValidationError");
+		this.name = "ValidationError";
+	}
+};
+/**
+* Runs all validators against a value, throwing ValidationError if any fail.
+*/
+function runValidators(value, validators) {
+	for (const validator of validators) if (!validator.validate(value)) throw new ValidationError(validator.message);
+}
+/**
+* Checks if an operation is compatible with the given operation definitions.
+* @param operation - The operation to check.
+* @param operationDefinitions - The operation definitions to check against.
+* @returns True if the operation is compatible, false otherwise.
+*/
+function isCompatibleOperation(operation, operationDefinitions) {
+	return Object.values(operationDefinitions).some((value) => value.kind === operation.kind);
+}
+
+//#endregion
+//#region src/OperationDefinition.ts
+const make$5 = (options) => {
+	return {
+		kind: options.kind,
+		payload: options.payload,
+		target: options.target,
+		apply: options.apply
+	};
+};
+
+//#endregion
+//#region src/OperationPath.ts
+var OperationPath_exports = /* @__PURE__ */ __export({
+	decode: () => decode$2,
+	encode: () => encode$2,
+	fromTokens: () => fromTokens,
+	getRelativePath: () => getRelativePath,
+	isPrefix: () => isPrefix,
+	make: () => make$4,
+	pathsEqual: () => pathsEqual,
+	pathsOverlap: () => pathsOverlap
+});
+const parseStringPath = (stringPath) => {
+	return stringPath.split("/");
+};
+const makeStringPathFromTokens = (tokens) => {
+	return tokens.join("/");
+};
+/**
+* Creates a new operation path.
+* @param stringPath - The string path to create the path from.
+* @returns The new operation path.
+*/
+function make$4(stringPath) {
+	const tokensInternal = stringPath ? parseStringPath(stringPath) : [];
+	/**
+	* Returns the tokens of the path.
+	* @returns The tokens of the path.
+	*/
+	const toTokens = () => {
+		return tokensInternal;
+	};
+	/**
+	* Concatenates two paths.
+	* @param other - The other path to concatenate.
+	* @returns The new path.
+	*/
+	const concat = (other) => {
+		return make$4(makeStringPathFromTokens(toTokens().concat(other.toTokens())));
+	};
+	/**
+	* Appends a token to the path.
+	* @param token - The token to append.
+	* @returns The new path.
+	*/
+	const append = (token) => {
+		return make$4(makeStringPathFromTokens(toTokens().concat([token])));
+	};
+	/**
+	* Removes the last token from the path.
+	* @returns The new path.
+	*/
+	const pop = () => {
+		return make$4(makeStringPathFromTokens(toTokens().slice(0, -1)));
+	};
+	/**
+	* Removes the first token from the path.
+	* @returns The new path.
+	*/
+	const shift = () => {
+		return make$4(makeStringPathFromTokens(toTokens().slice(1)));
+	};
+	return {
+		_tag: "OperationPath",
+		toTokens,
+		concat,
+		append,
+		pop,
+		shift
+	};
+}
+/**
+* Creates a new operation path from tokens.
+* @param tokens - The tokens to create the path from.
+* @returns The new operation path.
+*/
+function fromTokens(tokens) {
+	return make$4(makeStringPathFromTokens(tokens));
+}
+/**
+* Checks if two operation paths overlap (one is prefix of the other or equal).
+*/
+const pathsOverlap = (pathA, pathB) => {
+	const tokensA = pathA.toTokens().filter((t) => t !== "");
+	const tokensB = pathB.toTokens().filter((t) => t !== "");
+	const minLength = Math.min(tokensA.length, tokensB.length);
+	for (let i = 0; i < minLength; i++) if (tokensA[i] !== tokensB[i]) return false;
+	return true;
+};
+/**
+* Checks if pathA is a prefix of pathB (pathA is ancestor of pathB).
+*/
+const isPrefix = (pathA, pathB) => {
+	const tokensA = pathA.toTokens().filter((t) => t !== "");
+	const tokensB = pathB.toTokens().filter((t) => t !== "");
+	if (tokensA.length > tokensB.length) return false;
+	for (let i = 0; i < tokensA.length; i++) if (tokensA[i] !== tokensB[i]) return false;
+	return true;
+};
+/**
+* Checks if two paths are exactly equal.
+*/
+const pathsEqual = (pathA, pathB) => {
+	const tokensA = pathA.toTokens().filter((t) => t !== "");
+	const tokensB = pathB.toTokens().filter((t) => t !== "");
+	if (tokensA.length !== tokensB.length) return false;
+	for (let i = 0; i < tokensA.length; i++) if (tokensA[i] !== tokensB[i]) return false;
+	return true;
+};
+/**
+* Gets the relative path of pathB with respect to pathA.
+* Assumes pathA is a prefix of pathB.
+*/
+const getRelativePath = (basePath, fullPath) => {
+	const baseTokens = basePath.toTokens().filter((t) => t !== "");
+	return fullPath.toTokens().filter((t) => t !== "").slice(baseTokens.length);
+};
+/**
+* Encodes an OperationPath to a string for network transport.
+* @param path - The operation path to encode.
+* @returns The encoded string representation.
+*/
+const encode$2 = (path) => {
+	return makeStringPathFromTokens(path.toTokens());
+};
+/**
+* Decodes an encoded string back to an OperationPath.
+* @param encoded - The encoded string representation.
+* @returns The decoded OperationPath.
+*/
+const decode$2 = (encoded) => {
+	return make$4(encoded);
+};
+
+//#endregion
+//#region src/Operation.ts
+var Operation_exports = /* @__PURE__ */ __export({
+	decode: () => decode$1,
+	encode: () => encode$1,
+	fromDefinition: () => fromDefinition
+});
+const fromDefinition = (operationPath, definition, payload) => {
+	return {
+		kind: definition.kind,
+		path: operationPath,
+		payload
+	};
+};
+/**
+* Encodes an Operation to a JSON-serializable format for network transport.
+* @param operation - The operation to encode.
+* @returns The encoded representation.
+*/
+const encode$1 = (operation) => {
+	return {
+		kind: operation.kind,
+		path: encode$2(operation.path),
+		payload: operation.payload
+	};
+};
+/**
+* Decodes an encoded operation back to an Operation.
+* Note: This returns a partial operation without the definition methods.
+* The caller must have the operation definitions to fully reconstruct if needed.
+* @param encoded - The encoded representation.
+* @returns The decoded Operation (without definition-specific methods).
+*/
+const decode$1 = (encoded) => {
+	return {
+		kind: encoded.kind,
+		path: decode$2(encoded.path),
+		payload: encoded.payload
+	};
+};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r$1) {
+			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
+			_defineProperty(e, r$1, t[r$1]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+		});
+	}
+	return e;
+}
+
+//#endregion
+//#region src/primitives/String.ts
+var StringPrimitive = class StringPrimitive {
+	constructor(schema) {
+		_defineProperty(this, "_tag", "StringPrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make$5({
+			kind: "string.set",
+			payload: Schema.String,
+			target: Schema.String,
+			apply: (payload) => payload
+		}) });
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const defaultValue = this._schema.defaultValue;
+				return {
+					get: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					},
+					set: (value) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, value));
+					},
+					toSnapshot: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					}
+				};
+			},
+			applyOperation: (state, operation) => {
+				if (!isCompatibleOperation(operation, this._opDefinitions)) throw new ValidationError(`StringPrimitive cannot apply operation of kind: ${operation.kind}`);
+				const payload = operation.payload;
+				if (typeof payload !== "string") throw new ValidationError(`StringPrimitive.set requires a string payload, got: ${typeof payload}`);
+				runValidators(payload, this._schema.validators);
+				return payload;
+			},
+			getInitialState: () => {
+				return this._schema.defaultValue;
+			},
+			transformOperation: (clientOp, serverOp) => {
+				if (!pathsOverlap(clientOp.path, serverOp.path)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this string as required */
+	required() {
+		return new StringPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this string */
+	default(defaultValue) {
+		return new StringPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue }));
+	}
+	/** Add a custom validation rule */
+	refine(fn, message) {
+		return new StringPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { validators: [...this._schema.validators, {
+			validate: fn,
+			message
+		}] }));
+	}
+	/** Minimum string length */
+	min(length) {
+		return this.refine((v) => v.length >= length, `String must be at least ${length} characters`);
+	}
+	/** Maximum string length */
+	max(length) {
+		return this.refine((v) => v.length <= length, `String must be at most ${length} characters`);
+	}
+	/** Exact string length */
+	length(exact) {
+		return this.refine((v) => v.length === exact, `String must be exactly ${exact} characters`);
+	}
+	/** Match a regex pattern */
+	regex(pattern, message) {
+		return this.refine((v) => pattern.test(v), message !== null && message !== void 0 ? message : `String must match pattern ${pattern}`);
+	}
+	/** Validate as email format */
+	email() {
+		const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+		return this.refine((v) => emailPattern.test(v), "Invalid email format");
+	}
+	/** Validate as URL format */
+	url() {
+		return this.refine((v) => {
+			try {
+				new URL(v);
+				return true;
+			} catch (_unused) {
+				return false;
+			}
+		}, "Invalid URL format");
+	}
+};
+/** Creates a new StringPrimitive */
+const String$1 = () => new StringPrimitive({
+	required: false,
+	defaultValue: void 0,
+	validators: []
+});
+
+//#endregion
+//#region src/primitives/Struct.ts
+var StructPrimitive = class StructPrimitive {
+	constructor(schema) {
+		_defineProperty(this, "_tag", "StructPrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make$5({
+			kind: "struct.set",
+			payload: Schema.Unknown,
+			target: Schema.Unknown,
+			apply: (payload) => payload
+		}) });
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const fields = this._schema.fields;
+				const defaultValue = this._schema.defaultValue;
+				const buildSnapshot = () => {
+					const state = env.getState(operationPath);
+					const snapshot = {};
+					let hasAnyDefinedField = false;
+					for (const key in fields) {
+						const fieldPrimitive = fields[key];
+						const fieldPath = operationPath.append(key);
+						const fieldSnapshot = fieldPrimitive._internal.createProxy(env, fieldPath).toSnapshot();
+						snapshot[key] = fieldSnapshot;
+						if (fieldSnapshot !== void 0) hasAnyDefinedField = true;
+					}
+					if (state === void 0 && defaultValue === void 0 && !hasAnyDefinedField) return;
+					return snapshot;
+				};
+				return new globalThis.Proxy({
+					get: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					},
+					set: (value) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, value));
+					},
+					toSnapshot: () => {
+						return buildSnapshot();
+					}
+				}, {
+					get: (target, prop, receiver) => {
+						if (prop === "get") return target.get;
+						if (prop === "set") return target.set;
+						if (prop === "toSnapshot") return target.toSnapshot;
+						if (typeof prop === "symbol") return;
+						if (prop in fields) {
+							const fieldPrimitive = fields[prop];
+							const fieldPath = operationPath.append(prop);
+							return fieldPrimitive._internal.createProxy(env, fieldPath);
+						}
+					},
+					has: (target, prop) => {
+						if (prop === "get" || prop === "set" || prop === "toSnapshot") return true;
+						if (typeof prop === "string" && prop in fields) return true;
+						return false;
+					}
+				});
+			},
+			applyOperation: (state, operation) => {
+				const path = operation.path;
+				const tokens = path.toTokens().filter((t) => t !== "");
+				let newState;
+				if (tokens.length === 0) {
+					if (operation.kind !== "struct.set") throw new ValidationError(`StructPrimitive root cannot apply operation of kind: ${operation.kind}`);
+					const payload = operation.payload;
+					if (typeof payload !== "object" || payload === null) throw new ValidationError(`StructPrimitive.set requires an object payload`);
+					newState = payload;
+				} else {
+					const fieldName = tokens[0];
+					if (!(fieldName in this._schema.fields)) throw new ValidationError(`Unknown field: ${globalThis.String(fieldName)}`);
+					const fieldPrimitive = this._schema.fields[fieldName];
+					const remainingPath = path.shift();
+					const fieldOperation = _objectSpread2(_objectSpread2({}, operation), {}, { path: remainingPath });
+					const currentState = state !== null && state !== void 0 ? state : {};
+					const currentFieldState = currentState[fieldName];
+					const newFieldState = fieldPrimitive._internal.applyOperation(currentFieldState, fieldOperation);
+					newState = _objectSpread2(_objectSpread2({}, currentState), {}, { [fieldName]: newFieldState });
+				}
+				runValidators(newState, this._schema.validators);
+				return newState;
+			},
+			getInitialState: () => {
+				if (this._schema.defaultValue !== void 0) return this._schema.defaultValue;
+				const fields = this._schema.fields;
+				const initialState = {};
+				let hasAnyDefault = false;
+				for (const key in fields) {
+					const fieldDefault = fields[key]._internal.getInitialState();
+					if (fieldDefault !== void 0) {
+						initialState[key] = fieldDefault;
+						hasAnyDefault = true;
+					}
+				}
+				return hasAnyDefault ? initialState : void 0;
+			},
+			transformOperation: (clientOp, serverOp) => {
+				const clientPath = clientOp.path;
+				const serverPath = serverOp.path;
+				if (!pathsOverlap(clientPath, serverPath)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				const clientTokens = clientPath.toTokens().filter((t) => t !== "");
+				const serverTokens = serverPath.toTokens().filter((t) => t !== "");
+				if (clientTokens.length === 0 && serverTokens.length === 0) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (serverTokens.length === 0 && serverOp.kind === "struct.set") return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (clientTokens.length === 0 && clientOp.kind === "struct.set") return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (clientTokens.length > 0 && serverTokens.length > 0) {
+					const clientField = clientTokens[0];
+					if (clientField !== serverTokens[0]) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					const fieldPrimitive = this._schema.fields[clientField];
+					if (!fieldPrimitive) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					const clientOpForField = _objectSpread2(_objectSpread2({}, clientOp), {}, { path: clientOp.path.shift() });
+					const serverOpForField = _objectSpread2(_objectSpread2({}, serverOp), {}, { path: serverOp.path.shift() });
+					const result = fieldPrimitive._internal.transformOperation(clientOpForField, serverOpForField);
+					if (result.type === "transformed") return {
+						type: "transformed",
+						operation: _objectSpread2(_objectSpread2({}, result.operation), {}, { path: clientOp.path })
+					};
+					return result;
+				}
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this struct as required */
+	required() {
+		return new StructPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this struct */
+	default(defaultValue) {
+		return new StructPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue }));
+	}
+	/** Get the fields schema */
+	get fields() {
+		return this._schema.fields;
+	}
+	/** Add a custom validation rule (useful for cross-field validation) */
+	refine(fn, message) {
+		return new StructPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { validators: [...this._schema.validators, {
+			validate: fn,
+			message
+		}] }));
+	}
+};
+/** Creates a new StructPrimitive with the given fields */
+const Struct = (fields) => new StructPrimitive({
+	required: false,
+	defaultValue: void 0,
+	fields,
+	validators: []
+});
+
+//#endregion
+//#region src/primitives/Boolean.ts
+var BooleanPrimitive = class BooleanPrimitive {
+	constructor(schema) {
+		_defineProperty(this, "_tag", "BooleanPrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make$5({
+			kind: "boolean.set",
+			payload: Schema.Boolean,
+			target: Schema.Boolean,
+			apply: (payload) => payload
+		}) });
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const defaultValue = this._schema.defaultValue;
+				return {
+					get: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					},
+					set: (value) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, value));
+					},
+					toSnapshot: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					}
+				};
+			},
+			applyOperation: (state, operation) => {
+				if (operation.kind !== "boolean.set") throw new ValidationError(`BooleanPrimitive cannot apply operation of kind: ${operation.kind}`);
+				const payload = operation.payload;
+				if (typeof payload !== "boolean") throw new ValidationError(`BooleanPrimitive.set requires a boolean payload, got: ${typeof payload}`);
+				runValidators(payload, this._schema.validators);
+				return payload;
+			},
+			getInitialState: () => {
+				return this._schema.defaultValue;
+			},
+			transformOperation: (clientOp, serverOp) => {
+				if (!pathsOverlap(clientOp.path, serverOp.path)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this boolean as required */
+	required() {
+		return new BooleanPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this boolean */
+	default(defaultValue) {
+		return new BooleanPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue }));
+	}
+	/** Add a custom validation rule */
+	refine(fn, message) {
+		return new BooleanPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { validators: [...this._schema.validators, {
+			validate: fn,
+			message
+		}] }));
+	}
+};
+/** Creates a new BooleanPrimitive */
+const Boolean = () => new BooleanPrimitive({
+	required: false,
+	defaultValue: void 0,
+	validators: []
+});
+
+//#endregion
+//#region src/primitives/Number.ts
+var NumberPrimitive = class NumberPrimitive {
+	constructor(schema) {
+		_defineProperty(this, "_tag", "NumberPrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make$5({
+			kind: "number.set",
+			payload: Schema.Number,
+			target: Schema.Number,
+			apply: (payload) => payload
+		}) });
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const defaultValue = this._schema.defaultValue;
+				return {
+					get: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					},
+					set: (value) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, value));
+					},
+					toSnapshot: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					}
+				};
+			},
+			applyOperation: (state, operation) => {
+				if (operation.kind !== "number.set") throw new ValidationError(`NumberPrimitive cannot apply operation of kind: ${operation.kind}`);
+				const payload = operation.payload;
+				if (typeof payload !== "number") throw new ValidationError(`NumberPrimitive.set requires a number payload, got: ${typeof payload}`);
+				runValidators(payload, this._schema.validators);
+				return payload;
+			},
+			getInitialState: () => {
+				return this._schema.defaultValue;
+			},
+			transformOperation: (clientOp, serverOp) => {
+				if (!pathsOverlap(clientOp.path, serverOp.path)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this number as required */
+	required() {
+		return new NumberPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this number */
+	default(defaultValue) {
+		return new NumberPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue }));
+	}
+	/** Add a custom validation rule */
+	refine(fn, message) {
+		return new NumberPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { validators: [...this._schema.validators, {
+			validate: fn,
+			message
+		}] }));
+	}
+	/** Minimum value (inclusive) */
+	min(value) {
+		return this.refine((v) => v >= value, `Number must be at least ${value}`);
+	}
+	/** Maximum value (inclusive) */
+	max(value) {
+		return this.refine((v) => v <= value, `Number must be at most ${value}`);
+	}
+	/** Must be positive (> 0) */
+	positive() {
+		return this.refine((v) => v > 0, "Number must be positive");
+	}
+	/** Must be negative (< 0) */
+	negative() {
+		return this.refine((v) => v < 0, "Number must be negative");
+	}
+	/** Must be an integer */
+	int() {
+		return this.refine((v) => globalThis.Number.isInteger(v), "Number must be an integer");
+	}
+};
+/** Creates a new NumberPrimitive */
+const Number$1 = () => new NumberPrimitive({
+	required: false,
+	defaultValue: void 0,
+	validators: []
+});
+
+//#endregion
+//#region src/primitives/Literal.ts
+var LiteralPrimitive = class LiteralPrimitive {
+	constructor(schema) {
+		_defineProperty(this, "_tag", "LiteralPrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make$5({
+			kind: "literal.set",
+			payload: Schema.Unknown,
+			target: Schema.Unknown,
+			apply: (payload) => payload
+		}) });
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const defaultValue = this._schema.defaultValue;
+				return {
+					get: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					},
+					set: (value) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, value));
+					},
+					toSnapshot: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					}
+				};
+			},
+			applyOperation: (state, operation) => {
+				if (operation.kind !== "literal.set") throw new ValidationError(`LiteralPrimitive cannot apply operation of kind: ${operation.kind}`);
+				const payload = operation.payload;
+				if (payload !== this._schema.literal) throw new ValidationError(`LiteralPrimitive.set requires the exact literal value "${globalThis.String(this._schema.literal)}", got: "${globalThis.String(payload)}"`);
+				return payload;
+			},
+			getInitialState: () => {
+				return this._schema.defaultValue;
+			},
+			transformOperation: (clientOp, serverOp) => {
+				if (!pathsOverlap(clientOp.path, serverOp.path)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this literal as required */
+	required() {
+		return new LiteralPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this literal */
+	default(defaultValue) {
+		return new LiteralPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue }));
+	}
+	/** Get the literal value this primitive represents */
+	get literal() {
+		return this._schema.literal;
+	}
+};
+/** Creates a new LiteralPrimitive with the given literal value */
+const Literal = (literal) => new LiteralPrimitive({
+	required: false,
+	defaultValue: void 0,
+	literal
+});
+
+//#endregion
+//#region src/FractionalIndex.ts
+function createCharSetDicts(charSet) {
+	const byCode = {};
+	const byChar = {};
+	const length = charSet.length;
+	for (let i = 0; i < length; i++) {
+		const char = charSet[i];
+		if (char === void 0) throw new Error("invalid charSet: missing character at index " + i);
+		byCode[i] = char;
+		byChar[char] = i;
+	}
+	return {
+		byCode,
+		byChar,
+		length
+	};
+}
+function integerLimits(dicts, firstPositive, mostPositive, mostNegative) {
+	return Effect.gen(function* () {
+		const firstPositiveIndex = firstPositive ? dicts.byChar[firstPositive] : Math.ceil(dicts.length / 2);
+		const mostPositiveIndex = mostPositive ? dicts.byChar[mostPositive] : dicts.length - 1;
+		const mostNegativeIndex = mostNegative ? dicts.byChar[mostNegative] : 0;
+		if (firstPositiveIndex === void 0 || mostPositiveIndex === void 0 || mostNegativeIndex === void 0) return yield* Effect.fail(/* @__PURE__ */ new Error("invalid charSet"));
+		if (mostPositiveIndex - firstPositiveIndex < 3) return yield* Effect.fail(/* @__PURE__ */ new Error("mostPositive must be at least 3 characters away from neutral"));
+		if (firstPositiveIndex - mostNegativeIndex < 3) return yield* Effect.fail(/* @__PURE__ */ new Error("mostNegative must be at least 3 characters away from neutral"));
+		const firstPositiveChar = dicts.byCode[firstPositiveIndex];
+		const mostPositiveChar = dicts.byCode[mostPositiveIndex];
+		const firstNegativeChar = dicts.byCode[firstPositiveIndex - 1];
+		const mostNegativeChar = dicts.byCode[mostNegativeIndex];
+		if (firstPositiveChar === void 0 || mostPositiveChar === void 0 || firstNegativeChar === void 0 || mostNegativeChar === void 0) return yield* Effect.fail(/* @__PURE__ */ new Error("invalid charSet"));
+		return {
+			firstPositive: firstPositiveChar,
+			mostPositive: mostPositiveChar,
+			firstNegative: firstNegativeChar,
+			mostNegative: mostNegativeChar
+		};
+	});
+}
+function paddingDict(jitterRange, charSetLength) {
+	const paddingDict$1 = {};
+	for (let i = 0; i < 100; i++) {
+		const value = Math.pow(charSetLength, i);
+		paddingDict$1[i] = value;
+		if (value > jitterRange) break;
+	}
+	return paddingDict$1;
+}
+function validateChars(characters) {
+	if (characters.length < 7) return Effect.fail(/* @__PURE__ */ new Error("charSet must be at least 7 characters long"));
+	if (!(characters.split("").sort().join("") === characters)) return Effect.fail(/* @__PURE__ */ new Error("charSet must be sorted"));
+	return Effect.void;
+}
+function indexCharacterSet(options) {
+	return Effect.gen(function* () {
+		var _options$jitterRange;
+		yield* validateChars(options.chars);
+		const dicts = createCharSetDicts(options.chars);
+		const limits = yield* integerLimits(dicts, options.firstPositive, options.mostPositive, options.mostNegative);
+		const jitterRange = (_options$jitterRange = options.jitterRange) !== null && _options$jitterRange !== void 0 ? _options$jitterRange : Math.floor(Math.pow(dicts.length, 3) / 5);
+		const paddingRange = paddingDict(jitterRange, dicts.length);
+		const first = dicts.byCode[0];
+		const last = dicts.byCode[dicts.length - 1];
+		if (first === void 0 || last === void 0) return yield* Effect.fail(/* @__PURE__ */ new Error("invalid charSet"));
+		return {
+			chars: options.chars,
+			byChar: dicts.byChar,
+			byCode: dicts.byCode,
+			length: dicts.length,
+			first,
+			last,
+			firstPositive: limits.firstPositive,
+			mostPositive: limits.mostPositive,
+			firstNegative: limits.firstNegative,
+			mostNegative: limits.mostNegative,
+			jitterRange,
+			paddingDict: paddingRange
+		};
+	});
+}
+let _base62CharSet = null;
+function base62CharSet() {
+	if (_base62CharSet) return _base62CharSet;
+	_base62CharSet = Effect.runSync(indexCharacterSet({
+		chars: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+		firstPositive: "a",
+		mostPositive: "z",
+		mostNegative: "A"
+	}));
+	return _base62CharSet;
+}
+function makeSameLength(a, b, pad, fillChar, forceLength) {
+	const max = forceLength !== null && forceLength !== void 0 ? forceLength : Math.max(a.length, b.length);
+	if (pad === "start") return [a.padStart(max, fillChar), b.padStart(max, fillChar)];
+	return [a.padEnd(max, fillChar), b.padEnd(max, fillChar)];
+}
+function distanceBetween(a, b, charSet) {
+	const indexA = charSet.byChar[a];
+	const indexB = charSet.byChar[b];
+	if (indexA === void 0 || indexB === void 0) return Effect.fail(/* @__PURE__ */ new Error("invalid character in distance calculation"));
+	return Effect.succeed(Math.abs(indexA - indexB));
+}
+function integerLengthFromSecondLevel(key, direction, charSet) {
+	if (key.length === 0) return Effect.succeed(0);
+	const firstChar = key[0];
+	if (!firstChar || firstChar > charSet.mostPositive || firstChar < charSet.mostNegative) return Effect.fail(/* @__PURE__ */ new Error("invalid firstChar on key"));
+	if (firstChar === charSet.mostPositive && direction === "positive") return Effect.gen(function* () {
+		const totalPositiveRoom = yield* distanceBetween(firstChar, charSet.mostNegative, charSet);
+		const rest = yield* integerLengthFromSecondLevel(key.slice(1), direction, charSet);
+		return totalPositiveRoom + 1 + rest;
+	});
+	if (firstChar === charSet.mostNegative && direction === "negative") return Effect.gen(function* () {
+		const totalNegativeRoom = yield* distanceBetween(firstChar, charSet.mostPositive, charSet);
+		const rest = yield* integerLengthFromSecondLevel(key.slice(1), direction, charSet);
+		return totalNegativeRoom + 1 + rest;
+	});
+	if (direction === "positive") return Effect.gen(function* () {
+		return (yield* distanceBetween(firstChar, charSet.mostNegative, charSet)) + 2;
+	});
+	else return Effect.gen(function* () {
+		return (yield* distanceBetween(firstChar, charSet.mostPositive, charSet)) + 2;
+	});
+}
+function integerLength(head, charSet) {
+	if (head.length === 0) return Effect.fail(/* @__PURE__ */ new Error("head cannot be empty"));
+	const firstChar = head[0];
+	if (!firstChar || firstChar > charSet.mostPositive || firstChar < charSet.mostNegative) return Effect.fail(/* @__PURE__ */ new Error("invalid firstChar on key"));
+	if (firstChar === charSet.mostPositive) return Effect.gen(function* () {
+		const firstLevel = yield* distanceBetween(firstChar, charSet.firstPositive, charSet);
+		const rest = yield* integerLengthFromSecondLevel(head.slice(1), "positive", charSet);
+		return firstLevel + 1 + rest;
+	});
+	if (firstChar === charSet.mostNegative) return Effect.gen(function* () {
+		const firstLevel = yield* distanceBetween(firstChar, charSet.firstNegative, charSet);
+		const rest = yield* integerLengthFromSecondLevel(head.slice(1), "negative", charSet);
+		return firstLevel + 1 + rest;
+	});
+	if (firstChar >= charSet.firstPositive) return Effect.gen(function* () {
+		return (yield* distanceBetween(firstChar, charSet.firstPositive, charSet)) + 2;
+	});
+	else return Effect.gen(function* () {
+		return (yield* distanceBetween(firstChar, charSet.firstNegative, charSet)) + 2;
+	});
+}
+function encodeToCharSet(int, charSet) {
+	if (int === 0) {
+		const zero = charSet.byCode[0];
+		if (zero === void 0) return Effect.fail(/* @__PURE__ */ new Error("invalid charSet: missing code 0"));
+		return Effect.succeed(zero);
+	}
+	let res = "";
+	const max = charSet.length;
+	while (int > 0) {
+		const code = charSet.byCode[int % max];
+		if (code === void 0) return Effect.fail(/* @__PURE__ */ new Error("invalid character code in encodeToCharSet"));
+		res = code + res;
+		int = Math.floor(int / max);
+	}
+	return Effect.succeed(res);
+}
+function decodeCharSetToNumber(key, charSet) {
+	let res = 0;
+	const length = key.length;
+	const max = charSet.length;
+	for (let i = 0; i < length; i++) {
+		const char = key[i];
+		if (char === void 0) continue;
+		const charIndex = charSet.byChar[char];
+		if (charIndex === void 0) continue;
+		res += charIndex * Math.pow(max, length - i - 1);
+	}
+	return res;
+}
+function addCharSetKeys(a, b, charSet) {
+	const base = charSet.length;
+	const [paddedA, paddedB] = makeSameLength(a, b, "start", charSet.first);
+	const result = [];
+	let carry = 0;
+	for (let i = paddedA.length - 1; i >= 0; i--) {
+		const charA = paddedA[i];
+		const charB = paddedB[i];
+		if (!charA || !charB) return Effect.fail(/* @__PURE__ */ new Error("invalid character in addCharSetKeys"));
+		const digitA = charSet.byChar[charA];
+		const digitB = charSet.byChar[charB];
+		if (digitA === void 0 || digitB === void 0) return Effect.fail(/* @__PURE__ */ new Error("invalid character in addCharSetKeys"));
+		const sum = digitA + digitB + carry;
+		carry = Math.floor(sum / base);
+		const remainder = sum % base;
+		const codeChar = charSet.byCode[remainder];
+		if (codeChar === void 0) return Effect.fail(/* @__PURE__ */ new Error("invalid character code in addCharSetKeys"));
+		result.unshift(codeChar);
+	}
+	if (carry > 0) {
+		const carryChar = charSet.byCode[carry];
+		if (carryChar === void 0) return Effect.fail(/* @__PURE__ */ new Error("invalid carry character code"));
+		result.unshift(carryChar);
+	}
+	return Effect.succeed(result.join(""));
+}
+function subtractCharSetKeys(a, b, charSet, stripLeadingZeros = true) {
+	const base = charSet.length;
+	const [paddedA, paddedB] = makeSameLength(a, b, "start", charSet.first);
+	const result = [];
+	let borrow = 0;
+	for (let i = paddedA.length - 1; i >= 0; i--) {
+		const charA = paddedA[i];
+		const charB = paddedB[i];
+		if (!charA || !charB) return Effect.fail(/* @__PURE__ */ new Error("invalid character in subtractCharSetKeys"));
+		let digitA = charSet.byChar[charA];
+		const digitBValue = charSet.byChar[charB];
+		if (digitA === void 0 || digitBValue === void 0) return Effect.fail(/* @__PURE__ */ new Error("invalid character in subtractCharSetKeys"));
+		const digitB = digitBValue + borrow;
+		if (digitA < digitB) {
+			borrow = 1;
+			digitA += base;
+		} else borrow = 0;
+		const difference = digitA - digitB;
+		const codeChar = charSet.byCode[difference];
+		if (codeChar === void 0) return Effect.fail(/* @__PURE__ */ new Error("invalid character code in subtractCharSetKeys"));
+		result.unshift(codeChar);
+	}
+	if (borrow > 0) return Effect.fail(/* @__PURE__ */ new Error("Subtraction result is negative. Ensure a is greater than or equal to b."));
+	while (stripLeadingZeros && result.length > 1 && result[0] === charSet.first) result.shift();
+	return Effect.succeed(result.join(""));
+}
+function incrementKey(key, charSet) {
+	const one = charSet.byCode[1];
+	if (one === void 0) return Effect.fail(/* @__PURE__ */ new Error("invalid charSet: missing code 1"));
+	return addCharSetKeys(key, one, charSet);
+}
+function decrementKey(key, charSet) {
+	const one = charSet.byCode[1];
+	if (one === void 0) return Effect.fail(/* @__PURE__ */ new Error("invalid charSet: missing code 1"));
+	return subtractCharSetKeys(key, one, charSet, false);
+}
+function lexicalDistance(a, b, charSet) {
+	const [lower, upper] = makeSameLength(a, b, "end", charSet.first).sort();
+	return Effect.gen(function* () {
+		return decodeCharSetToNumber(yield* subtractCharSetKeys(upper, lower, charSet), charSet);
+	});
+}
+function midPoint(lower, upper, charSet) {
+	return Effect.gen(function* () {
+		let [paddedLower, paddedUpper] = makeSameLength(lower, upper, "end", charSet.first);
+		let distance = yield* lexicalDistance(paddedLower, paddedUpper, charSet);
+		if (distance === 1) {
+			paddedLower = paddedLower.padEnd(paddedLower.length + 1, charSet.first);
+			distance = charSet.length;
+		}
+		const mid = yield* encodeToCharSet(Math.floor(distance / 2), charSet);
+		return yield* addCharSetKeys(paddedLower, mid, charSet);
+	});
+}
+function startKey(charSet) {
+	return charSet.firstPositive + charSet.byCode[0];
+}
+function validInteger(integer, charSet) {
+	return Effect.gen(function* () {
+		return (yield* integerLength(integer, charSet)) === integer.length;
+	});
+}
+function validateOrderKey(orderKey, charSet) {
+	return Effect.gen(function* () {
+		yield* getIntegerPart(orderKey, charSet);
+	});
+}
+function getIntegerPart(orderKey, charSet) {
+	return Effect.gen(function* () {
+		const integerPartLength = yield* integerLength(integerHead(orderKey, charSet), charSet);
+		if (integerPartLength > orderKey.length) return yield* Effect.fail(/* @__PURE__ */ new Error("invalid order key length: " + orderKey));
+		return orderKey.slice(0, integerPartLength);
+	});
+}
+function validateInteger(integer, charSet) {
+	return Effect.gen(function* () {
+		if (!(yield* validInteger(integer, charSet))) return yield* Effect.fail(/* @__PURE__ */ new Error("invalid integer length: " + integer));
+	});
+}
+function integerHead(integer, charSet) {
+	let i = 0;
+	if (integer[0] === charSet.mostPositive) while (integer[i] === charSet.mostPositive) i = i + 1;
+	if (integer[0] === charSet.mostNegative) while (integer[i] === charSet.mostNegative) i = i + 1;
+	return integer.slice(0, i + 1);
+}
+function splitInteger(integer, charSet) {
+	return Effect.gen(function* () {
+		const head = integerHead(integer, {
+			firstPositive: charSet.firstPositive,
+			mostPositive: charSet.mostPositive,
+			firstNegative: charSet.firstNegative,
+			mostNegative: charSet.mostNegative
+		});
+		return [head, integer.slice(head.length)];
+	});
+}
+function incrementIntegerHead(head, charSet) {
+	return Effect.gen(function* () {
+		const inPositiveRange = head >= charSet.firstPositive;
+		const nextHead = yield* incrementKey(head, charSet);
+		const headIsLimitMax = head[head.length - 1] === charSet.mostPositive;
+		const nextHeadIsLimitMax = nextHead[nextHead.length - 1] === charSet.mostPositive;
+		if (inPositiveRange && nextHeadIsLimitMax) return nextHead + charSet.mostNegative;
+		if (!inPositiveRange && headIsLimitMax) return head.slice(0, head.length - 1);
+		return nextHead;
+	});
+}
+function decrementIntegerHead(head, charSet) {
+	return Effect.gen(function* () {
+		const inPositiveRange = head >= charSet.firstPositive;
+		const headIsLimitMin = head[head.length - 1] === charSet.mostNegative;
+		if (inPositiveRange && headIsLimitMin) return yield* decrementKey(head.slice(0, head.length - 1), charSet);
+		if (!inPositiveRange && headIsLimitMin) return head + charSet.mostPositive;
+		return yield* decrementKey(head, charSet);
+	});
+}
+function startOnNewHead(head, limit, charSet) {
+	return Effect.gen(function* () {
+		const newLength = yield* integerLength(head, charSet);
+		const fillCharCode = limit === "upper" ? charSet.length - 1 : 0;
+		const fillChar = charSet.byCode[fillCharCode];
+		if (fillChar === void 0) return yield* Effect.fail(/* @__PURE__ */ new Error("invalid fill character code"));
+		return head + fillChar.repeat(newLength - head.length);
+	});
+}
+function incrementInteger(integer, charSet) {
+	return Effect.gen(function* () {
+		yield* validateInteger(integer, charSet);
+		const [head, digs] = yield* splitInteger(integer, charSet);
+		const maxChar = charSet.byCode[charSet.length - 1];
+		if (maxChar === void 0) return yield* Effect.fail(/* @__PURE__ */ new Error("invalid charSet: missing max character"));
+		if (digs.split("").some((d) => d !== maxChar)) return head + (yield* incrementKey(digs, charSet));
+		return yield* startOnNewHead(yield* incrementIntegerHead(head, charSet), "lower", charSet);
+	});
+}
+function decrementInteger(integer, charSet) {
+	return Effect.gen(function* () {
+		yield* validateInteger(integer, charSet);
+		const [head, digs] = yield* splitInteger(integer, charSet);
+		const minChar = charSet.byCode[0];
+		if (minChar === void 0) return yield* Effect.fail(/* @__PURE__ */ new Error("invalid charSet: missing min character"));
+		if (digs.split("").some((d) => d !== minChar)) return head + (yield* decrementKey(digs, charSet));
+		return yield* startOnNewHead(yield* decrementIntegerHead(head, charSet), "upper", charSet);
+	});
+}
+/**
+* Generate a key between two other keys.
+* If either lower or upper is null, the key will be generated at the start or end of the list.
+*/
+function generateKeyBetween(lower, upper, charSet = base62CharSet()) {
+	return Effect.gen(function* () {
+		if (lower !== null) yield* validateOrderKey(lower, charSet);
+		if (upper !== null) yield* validateOrderKey(upper, charSet);
+		if (lower === null && upper === null) return startKey(charSet);
+		if (lower === null) return yield* decrementInteger(yield* getIntegerPart(upper, charSet), charSet);
+		if (upper === null) return yield* incrementInteger(yield* getIntegerPart(lower, charSet), charSet);
+		if (lower >= upper) return yield* Effect.fail(/* @__PURE__ */ new Error(lower + " >= " + upper));
+		return yield* midPoint(lower, upper, charSet);
+	});
+}
+
+//#endregion
+//#region src/primitives/Array.ts
+/**
+* Sort array entries by their fractional position
+*/
+const sortByPos = (entries) => [...entries].sort((a, b) => a.pos < b.pos ? -1 : a.pos > b.pos ? 1 : 0);
+/**
+* Generate a fractional position between two positions
+*/
+const generatePosBetween = (left, right) => {
+	const charSet = base62CharSet();
+	return Effect.runSync(generateKeyBetween(left, right, charSet));
+};
+var ArrayPrimitive = class ArrayPrimitive {
+	constructor(schema) {
+		_defineProperty(this, "_tag", "ArrayPrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", {
+			set: make$5({
+				kind: "array.set",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			insert: make$5({
+				kind: "array.insert",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			remove: make$5({
+				kind: "array.remove",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			move: make$5({
+				kind: "array.move",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			})
+		});
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const elementPrimitive = this._schema.element;
+				const getCurrentState = () => {
+					const state = env.getState(operationPath);
+					if (!state || !globalThis.Array.isArray(state)) return [];
+					return sortByPos(state);
+				};
+				return {
+					get: () => {
+						return getCurrentState();
+					},
+					set: (values) => {
+						const entries = [];
+						let prevPos = null;
+						for (const value of values) {
+							const id = env.generateId();
+							const pos = generatePosBetween(prevPos, null);
+							entries.push({
+								id,
+								pos,
+								value
+							});
+							prevPos = pos;
+						}
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, entries));
+					},
+					push: (value) => {
+						const sorted = getCurrentState();
+						const lastPos = sorted.length > 0 ? sorted[sorted.length - 1].pos : null;
+						const id = env.generateId();
+						const pos = generatePosBetween(lastPos, null);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							pos,
+							value
+						}));
+					},
+					insertAt: (index, value) => {
+						const sorted = getCurrentState();
+						const leftPos = index > 0 && sorted[index - 1] ? sorted[index - 1].pos : null;
+						const rightPos = index < sorted.length && sorted[index] ? sorted[index].pos : null;
+						const id = env.generateId();
+						const pos = generatePosBetween(leftPos, rightPos);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							pos,
+							value
+						}));
+					},
+					remove: (id) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.remove, { id }));
+					},
+					move: (id, toIndex) => {
+						const without = getCurrentState().filter((e) => e.id !== id);
+						const clampedIndex = Math.max(0, Math.min(toIndex, without.length));
+						const pos = generatePosBetween(clampedIndex > 0 && without[clampedIndex - 1] ? without[clampedIndex - 1].pos : null, clampedIndex < without.length && without[clampedIndex] ? without[clampedIndex].pos : null);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.move, {
+							id,
+							pos
+						}));
+					},
+					at: (id) => {
+						const elementPath = operationPath.append(id);
+						return elementPrimitive._internal.createProxy(env, elementPath);
+					},
+					find: (predicate) => {
+						const found = getCurrentState().find((entry) => predicate(entry.value, entry.id));
+						if (!found) return void 0;
+						const elementPath = operationPath.append(found.id);
+						return elementPrimitive._internal.createProxy(env, elementPath);
+					},
+					toSnapshot: () => {
+						return getCurrentState().map((entry) => {
+							const elementPath = operationPath.append(entry.id);
+							const elementProxy = elementPrimitive._internal.createProxy(env, elementPath);
+							return {
+								id: entry.id,
+								value: elementProxy.toSnapshot()
+							};
+						});
+					}
+				};
+			},
+			applyOperation: (state, operation) => {
+				const path = operation.path;
+				const tokens = path.toTokens().filter((t) => t !== "");
+				const currentState = state !== null && state !== void 0 ? state : [];
+				let newState;
+				if (tokens.length === 0) switch (operation.kind) {
+					case "array.set": {
+						const payload = operation.payload;
+						if (!globalThis.Array.isArray(payload)) throw new ValidationError(`ArrayPrimitive.set requires an array payload`);
+						newState = payload;
+						break;
+					}
+					case "array.insert": {
+						const { id, pos, value } = operation.payload;
+						newState = [...currentState, {
+							id,
+							pos,
+							value
+						}];
+						break;
+					}
+					case "array.remove": {
+						const { id } = operation.payload;
+						newState = currentState.filter((entry) => entry.id !== id);
+						break;
+					}
+					case "array.move": {
+						const { id, pos } = operation.payload;
+						newState = currentState.map((entry) => entry.id === id ? _objectSpread2(_objectSpread2({}, entry), {}, { pos }) : entry);
+						break;
+					}
+					default: throw new ValidationError(`ArrayPrimitive cannot apply operation of kind: ${operation.kind}`);
+				}
+				else {
+					const elementId = tokens[0];
+					const entryIndex = currentState.findIndex((entry) => entry.id === elementId);
+					if (entryIndex === -1) throw new ValidationError(`Array element not found with ID: ${elementId}`);
+					const elementPrimitive = this._schema.element;
+					const remainingPath = path.shift();
+					const elementOperation = _objectSpread2(_objectSpread2({}, operation), {}, { path: remainingPath });
+					const currentEntry = currentState[entryIndex];
+					const newValue = elementPrimitive._internal.applyOperation(currentEntry.value, elementOperation);
+					const mutableState = [...currentState];
+					mutableState[entryIndex] = _objectSpread2(_objectSpread2({}, currentEntry), {}, { value: newValue });
+					newState = mutableState;
+				}
+				runValidators(newState, this._schema.validators);
+				return newState;
+			},
+			getInitialState: () => {
+				return this._schema.defaultValue;
+			},
+			transformOperation: (clientOp, serverOp) => {
+				const clientPath = clientOp.path;
+				const serverPath = serverOp.path;
+				if (!pathsOverlap(clientPath, serverPath)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (serverOp.kind === "array.remove") {
+					const removedId = serverOp.payload.id;
+					const clientTokens$1 = clientPath.toTokens().filter((t) => t !== "");
+					const serverTokens$1 = serverPath.toTokens().filter((t) => t !== "");
+					if (clientTokens$1.length > serverTokens$1.length) {
+						if (clientTokens$1[serverTokens$1.length] === removedId) return { type: "noop" };
+					}
+				}
+				if (serverOp.kind === "array.insert" && clientOp.kind === "array.insert") return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (serverOp.kind === "array.move" && clientOp.kind === "array.move") {
+					if (serverOp.payload.id === clientOp.payload.id) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					return {
+						type: "transformed",
+						operation: clientOp
+					};
+				}
+				if (pathsEqual(clientPath, serverPath)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (serverOp.kind === "array.set" && isPrefix(serverPath, clientPath)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				const clientTokens = clientPath.toTokens().filter((t) => t !== "");
+				const serverTokens = serverPath.toTokens().filter((t) => t !== "");
+				if (clientTokens.length > 0 && serverTokens.length > 0) {
+					if (clientTokens[0] !== serverTokens[0]) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					const elementPrimitive = this._schema.element;
+					const clientOpForElement = _objectSpread2(_objectSpread2({}, clientOp), {}, { path: clientOp.path.shift() });
+					const serverOpForElement = _objectSpread2(_objectSpread2({}, serverOp), {}, { path: serverOp.path.shift() });
+					const result = elementPrimitive._internal.transformOperation(clientOpForElement, serverOpForElement);
+					if (result.type === "transformed") return {
+						type: "transformed",
+						operation: _objectSpread2(_objectSpread2({}, result.operation), {}, { path: clientOp.path })
+					};
+					return result;
+				}
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this array as required */
+	required() {
+		return new ArrayPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this array */
+	default(defaultValue) {
+		return new ArrayPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue }));
+	}
+	/** Get the element primitive */
+	get element() {
+		return this._schema.element;
+	}
+	/** Add a custom validation rule */
+	refine(fn, message) {
+		return new ArrayPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { validators: [...this._schema.validators, {
+			validate: fn,
+			message
+		}] }));
+	}
+	/** Minimum array length */
+	minLength(length) {
+		return this.refine((v) => v.length >= length, `Array must have at least ${length} elements`);
+	}
+	/** Maximum array length */
+	maxLength(length) {
+		return this.refine((v) => v.length <= length, `Array must have at most ${length} elements`);
+	}
+};
+/** Creates a new ArrayPrimitive with the given element type */
+const Array$1 = (element) => new ArrayPrimitive({
+	required: false,
+	defaultValue: void 0,
+	element,
+	validators: []
+});
+
+//#endregion
+//#region src/primitives/Lazy.ts
+var LazyPrimitive = class {
+	constructor(thunk) {
+		_defineProperty(this, "_tag", "LazyPrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_thunk", void 0);
+		_defineProperty(this, "_resolved", void 0);
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				return this._resolve()._internal.createProxy(env, operationPath);
+			},
+			applyOperation: (state, operation) => {
+				return this._resolve()._internal.applyOperation(state, operation);
+			},
+			getInitialState: () => {
+				return this._resolve()._internal.getInitialState();
+			},
+			transformOperation: (clientOp, serverOp) => {
+				return this._resolve()._internal.transformOperation(clientOp, serverOp);
+			}
+		});
+		this._thunk = thunk;
+	}
+	/** Resolve and cache the lazy primitive */
+	_resolve() {
+		if (this._resolved === void 0) this._resolved = this._thunk();
+		return this._resolved;
+	}
+	/** Mark this lazy primitive as required (delegates to resolved) */
+	required() {
+		return this;
+	}
+};
+/** Creates a new LazyPrimitive with the given thunk */
+const Lazy = (thunk) => new LazyPrimitive(thunk);
+
+//#endregion
+//#region src/primitives/Union.ts
+var UnionPrimitive = class UnionPrimitive {
+	constructor(schema) {
+		_defineProperty(this, "_tag", "UnionPrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make$5({
+			kind: "union.set",
+			payload: Schema.Unknown,
+			target: Schema.Unknown,
+			apply: (payload) => payload
+		}) });
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const variants = this._schema.variants;
+				const defaultValue = this._schema.defaultValue;
+				return {
+					get: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					},
+					set: (value) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, value));
+					},
+					as: (variant) => {
+						const variantPrimitive = variants[variant];
+						if (!variantPrimitive) throw new ValidationError(`Unknown variant: ${globalThis.String(variant)}`);
+						return variantPrimitive._internal.createProxy(env, operationPath);
+					},
+					match: (handlers) => {
+						const state = env.getState(operationPath);
+						if (!state) return void 0;
+						const variantKey = this._findVariantKey(state);
+						if (!variantKey) return void 0;
+						const handler = handlers[variantKey];
+						if (!handler) return void 0;
+						return handler(variants[variantKey]._internal.createProxy(env, operationPath));
+					},
+					toSnapshot: () => {
+						const state = env.getState(operationPath);
+						const effectiveState = state !== null && state !== void 0 ? state : defaultValue;
+						if (!effectiveState) return;
+						const variantKey = this._findVariantKey(effectiveState);
+						if (!variantKey) return;
+						return variants[variantKey]._internal.createProxy(env, operationPath).toSnapshot();
+					}
+				};
+			},
+			applyOperation: (state, operation) => {
+				if (operation.path.toTokens().filter((t) => t !== "").length === 0) {
+					if (operation.kind !== "union.set") throw new ValidationError(`UnionPrimitive root cannot apply operation of kind: ${operation.kind}`);
+					const payload = operation.payload;
+					if (typeof payload !== "object" || payload === null) throw new ValidationError(`UnionPrimitive.set requires an object payload`);
+					if (payload[this._schema.discriminator] === void 0) throw new ValidationError(`UnionPrimitive.set requires a "${this._schema.discriminator}" discriminator field`);
+					return payload;
+				}
+				if (state === void 0) throw new ValidationError(`Cannot apply nested operation to undefined union state`);
+				const variantKey = this._findVariantKey(state);
+				if (variantKey === void 0) throw new ValidationError(`Cannot determine active variant from state`);
+				return this._schema.variants[variantKey]._internal.applyOperation(state, operation);
+			},
+			getInitialState: () => {
+				return this._schema.defaultValue;
+			},
+			transformOperation: (clientOp, serverOp) => {
+				const clientPath = clientOp.path;
+				const serverPath = serverOp.path;
+				if (!pathsOverlap(clientPath, serverPath)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				const clientTokens = clientPath.toTokens().filter((t) => t !== "");
+				const serverTokens = serverPath.toTokens().filter((t) => t !== "");
+				if (clientTokens.length === 0 && serverTokens.length === 0) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (serverTokens.length === 0 && serverOp.kind === "union.set") return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (clientTokens.length === 0 && clientOp.kind === "union.set") return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (clientTokens.length > 0 && serverTokens.length > 0) {
+					if (clientTokens[0] !== serverTokens[0]) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					const variantKeys = Object.keys(this._schema.variants);
+					if (variantKeys.length === 0) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					return this._schema.variants[variantKeys[0]]._internal.transformOperation(clientOp, serverOp);
+				}
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this union as required */
+	required() {
+		return new UnionPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this union */
+	default(defaultValue) {
+		return new UnionPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue }));
+	}
+	/** Get the discriminator field name */
+	get discriminator() {
+		return this._schema.discriminator;
+	}
+	/** Get the variants */
+	get variants() {
+		return this._schema.variants;
+	}
+	/** Find the variant key from a state value */
+	_findVariantKey(state) {
+		if (typeof state !== "object" || state === null) return;
+		const discriminatorValue = state[this._schema.discriminator];
+		for (const key in this._schema.variants) {
+			const discriminatorField = this._schema.variants[key].fields[this._schema.discriminator];
+			if (discriminatorField && discriminatorField._tag === "LiteralPrimitive") {
+				if (discriminatorField.literal === discriminatorValue) return key;
+			}
+		}
+	}
+};
+function Union(options) {
+	var _options$discriminato;
+	return new UnionPrimitive({
+		required: false,
+		defaultValue: void 0,
+		discriminator: (_options$discriminato = options.discriminator) !== null && _options$discriminato !== void 0 ? _options$discriminato : "type",
+		variants: options.variants
+	});
+}
+
+//#endregion
+//#region src/primitives/TreeNode.ts
+/**
+* TreeNodePrimitive - defines a node type with its data schema and allowed children
+*/
+var TreeNodePrimitive = class {
+	constructor(type, config) {
+		_defineProperty(this, "_tag", "TreeNodePrimitive");
+		_defineProperty(this, "_Type", void 0);
+		_defineProperty(this, "_Data", void 0);
+		_defineProperty(this, "_Children", void 0);
+		_defineProperty(this, "_type", void 0);
+		_defineProperty(this, "_data", void 0);
+		_defineProperty(this, "_children", void 0);
+		_defineProperty(this, "_resolvedChildren", void 0);
+		this._type = type;
+		this._data = config.data;
+		this._children = config.children;
+	}
+	/** Get the node type identifier */
+	get type() {
+		return this._type;
+	}
+	/** Get the data primitive */
+	get data() {
+		return this._data;
+	}
+	/** Get resolved children (resolves lazy thunk if needed) */
+	get children() {
+		if (this._resolvedChildren === void 0) if (typeof this._children === "function") this._resolvedChildren = this._children();
+		else this._resolvedChildren = this._children;
+		return this._resolvedChildren;
+	}
+	/** Check if a child type is allowed */
+	isChildAllowed(childType) {
+		return this.children.some((child) => child.type === childType);
+	}
+};
+/** Creates a new TreeNodePrimitive with the given type and config */
+const TreeNode = (type, config) => new TreeNodePrimitive(type, config);
+
+//#endregion
+//#region src/primitives/Tree.ts
+/**
+* Helper to get children sorted by position
+*/
+const getOrderedChildren = (nodes, parentId) => {
+	return [...nodes].filter((n) => n.parentId === parentId).sort((a, b) => a.pos < b.pos ? -1 : a.pos > b.pos ? 1 : 0);
+};
+/**
+* Get all descendant IDs of a node (recursive)
+*/
+const getDescendantIds = (nodes, nodeId) => {
+	const children = nodes.filter((n) => n.parentId === nodeId);
+	const descendantIds = [];
+	for (const child of children) {
+		descendantIds.push(child.id);
+		descendantIds.push(...getDescendantIds(nodes, child.id));
+	}
+	return descendantIds;
+};
+/**
+* Check if moving a node to a new parent would create a cycle
+*/
+const wouldCreateCycle = (nodes, nodeId, newParentId) => {
+	if (newParentId === null) return false;
+	if (newParentId === nodeId) return true;
+	return getDescendantIds(nodes, nodeId).includes(newParentId);
+};
+/**
+* Generate a fractional position between two positions
+*/
+const generateTreePosBetween = (left, right) => {
+	const charSet = base62CharSet();
+	return Effect.runSync(generateKeyBetween(left, right, charSet));
+};
+var TreePrimitive = class TreePrimitive {
+	constructor(schema) {
+		_defineProperty(this, "_tag", "TreePrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_nodeTypeRegistry", void 0);
+		_defineProperty(this, "_opDefinitions", {
+			set: make$5({
+				kind: "tree.set",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			insert: make$5({
+				kind: "tree.insert",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			remove: make$5({
+				kind: "tree.remove",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			move: make$5({
+				kind: "tree.move",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			})
+		});
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const getCurrentState = () => {
+					const state = env.getState(operationPath);
+					return state !== null && state !== void 0 ? state : [];
+				};
+				const getParentType = (parentId) => {
+					var _parent$type;
+					if (parentId === null) return null;
+					const parent = getCurrentState().find((n) => n.id === parentId);
+					return (_parent$type = parent === null || parent === void 0 ? void 0 : parent.type) !== null && _parent$type !== void 0 ? _parent$type : null;
+				};
+				const createNodeProxy = (nodeState) => {
+					return {
+						id: nodeState.id,
+						type: nodeState.type,
+						is: (nodeType) => {
+							return nodeState.type === nodeType.type;
+						},
+						as: (nodeType) => {
+							if (nodeState.type !== nodeType.type) throw new ValidationError(`Node is of type "${nodeState.type}", not "${nodeType.type}"`);
+							const nodePath = operationPath.append(nodeState.id);
+							return {
+								id: nodeState.id,
+								type: nodeType.type,
+								data: nodeType.data._internal.createProxy(env, nodePath),
+								get: () => nodeState
+							};
+						},
+						get: () => nodeState
+					};
+				};
+				const buildSnapshot = (nodeId, nodes) => {
+					const node = nodes.find((n) => n.id === nodeId);
+					if (!node) return void 0;
+					const childNodes = getOrderedChildren(nodes, nodeId);
+					const children = [];
+					for (const child of childNodes) {
+						const childSnapshot = buildSnapshot(child.id, nodes);
+						if (childSnapshot) children.push(childSnapshot);
+					}
+					return _objectSpread2(_objectSpread2({
+						id: node.id,
+						type: node.type
+					}, node.data), {}, { children });
+				};
+				return {
+					get: () => {
+						return getCurrentState();
+					},
+					set: (nodes) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, nodes));
+					},
+					root: () => {
+						return getCurrentState().find((n) => n.parentId === null);
+					},
+					children: (parentId) => {
+						return getOrderedChildren(getCurrentState(), parentId);
+					},
+					node: (id) => {
+						const nodeState = getCurrentState().find((n) => n.id === id);
+						if (!nodeState) return void 0;
+						return createNodeProxy(nodeState);
+					},
+					insertFirst: (parentId, nodeType, data) => {
+						const state = getCurrentState();
+						const siblings = getOrderedChildren(state, parentId);
+						const pos = generateTreePosBetween(null, siblings.length > 0 ? siblings[0].pos : null);
+						const id = env.generateId();
+						if (parentId !== null && !state.find((n) => n.id === parentId)) throw new ValidationError(`Parent node not found: ${parentId}`);
+						const parentType = getParentType(parentId);
+						this._validateChildType(parentType, nodeType.type);
+						if (parentId === null && state.some((n) => n.parentId === null)) throw new ValidationError("Tree already has a root node");
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data
+						}));
+						return id;
+					},
+					insertLast: (parentId, nodeType, data) => {
+						const state = getCurrentState();
+						const siblings = getOrderedChildren(state, parentId);
+						const pos = generateTreePosBetween(siblings.length > 0 ? siblings[siblings.length - 1].pos : null, null);
+						const id = env.generateId();
+						if (parentId !== null && !state.find((n) => n.id === parentId)) throw new ValidationError(`Parent node not found: ${parentId}`);
+						const parentType = getParentType(parentId);
+						this._validateChildType(parentType, nodeType.type);
+						if (parentId === null && state.some((n) => n.parentId === null)) throw new ValidationError("Tree already has a root node");
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data
+						}));
+						return id;
+					},
+					insertAt: (parentId, index, nodeType, data) => {
+						const state = getCurrentState();
+						const siblings = getOrderedChildren(state, parentId);
+						const clampedIndex = Math.max(0, Math.min(index, siblings.length));
+						const pos = generateTreePosBetween(clampedIndex > 0 && siblings[clampedIndex - 1] ? siblings[clampedIndex - 1].pos : null, clampedIndex < siblings.length && siblings[clampedIndex] ? siblings[clampedIndex].pos : null);
+						const id = env.generateId();
+						if (parentId !== null && !state.find((n) => n.id === parentId)) throw new ValidationError(`Parent node not found: ${parentId}`);
+						const parentType = getParentType(parentId);
+						this._validateChildType(parentType, nodeType.type);
+						if (parentId === null && state.some((n) => n.parentId === null)) throw new ValidationError("Tree already has a root node");
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data
+						}));
+						return id;
+					},
+					insertAfter: (siblingId, nodeType, data) => {
+						var _nextSibling$pos;
+						const state = getCurrentState();
+						const sibling = state.find((n) => n.id === siblingId);
+						if (!sibling) throw new ValidationError(`Sibling node not found: ${siblingId}`);
+						const parentId = sibling.parentId;
+						const siblings = getOrderedChildren(state, parentId);
+						const nextSibling = siblings[siblings.findIndex((n) => n.id === siblingId) + 1];
+						const pos = generateTreePosBetween(sibling.pos, (_nextSibling$pos = nextSibling === null || nextSibling === void 0 ? void 0 : nextSibling.pos) !== null && _nextSibling$pos !== void 0 ? _nextSibling$pos : null);
+						const id = env.generateId();
+						const parentType = getParentType(parentId);
+						this._validateChildType(parentType, nodeType.type);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data
+						}));
+						return id;
+					},
+					insertBefore: (siblingId, nodeType, data) => {
+						var _prevSibling$pos;
+						const state = getCurrentState();
+						const sibling = state.find((n) => n.id === siblingId);
+						if (!sibling) throw new ValidationError(`Sibling node not found: ${siblingId}`);
+						const parentId = sibling.parentId;
+						const siblings = getOrderedChildren(state, parentId);
+						const prevSibling = siblings[siblings.findIndex((n) => n.id === siblingId) - 1];
+						const pos = generateTreePosBetween((_prevSibling$pos = prevSibling === null || prevSibling === void 0 ? void 0 : prevSibling.pos) !== null && _prevSibling$pos !== void 0 ? _prevSibling$pos : null, sibling.pos);
+						const id = env.generateId();
+						const parentType = getParentType(parentId);
+						this._validateChildType(parentType, nodeType.type);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data
+						}));
+						return id;
+					},
+					remove: (id) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.remove, { id }));
+					},
+					move: (nodeId, newParentId, toIndex) => {
+						var _state$find$type, _state$find;
+						const state = getCurrentState();
+						const node = state.find((n) => n.id === nodeId);
+						if (!node) throw new ValidationError(`Node not found: ${nodeId}`);
+						if (newParentId !== null && !state.find((n) => n.id === newParentId)) throw new ValidationError(`Parent node not found: ${newParentId}`);
+						if (wouldCreateCycle(state, nodeId, newParentId)) throw new ValidationError("Move would create a cycle in the tree");
+						const newParentType = newParentId === null ? null : (_state$find$type = (_state$find = state.find((n) => n.id === newParentId)) === null || _state$find === void 0 ? void 0 : _state$find.type) !== null && _state$find$type !== void 0 ? _state$find$type : null;
+						this._validateChildType(newParentType, node.type);
+						if (node.parentId === null && newParentId !== null) throw new ValidationError("Cannot move root node to have a parent");
+						const siblings = getOrderedChildren(state, newParentId).filter((n) => n.id !== nodeId);
+						const clampedIndex = Math.max(0, Math.min(toIndex, siblings.length));
+						const pos = generateTreePosBetween(clampedIndex > 0 && siblings[clampedIndex - 1] ? siblings[clampedIndex - 1].pos : null, clampedIndex < siblings.length && siblings[clampedIndex] ? siblings[clampedIndex].pos : null);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.move, {
+							id: nodeId,
+							parentId: newParentId,
+							pos
+						}));
+					},
+					moveAfter: (nodeId, siblingId) => {
+						var _state$find$type2, _state$find2, _nextSibling$pos2;
+						const state = getCurrentState();
+						const node = state.find((n) => n.id === nodeId);
+						const sibling = state.find((n) => n.id === siblingId);
+						if (!node) throw new ValidationError(`Node not found: ${nodeId}`);
+						if (!sibling) throw new ValidationError(`Sibling node not found: ${siblingId}`);
+						const newParentId = sibling.parentId;
+						if (wouldCreateCycle(state, nodeId, newParentId)) throw new ValidationError("Move would create a cycle in the tree");
+						const newParentType = newParentId === null ? null : (_state$find$type2 = (_state$find2 = state.find((n) => n.id === newParentId)) === null || _state$find2 === void 0 ? void 0 : _state$find2.type) !== null && _state$find$type2 !== void 0 ? _state$find$type2 : null;
+						this._validateChildType(newParentType, node.type);
+						if (node.parentId === null && newParentId !== null) throw new ValidationError("Cannot move root node to have a parent");
+						const siblings = getOrderedChildren(state, newParentId).filter((n) => n.id !== nodeId);
+						const nextSibling = siblings[siblings.findIndex((n) => n.id === siblingId) + 1];
+						const pos = generateTreePosBetween(sibling.pos, (_nextSibling$pos2 = nextSibling === null || nextSibling === void 0 ? void 0 : nextSibling.pos) !== null && _nextSibling$pos2 !== void 0 ? _nextSibling$pos2 : null);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.move, {
+							id: nodeId,
+							parentId: newParentId,
+							pos
+						}));
+					},
+					moveBefore: (nodeId, siblingId) => {
+						var _state$find$type3, _state$find3, _prevSibling$pos2;
+						const state = getCurrentState();
+						const node = state.find((n) => n.id === nodeId);
+						const sibling = state.find((n) => n.id === siblingId);
+						if (!node) throw new ValidationError(`Node not found: ${nodeId}`);
+						if (!sibling) throw new ValidationError(`Sibling node not found: ${siblingId}`);
+						const newParentId = sibling.parentId;
+						if (wouldCreateCycle(state, nodeId, newParentId)) throw new ValidationError("Move would create a cycle in the tree");
+						const newParentType = newParentId === null ? null : (_state$find$type3 = (_state$find3 = state.find((n) => n.id === newParentId)) === null || _state$find3 === void 0 ? void 0 : _state$find3.type) !== null && _state$find$type3 !== void 0 ? _state$find$type3 : null;
+						this._validateChildType(newParentType, node.type);
+						if (node.parentId === null && newParentId !== null) throw new ValidationError("Cannot move root node to have a parent");
+						const siblings = getOrderedChildren(state, newParentId).filter((n) => n.id !== nodeId);
+						const prevSibling = siblings[siblings.findIndex((n) => n.id === siblingId) - 1];
+						const pos = generateTreePosBetween((_prevSibling$pos2 = prevSibling === null || prevSibling === void 0 ? void 0 : prevSibling.pos) !== null && _prevSibling$pos2 !== void 0 ? _prevSibling$pos2 : null, sibling.pos);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.move, {
+							id: nodeId,
+							parentId: newParentId,
+							pos
+						}));
+					},
+					moveToFirst: (nodeId, newParentId) => {
+						var _state$find$type4, _state$find4;
+						const state = getCurrentState();
+						const node = state.find((n) => n.id === nodeId);
+						if (!node) throw new ValidationError(`Node not found: ${nodeId}`);
+						if (newParentId !== null && !state.find((n) => n.id === newParentId)) throw new ValidationError(`Parent node not found: ${newParentId}`);
+						if (wouldCreateCycle(state, nodeId, newParentId)) throw new ValidationError("Move would create a cycle in the tree");
+						const newParentType = newParentId === null ? null : (_state$find$type4 = (_state$find4 = state.find((n) => n.id === newParentId)) === null || _state$find4 === void 0 ? void 0 : _state$find4.type) !== null && _state$find$type4 !== void 0 ? _state$find$type4 : null;
+						this._validateChildType(newParentType, node.type);
+						if (node.parentId === null && newParentId !== null) throw new ValidationError("Cannot move root node to have a parent");
+						const siblings = getOrderedChildren(state, newParentId).filter((n) => n.id !== nodeId);
+						const pos = generateTreePosBetween(null, siblings.length > 0 ? siblings[0].pos : null);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.move, {
+							id: nodeId,
+							parentId: newParentId,
+							pos
+						}));
+					},
+					moveToLast: (nodeId, newParentId) => {
+						var _state$find$type5, _state$find5;
+						const state = getCurrentState();
+						const node = state.find((n) => n.id === nodeId);
+						if (!node) throw new ValidationError(`Node not found: ${nodeId}`);
+						if (newParentId !== null && !state.find((n) => n.id === newParentId)) throw new ValidationError(`Parent node not found: ${newParentId}`);
+						if (wouldCreateCycle(state, nodeId, newParentId)) throw new ValidationError("Move would create a cycle in the tree");
+						const newParentType = newParentId === null ? null : (_state$find$type5 = (_state$find5 = state.find((n) => n.id === newParentId)) === null || _state$find5 === void 0 ? void 0 : _state$find5.type) !== null && _state$find$type5 !== void 0 ? _state$find$type5 : null;
+						this._validateChildType(newParentType, node.type);
+						if (node.parentId === null && newParentId !== null) throw new ValidationError("Cannot move root node to have a parent");
+						const siblings = getOrderedChildren(state, newParentId).filter((n) => n.id !== nodeId);
+						const pos = generateTreePosBetween(siblings.length > 0 ? siblings[siblings.length - 1].pos : null, null);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.move, {
+							id: nodeId,
+							parentId: newParentId,
+							pos
+						}));
+					},
+					at: (id, nodeType) => {
+						const node = getCurrentState().find((n) => n.id === id);
+						if (!node) throw new ValidationError(`Node not found: ${id}`);
+						if (node.type !== nodeType.type) throw new ValidationError(`Node is of type "${node.type}", not "${nodeType.type}"`);
+						const nodePath = operationPath.append(id);
+						return nodeType.data._internal.createProxy(env, nodePath);
+					},
+					toSnapshot: () => {
+						const state = getCurrentState();
+						const rootNode = state.find((n) => n.parentId === null);
+						if (!rootNode) return void 0;
+						return buildSnapshot(rootNode.id, state);
+					}
+				};
+			},
+			applyOperation: (state, operation) => {
+				const path = operation.path;
+				const tokens = path.toTokens().filter((t) => t !== "");
+				const currentState = state !== null && state !== void 0 ? state : [];
+				let newState;
+				if (tokens.length === 0) switch (operation.kind) {
+					case "tree.set": {
+						const payload = operation.payload;
+						if (!globalThis.Array.isArray(payload)) throw new ValidationError(`TreePrimitive.set requires an array payload`);
+						newState = payload;
+						break;
+					}
+					case "tree.insert": {
+						const { id, type, parentId, pos, data } = operation.payload;
+						newState = [...currentState, {
+							id,
+							type,
+							parentId,
+							pos,
+							data
+						}];
+						break;
+					}
+					case "tree.remove": {
+						const { id } = operation.payload;
+						const descendantIds = getDescendantIds(currentState, id);
+						const idsToRemove = new Set([id, ...descendantIds]);
+						newState = currentState.filter((node) => !idsToRemove.has(node.id));
+						break;
+					}
+					case "tree.move": {
+						const { id, parentId, pos } = operation.payload;
+						newState = currentState.map((node) => node.id === id ? _objectSpread2(_objectSpread2({}, node), {}, {
+							parentId,
+							pos
+						}) : node);
+						break;
+					}
+					default: throw new ValidationError(`TreePrimitive cannot apply operation of kind: ${operation.kind}`);
+				}
+				else {
+					const nodeId = tokens[0];
+					const nodeIndex = currentState.findIndex((node$1) => node$1.id === nodeId);
+					if (nodeIndex === -1) throw new ValidationError(`Tree node not found with ID: ${nodeId}`);
+					const node = currentState[nodeIndex];
+					const nodeTypePrimitive = this._getNodeTypePrimitive(node.type);
+					const remainingPath = path.shift();
+					const nodeOperation = _objectSpread2(_objectSpread2({}, operation), {}, { path: remainingPath });
+					const newData = nodeTypePrimitive.data._internal.applyOperation(node.data, nodeOperation);
+					const mutableState = [...currentState];
+					mutableState[nodeIndex] = _objectSpread2(_objectSpread2({}, node), {}, { data: newData });
+					newState = mutableState;
+				}
+				runValidators(newState, this._schema.validators);
+				return newState;
+			},
+			getInitialState: () => {
+				var _rootNodeType$data$_i;
+				if (this._schema.defaultValue !== void 0) return this._schema.defaultValue;
+				const rootNodeType = this._schema.root;
+				const rootData = (_rootNodeType$data$_i = rootNodeType.data._internal.getInitialState()) !== null && _rootNodeType$data$_i !== void 0 ? _rootNodeType$data$_i : {};
+				const rootId = crypto.randomUUID();
+				const rootPos = generateTreePosBetween(null, null);
+				return [{
+					id: rootId,
+					type: rootNodeType.type,
+					parentId: null,
+					pos: rootPos,
+					data: rootData
+				}];
+			},
+			transformOperation: (clientOp, serverOp) => {
+				const clientPath = clientOp.path;
+				const serverPath = serverOp.path;
+				if (!pathsOverlap(clientPath, serverPath)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (serverOp.kind === "tree.remove") {
+					const removedId = serverOp.payload.id;
+					const clientTokens$1 = clientPath.toTokens().filter((t) => t !== "");
+					const serverTokens$1 = serverPath.toTokens().filter((t) => t !== "");
+					if (clientOp.kind === "tree.move") {
+						const movePayload = clientOp.payload;
+						if (movePayload.id === removedId || movePayload.parentId === removedId) return { type: "noop" };
+					}
+					if (clientOp.kind === "tree.insert") {
+						if (clientOp.payload.parentId === removedId) return { type: "noop" };
+					}
+					if (clientTokens$1.length > serverTokens$1.length) {
+						if (clientTokens$1[serverTokens$1.length] === removedId) return { type: "noop" };
+					}
+				}
+				if (serverOp.kind === "tree.insert" && clientOp.kind === "tree.insert") return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (serverOp.kind === "tree.move" && clientOp.kind === "tree.move") {
+					if (serverOp.payload.id === clientOp.payload.id) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					return {
+						type: "transformed",
+						operation: clientOp
+					};
+				}
+				if (pathsEqual(clientPath, serverPath)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (serverOp.kind === "tree.set" && isPrefix(serverPath, clientPath)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				const clientTokens = clientPath.toTokens().filter((t) => t !== "");
+				const serverTokens = serverPath.toTokens().filter((t) => t !== "");
+				if (clientTokens.length > 0 && serverTokens.length > 0) {
+					if (clientTokens[0] !== serverTokens[0]) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					return {
+						type: "transformed",
+						operation: clientOp
+					};
+				}
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this tree as required */
+	required() {
+		return new TreePrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this tree */
+	default(defaultValue) {
+		return new TreePrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue }));
+	}
+	/** Get the root node type */
+	get root() {
+		return this._schema.root;
+	}
+	/** Add a custom validation rule */
+	refine(fn, message) {
+		return new TreePrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { validators: [...this._schema.validators, {
+			validate: fn,
+			message
+		}] }));
+	}
+	/**
+	* Build a registry of all node types reachable from root
+	*/
+	_buildNodeTypeRegistry() {
+		if (this._nodeTypeRegistry !== void 0) return this._nodeTypeRegistry;
+		const registry = /* @__PURE__ */ new Map();
+		const visited = /* @__PURE__ */ new Set();
+		const visit = (node) => {
+			if (visited.has(node.type)) return;
+			visited.add(node.type);
+			registry.set(node.type, node);
+			for (const child of node.children) visit(child);
+		};
+		visit(this._schema.root);
+		this._nodeTypeRegistry = registry;
+		return registry;
+	}
+	/**
+	* Get a node type primitive by its type string
+	*/
+	_getNodeTypePrimitive(type) {
+		const nodeType = this._buildNodeTypeRegistry().get(type);
+		if (!nodeType) throw new ValidationError(`Unknown node type: ${type}`);
+		return nodeType;
+	}
+	/**
+	* Validate that a node type can be a child of a parent node type
+	*/
+	_validateChildType(parentType, childType) {
+		if (parentType === null) {
+			if (childType !== this._schema.root.type) throw new ValidationError(`Root node must be of type "${this._schema.root.type}", got "${childType}"`);
+			return;
+		}
+		const parentNodePrimitive = this._getNodeTypePrimitive(parentType);
+		if (!parentNodePrimitive.isChildAllowed(childType)) throw new ValidationError(`Node type "${childType}" is not allowed as a child of "${parentType}". Allowed types: ${parentNodePrimitive.children.map((c) => c.type).join(", ") || "none"}`);
+	}
+};
+/** Creates a new TreePrimitive with the given root node type */
+const Tree = (options) => new TreePrimitive({
+	required: false,
+	defaultValue: void 0,
+	root: options.root,
+	validators: []
+});
+
+//#endregion
+//#region src/Primitive.ts
+var Primitive_exports = /* @__PURE__ */ __export({
+	Array: () => Array$1,
+	ArrayPrimitive: () => ArrayPrimitive,
+	Boolean: () => Boolean,
+	BooleanPrimitive: () => BooleanPrimitive,
+	Lazy: () => Lazy,
+	LazyPrimitive: () => LazyPrimitive,
+	Literal: () => Literal,
+	LiteralPrimitive: () => LiteralPrimitive,
+	Number: () => Number$1,
+	NumberPrimitive: () => NumberPrimitive,
+	String: () => String$1,
+	StringPrimitive: () => StringPrimitive,
+	Struct: () => Struct,
+	StructPrimitive: () => StructPrimitive,
+	Tree: () => Tree,
+	TreeNode: () => TreeNode,
+	TreeNodePrimitive: () => TreeNodePrimitive,
+	TreePrimitive: () => TreePrimitive,
+	Union: () => Union,
+	UnionPrimitive: () => UnionPrimitive,
+	ValidationError: () => ValidationError,
+	isCompatibleOperation: () => isCompatibleOperation,
+	runValidators: () => runValidators
+});
+
+//#endregion
+//#region src/ProxyEnvironment.ts
+var ProxyEnvironment_exports = /* @__PURE__ */ __export({ make: () => make$3 });
+/** Default UUID generator using crypto.randomUUID */
+const defaultGenerateId = () => {
+	return crypto.randomUUID();
+};
+/** Default state getter that always returns undefined */
+const defaultGetState = (_path) => {};
+/**
+* Creates a ProxyEnvironment.
+* @param optionsOrCallback - Either an options object or a simple callback for operations
+*/
+const make$3 = (optionsOrCallback) => {
+	var _options$getState, _options$generateId;
+	const options = typeof optionsOrCallback === "function" ? { onOperation: optionsOrCallback } : optionsOrCallback;
+	return {
+		addOperation: (operation) => {
+			options.onOperation(operation);
+		},
+		getState: (_options$getState = options.getState) !== null && _options$getState !== void 0 ? _options$getState : defaultGetState,
+		generateId: (_options$generateId = options.generateId) !== null && _options$generateId !== void 0 ? _options$generateId : defaultGenerateId
+	};
+};
+
+//#endregion
+//#region src/Transaction.ts
+var Transaction_exports = /* @__PURE__ */ __export({
+	decode: () => decode,
+	empty: () => empty,
+	encode: () => encode,
+	isEmpty: () => isEmpty,
+	make: () => make$2,
+	merge: () => merge
+});
+/**
+* Creates a new Transaction with the given operations.
+*/
+const make$2 = (ops) => ({
+	id: crypto.randomUUID(),
+	ops,
+	timestamp: Date.now()
+});
+/**
+* Creates an empty Transaction.
+*/
+const empty = () => make$2([]);
+/**
+* Checks if a transaction is empty (has no operations).
+*/
+const isEmpty = (tx) => tx.ops.length === 0;
+/**
+* Merges multiple transactions into one.
+*/
+const merge = (txs) => {
+	return make$2(txs.flatMap((tx) => tx.ops));
+};
+/**
+* Encodes a Transaction to a JSON-serializable format for network transport.
+* @param transaction - The transaction to encode.
+* @returns The encoded representation.
+*/
+const encode = (transaction) => ({
+	id: transaction.id,
+	ops: transaction.ops.map(encode$1),
+	timestamp: transaction.timestamp
+});
+/**
+* Decodes an encoded transaction back to a Transaction.
+* @param encoded - The encoded representation.
+* @returns The decoded Transaction.
+*/
+const decode = (encoded) => ({
+	id: encoded.id,
+	ops: encoded.ops.map(decode$1),
+	timestamp: encoded.timestamp
+});
+
+//#endregion
+//#region src/Document.ts
+var Document_exports = /* @__PURE__ */ __export({
+	NestedTransactionError: () => NestedTransactionError,
+	OperationError: () => OperationError,
+	make: () => make$1
+});
+/**
+* Error thrown when attempting to start a nested transaction.
+*/
+var NestedTransactionError = class extends Error {
+	constructor() {
+		super("Nested transactions are not supported");
+		_defineProperty(this, "_tag", "NestedTransactionError");
+		this.name = "NestedTransactionError";
+	}
+};
+/**
+* Error thrown when an operation fails to apply.
+*/
+var OperationError = class extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "_tag", "OperationError");
+		this.name = "OperationError";
+	}
+};
+/**
+* Creates a new Document for the given schema.
+*/
+const make$1 = (schema, options) => {
+	var _options$initial;
+	let _state = (_options$initial = options === null || options === void 0 ? void 0 : options.initial) !== null && _options$initial !== void 0 ? _options$initial : schema._internal.getInitialState();
+	let _pending = [];
+	let _inTransaction = false;
+	let _txOps = [];
+	let _txBaseState = void 0;
+	/**
+	* Gets state at the given path.
+	*/
+	const getStateAtPath = (path) => {
+		const tokens = path.toTokens().filter((t) => t !== "");
+		if (tokens.length === 0) return _state;
+		let current = _state;
+		for (const token of tokens) {
+			if (current === null || current === void 0) return;
+			if (typeof current === "object") {
+				if (Array.isArray(current)) {
+					const entry = current.find((e) => e.id === token);
+					if (entry) {
+						current = entry.value;
+						continue;
+					}
+				}
+				current = current[token];
+			} else return;
+		}
+		return current;
+	};
+	/**
+	* Applies a single operation to the current state.
+	*/
+	const applyOperation = (op) => {
+		try {
+			_state = schema._internal.applyOperation(_state, op);
+		} catch (error) {
+			if (error instanceof Error) throw new OperationError(error.message);
+			throw new OperationError(String(error));
+		}
+	};
+	/**
+	* Handles an operation from a proxy.
+	* In transaction mode: collects operations, applies to state immediately for subsequent reads.
+	* Outside transaction mode: auto-wraps in a single-operation transaction.
+	*/
+	const handleOperation = (op) => {
+		if (_inTransaction) {
+			_txOps.push(op);
+			applyOperation(op);
+		} else {
+			const baseState = _state;
+			try {
+				applyOperation(op);
+				_pending.push(op);
+			} catch (error) {
+				_state = baseState;
+				throw error;
+			}
+		}
+	};
+	/**
+	* Creates a ProxyEnvironment for the document.
+	*/
+	const createEnv = () => {
+		return make$3({
+			onOperation: handleOperation,
+			getState: getStateAtPath
+		});
+	};
+	const env = createEnv();
+	const rootProxy = schema._internal.createProxy(env, make$4(""));
+	return {
+		schema,
+		root: rootProxy,
+		get: () => {
+			return _state;
+		},
+		toSnapshot: () => {
+			return rootProxy.toSnapshot();
+		},
+		transaction: (fn) => {
+			if (_inTransaction) throw new NestedTransactionError();
+			_inTransaction = true;
+			_txOps = [];
+			_txBaseState = _state;
+			try {
+				const result = fn(rootProxy);
+				_pending.push(..._txOps);
+				return result;
+			} catch (error) {
+				_state = _txBaseState;
+				throw error;
+			} finally {
+				_inTransaction = false;
+				_txOps = [];
+				_txBaseState = void 0;
+			}
+		},
+		apply: (ops) => {
+			for (const op of ops) applyOperation(op);
+		},
+		flush: () => {
+			const tx = make$2(_pending);
+			_pending = [];
+			return tx;
+		}
+	};
+};
+
+//#endregion
+//#region src/Transform.ts
+var Transform_exports = {};
+
+//#endregion
+//#region src/Presence.ts
+/**
+* @since 0.0.1
+* Presence module for ephemeral per-connection state.
+* Used by both client and server for schema validation.
+*/
+var Presence_exports = /* @__PURE__ */ __export({
+	isValid: () => isValid,
+	make: () => make,
+	validate: () => validate,
+	validateSafe: () => validateSafe
+});
+/**
+* Creates a new Presence schema wrapper.
+*
+* @example
+* ```typescript
+* import { Presence } from "@voidhash/mimic";
+* import { Schema } from "effect";
+*
+* const CursorPresence = Presence.make({
+*   schema: Schema.Struct({
+*     name: Schema.String,
+*     cursor: Schema.Struct({
+*       x: Schema.Number,
+*       y: Schema.Number,
+*     }),
+*   }),
+* });
+* ```
+*/
+const make = (options) => ({
+	_tag: "Presence",
+	schema: options.schema,
+	_Data: void 0
+});
+/**
+* Validates unknown data against a Presence schema.
+* Throws a ParseError if validation fails.
+*
+* @param presence - The Presence instance with the schema
+* @param data - Unknown data to validate
+* @returns The validated and typed data
+* @throws ParseError if validation fails
+*/
+const validate = (presence, data) => {
+	return Schema$1.decodeUnknownSync(presence.schema)(data);
+};
+/**
+* Safely validates unknown data against a Presence schema.
+* Returns undefined if validation fails instead of throwing.
+*
+* @param presence - The Presence instance with the schema
+* @param data - Unknown data to validate
+* @returns The validated data or undefined if invalid
+*/
+const validateSafe = (presence, data) => {
+	try {
+		return Schema$1.decodeUnknownSync(presence.schema)(data);
+	} catch (_unused) {
+		return;
+	}
+};
+/**
+* Checks if unknown data is valid according to a Presence schema.
+*
+* @param presence - The Presence instance with the schema
+* @param data - Unknown data to check
+* @returns true if valid, false otherwise
+*/
+const isValid = (presence, data) => {
+	try {
+		Schema$1.decodeUnknownSync(presence.schema)(data);
+		return true;
+	} catch (_unused2) {
+		return false;
+	}
+};
+
+//#endregion
+export { Document_exports as Document, Operation_exports as Operation, OperationPath_exports as OperationPath, Presence_exports as Presence, Primitive_exports as Primitive, ProxyEnvironment_exports as ProxyEnvironment, Transaction_exports as Transaction, Transform_exports as Transform };
+//# sourceMappingURL=index.mjs.map