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

package/dist/index.mjs

@@ -0,0 +1,2526 @@
+import { t as __export } from "./chunk-CLMFDpHK.mjs";
+import { c as Operation_exports, d as isPrefix, f as pathsEqual, l as fromDefinition, m as _defineProperty, p as pathsOverlap, r as Transaction_exports, s as ProxyEnvironment_exports, t as Document_exports, u as OperationPath_exports } from "./Document-CwiAFTIq.mjs";
+import { r as _objectSpread2, t as Presence_exports } from "./Presence-DdMVKcOv.mjs";
+import { Effect, Schema } from "effect";
+
+//#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);
+}
+/**
+* Applies default values to a partial input, recursively handling nested structs.
+* 
+* Uses a two-layer approach:
+* 1. First, get the struct's initial state (which includes struct-level defaults)
+* 2. Then, layer the provided values on top
+* 3. Finally, ensure nested structs are recursively processed
+* 
+* @param primitive - The primitive definition containing field information
+* @param value - The partial value provided by the user
+* @returns The value with defaults applied for missing fields
+*/
+function applyDefaults(primitive, value) {
+	if (primitive._tag === "StructPrimitive") {
+		var _structPrimitive$_int;
+		const structPrimitive = primitive;
+		const result = _objectSpread2(_objectSpread2({}, (_structPrimitive$_int = structPrimitive._internal.getInitialState()) !== null && _structPrimitive$_int !== void 0 ? _structPrimitive$_int : {}), value);
+		for (const key in structPrimitive.fields) {
+			const fieldPrimitive = structPrimitive.fields[key];
+			if (result[key] === void 0) {
+				const fieldDefault = fieldPrimitive._internal.getInitialState();
+				if (fieldDefault !== void 0) result[key] = fieldDefault;
+			} else if (fieldPrimitive._tag === "StructPrimitive" && typeof result[key] === "object" && result[key] !== null) result[key] = applyDefaults(fieldPrimitive, result[key]);
+		}
+		return result;
+	}
+	return value;
+}
+
+//#endregion
+//#region src/OperationDefinition.ts
+const make = (options) => {
+	return {
+		kind: options.kind,
+		payload: options.payload,
+		target: options.target,
+		apply: options.apply
+	};
+};
+
+//#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, "_TRequired", void 0);
+		_defineProperty(this, "_THasDefault", void 0);
+		_defineProperty(this, "TUpdateInput", void 0);
+		_defineProperty(this, "TSetInput", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make({
+			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));
+					},
+					update: (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 = () => 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, "_TRequired", void 0);
+		_defineProperty(this, "_THasDefault", void 0);
+		_defineProperty(this, "TSetInput", void 0);
+		_defineProperty(this, "TUpdateInput", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make({
+			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) => {
+						const merged = applyDefaults(this, value);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, merged));
+					},
+					update: (value) => {
+						for (const key in value) if (Object.prototype.hasOwnProperty.call(value, key)) {
+							const fieldValue = value[key];
+							if (fieldValue === void 0) continue;
+							const fieldPrimitive = fields[key];
+							if (!fieldPrimitive) continue;
+							const fieldPath = operationPath.append(key);
+							const fieldProxy = fieldPrimitive._internal.createProxy(env, fieldPath);
+							if (fieldPrimitive._tag === "StructPrimitive" && typeof fieldValue === "object" && fieldValue !== null && !Array.isArray(fieldValue)) fieldProxy.update(fieldValue);
+							else fieldProxy.set(fieldValue);
+						}
+					},
+					toSnapshot: () => {
+						return buildSnapshot();
+					}
+				}, {
+					get: (target, prop, _receiver) => {
+						if (prop === "get") return target.get;
+						if (prop === "set") return target.set;
+						if (prop === "update") return target.update;
+						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 === "update" || 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) {
+		const merged = applyDefaults(this, defaultValue);
+		return new StructPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue: merged }));
+	}
+	/** 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, "_TRequired", void 0);
+		_defineProperty(this, "_THasDefault", void 0);
+		_defineProperty(this, "TUpdateInput", void 0);
+		_defineProperty(this, "TSetInput", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make({
+			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));
+					},
+					update: (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, "_TRequired", void 0);
+		_defineProperty(this, "_THasDefault", void 0);
+		_defineProperty(this, "TUpdateInput", void 0);
+		_defineProperty(this, "TSetInput", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make({
+			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));
+					},
+					update: (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 = () => 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, "_TRequired", void 0);
+		_defineProperty(this, "_THasDefault", void 0);
+		_defineProperty(this, "TUpdateInput", void 0);
+		_defineProperty(this, "TSetInput", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make({
+			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));
+					},
+					update: (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, "_TRequired", void 0);
+		_defineProperty(this, "_THasDefault", void 0);
+		_defineProperty(this, "TSetInput", void 0);
+		_defineProperty(this, "TUpdateInput", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", {
+			set: make({
+				kind: "array.set",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			insert: make({
+				kind: "array.insert",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			remove: make({
+				kind: "array.remove",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			move: make({
+				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);
+				};
+				const applyElementDefaults = (value) => {
+					return applyDefaults(elementPrimitive, value);
+				};
+				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);
+							const mergedValue = applyElementDefaults(value);
+							entries.push({
+								id,
+								pos,
+								value: mergedValue
+							});
+							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);
+						const mergedValue = applyElementDefaults(value);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							pos,
+							value: mergedValue
+						}));
+					},
+					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);
+						const mergedValue = applyElementDefaults(value);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							pos,
+							value: mergedValue
+						}));
+					},
+					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, "_TRequired", void 0);
+		_defineProperty(this, "_THasDefault", void 0);
+		_defineProperty(this, "TSetInput", void 0);
+		_defineProperty(this, "TUpdateInput", 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, "_TRequired", void 0);
+		_defineProperty(this, "_THasDefault", void 0);
+		_defineProperty(this, "TSetInput", void 0);
+		_defineProperty(this, "TUpdateInput", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make({
+			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) => {
+						const merged = this._applyVariantDefaults(value);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, merged));
+					},
+					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) {
+		const merged = this._applyVariantDefaults(defaultValue);
+		return new UnionPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue: merged }));
+	}
+	/** 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;
+			}
+		}
+	}
+	/** Apply defaults to a variant value based on the discriminator */
+	_applyVariantDefaults(value) {
+		const variantKey = this._findVariantKey(value);
+		if (!variantKey) return value;
+		const variantPrimitive = this._schema.variants[variantKey];
+		return applyDefaults(variantPrimitive, value);
+	}
+};
+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/Either.ts
+var EitherPrimitive = class EitherPrimitive {
+	constructor(schema) {
+		_defineProperty(this, "_tag", "EitherPrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_TRequired", void 0);
+		_defineProperty(this, "_THasDefault", void 0);
+		_defineProperty(this, "TUpdateInput", void 0);
+		_defineProperty(this, "TSetInput", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make({
+			kind: "either.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));
+					},
+					update: (value) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, value));
+					},
+					match: (handlers) => {
+						const currentState = env.getState(operationPath);
+						const effectiveState = currentState !== null && currentState !== void 0 ? currentState : defaultValue;
+						if (effectiveState === void 0) return void 0;
+						const valueType = this._getValueType(effectiveState);
+						if (!valueType) return void 0;
+						switch (valueType) {
+							case "string":
+								var _handlers$string;
+								return (_handlers$string = handlers.string) === null || _handlers$string === void 0 ? void 0 : _handlers$string.call(handlers, effectiveState);
+							case "number":
+								var _handlers$number;
+								return (_handlers$number = handlers.number) === null || _handlers$number === void 0 ? void 0 : _handlers$number.call(handlers, effectiveState);
+							case "boolean":
+								var _handlers$boolean;
+								return (_handlers$boolean = handlers.boolean) === null || _handlers$boolean === void 0 ? void 0 : _handlers$boolean.call(handlers, effectiveState);
+							case "literal":
+								var _handlers$literal;
+								return (_handlers$literal = handlers.literal) === null || _handlers$literal === void 0 ? void 0 : _handlers$literal.call(handlers, effectiveState);
+							default: return;
+						}
+					},
+					toSnapshot: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					}
+				};
+			},
+			applyOperation: (_state, operation) => {
+				if (operation.kind !== "either.set") throw new ValidationError(`EitherPrimitive cannot apply operation of kind: ${operation.kind}`);
+				const payload = operation.payload;
+				this._validateAndApplyToVariant(payload, operation.path);
+				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 either as required */
+	required() {
+		return new EitherPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this either */
+	default(defaultValue) {
+		return new EitherPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue }));
+	}
+	/** Get the variants */
+	get variants() {
+		return this._schema.variants;
+	}
+	/**
+	* Determine the type category of a value based on the variants
+	*/
+	_getValueType(value) {
+		const valueType = typeof value;
+		for (const variant of this._schema.variants) if (variant._tag === "LiteralPrimitive") {
+			if (value === variant.literal) return "literal";
+		}
+		if (valueType === "string") {
+			for (const variant of this._schema.variants) if (variant._tag === "StringPrimitive") return "string";
+		}
+		if (valueType === "number") {
+			for (const variant of this._schema.variants) if (variant._tag === "NumberPrimitive") return "number";
+		}
+		if (valueType === "boolean") {
+			for (const variant of this._schema.variants) if (variant._tag === "BooleanPrimitive") return "boolean";
+		}
+	}
+	/**
+	* Find the matching variant for a value.
+	* For literals, matches exact value. For other types, matches by typeof.
+	*/
+	_findMatchingVariant(value) {
+		const valueType = typeof value;
+		for (const variant of this._schema.variants) if (variant._tag === "LiteralPrimitive") {
+			if (value === variant.literal) return variant;
+		}
+		if (valueType === "string") {
+			for (const variant of this._schema.variants) if (variant._tag === "StringPrimitive") return variant;
+		}
+		if (valueType === "number") {
+			for (const variant of this._schema.variants) if (variant._tag === "NumberPrimitive") return variant;
+		}
+		if (valueType === "boolean") {
+			for (const variant of this._schema.variants) if (variant._tag === "BooleanPrimitive") return variant;
+		}
+	}
+	/**
+	* Get the operation kind for a variant
+	*/
+	_getVariantOperationKind(variant) {
+		switch (variant._tag) {
+			case "StringPrimitive": return "string.set";
+			case "NumberPrimitive": return "number.set";
+			case "BooleanPrimitive": return "boolean.set";
+			case "LiteralPrimitive": return "literal.set";
+			default: return "unknown.set";
+		}
+	}
+	/**
+	* Validate a value against the matching variant, including running its validators.
+	* Throws ValidationError if the value doesn't match any variant or fails validation.
+	*/
+	_validateAndApplyToVariant(value, path) {
+		const matchingVariant = this._findMatchingVariant(value);
+		if (!matchingVariant) throw new ValidationError(`EitherPrimitive.set requires a value matching one of: ${this._schema.variants.map((v) => v._tag).join(", ")}, got: ${typeof value}`);
+		const syntheticOp = {
+			kind: this._getVariantOperationKind(matchingVariant),
+			path,
+			payload: value
+		};
+		matchingVariant._internal.applyOperation(void 0, syntheticOp);
+	}
+};
+/**
+* Creates a new EitherPrimitive with the given scalar variant types.
+* Validators defined on the variants are applied when validating values.
+*
+* @example
+* ```typescript
+* // String or number
+* const value = Either(String(), Number());
+*
+* // String, number, or boolean
+* const status = Either(String(), Number(), Boolean()).default("pending");
+*
+* // With literal types
+* const mode = Either(Literal("auto"), Literal("manual"), Number());
+*
+* // With validators - validates string length and number range
+* const constrained = Either(
+*   String().min(2).max(50),
+*   Number().max(255)
+* );
+* ```
+*/
+function Either(...variants) {
+	if (variants.length === 0) throw new ValidationError("Either requires at least one variant");
+	return new EitherPrimitive({
+		required: false,
+		defaultValue: void 0,
+		variants
+	});
+}
+
+//#endregion
+//#region src/primitives/TreeNode.ts
+/**
+* Symbol used to identify the Self placeholder
+*/
+const TreeNodeSelfSymbol = Symbol.for("TreeNode.Self");
+/**
+* Special placeholder for self-referential tree nodes.
+* Use this in the children array when a node type can contain itself.
+* 
+* @example
+* ```typescript
+* const FolderNode = TreeNode("folder", {
+*   data: Struct({ name: String() }),
+*   children: [TreeNodeSelf], // Folder can contain other folders
+* });
+* ```
+*/
+const TreeNodeSelf = {
+	_tag: "TreeNodeSelf",
+	_symbol: TreeNodeSelfSymbol
+};
+/**
+* Check if a value is the Self placeholder
+*/
+const isSelf = (value) => {
+	return typeof value === "object" && value !== null && "_symbol" in value && value._symbol === TreeNodeSelfSymbol;
+};
+/**
+* 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, "TSetInput", void 0);
+		_defineProperty(this, "TUpdateInput", 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, replaces Self with this node) */
+	get children() {
+		if (this._resolvedChildren === void 0) this._resolvedChildren = (typeof this._children === "function" ? this._children() : this._children).map((child) => isSelf(child) ? this : child);
+		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, "_TRequired", void 0);
+		_defineProperty(this, "_THasDefault", void 0);
+		_defineProperty(this, "TSetInput", void 0);
+		_defineProperty(this, "TUpdateInput", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_nodeTypeRegistry", void 0);
+		_defineProperty(this, "_opDefinitions", {
+			set: make({
+				kind: "tree.set",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			insert: make({
+				kind: "tree.insert",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			remove: make({
+				kind: "tree.remove",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			move: make({
+				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);
+							const dataProxy = nodeType.data._internal.createProxy(env, nodePath);
+							return {
+								id: nodeState.id,
+								type: nodeType.type,
+								data: dataProxy,
+								get: () => nodeState,
+								update: (value) => {
+									dataProxy.update(value);
+								}
+							};
+						},
+						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");
+						const mergedData = applyDefaults(nodeType.data, data);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data: mergedData
+						}));
+						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");
+						const mergedData = applyDefaults(nodeType.data, data);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data: mergedData
+						}));
+						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");
+						const mergedData = applyDefaults(nodeType.data, data);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data: mergedData
+						}));
+						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);
+						const mergedData = applyDefaults(nodeType.data, data);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data: mergedData
+						}));
+						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);
+						const mergedData = applyDefaults(nodeType.data, data);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data: mergedData
+						}));
+						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);
+					},
+					updateAt: (id, nodeType, value) => {
+						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);
+						nodeType.data._internal.createProxy(env, nodePath).update(value);
+					},
+					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,
+	Either: () => Either,
+	EitherPrimitive: () => EitherPrimitive,
+	Lazy: () => Lazy,
+	LazyPrimitive: () => LazyPrimitive,
+	Literal: () => Literal,
+	LiteralPrimitive: () => LiteralPrimitive,
+	Number: () => Number,
+	NumberPrimitive: () => NumberPrimitive,
+	String: () => String,
+	StringPrimitive: () => StringPrimitive,
+	Struct: () => Struct,
+	StructPrimitive: () => StructPrimitive,
+	Tree: () => Tree,
+	TreeNode: () => TreeNode,
+	TreeNodePrimitive: () => TreeNodePrimitive,
+	TreeNodeSelf: () => TreeNodeSelf,
+	TreePrimitive: () => TreePrimitive,
+	Union: () => Union,
+	UnionPrimitive: () => UnionPrimitive,
+	ValidationError: () => ValidationError,
+	applyDefaults: () => applyDefaults,
+	isCompatibleOperation: () => isCompatibleOperation,
+	runValidators: () => runValidators
+});
+
+//#endregion
+//#region src/Transform.ts
+var Transform_exports = {};
+
+//#endregion
+//#region src/EffectSchema.ts
+/**
+* Effect.Schema utilities for converting Mimic primitives to Effect.Schema schemas.
+* 
+* @since 0.0.1
+*/
+var EffectSchema_exports = /* @__PURE__ */ __export({
+	TreeNodeStateSchema: () => TreeNodeStateSchema,
+	toSetSchema: () => toSetSchema,
+	toUpdateSchema: () => toUpdateSchema
+});
+/**
+* Schema for a tree node state (flat storage format).
+*/
+const TreeNodeStateSchema = Schema.Struct({
+	id: Schema.String,
+	type: Schema.String,
+	parentId: Schema.NullOr(Schema.String),
+	pos: Schema.String,
+	data: Schema.Unknown
+});
+/**
+* Check if a field is required for set operations.
+* A field is required if: TRequired is true AND THasDefault is false.
+* 
+* We determine this by checking the primitive's schema properties.
+*/
+function isRequiredForSet(primitive) {
+	const schema = primitive._schema;
+	if (!schema) return false;
+	return schema.required === true && schema.defaultValue === void 0;
+}
+/**
+* Get the base Effect.Schema for a primitive type (without optional wrapper).
+*/
+function getBaseSchema(primitive) {
+	switch (primitive._tag) {
+		case "StringPrimitive": return Schema.String;
+		case "NumberPrimitive": return Schema.Number;
+		case "BooleanPrimitive": return Schema.Boolean;
+		case "LiteralPrimitive": {
+			var _schema$literal, _schema;
+			const literalPrimitive = primitive;
+			const literalValue = (_schema$literal = (_schema = literalPrimitive._schema) === null || _schema === void 0 ? void 0 : _schema.literal) !== null && _schema$literal !== void 0 ? _schema$literal : literalPrimitive.literal;
+			return Schema.Literal(literalValue);
+		}
+		case "StructPrimitive": return buildStructSetSchema(primitive);
+		case "ArrayPrimitive": {
+			const elementSchema = buildElementSetSchema(primitive.element);
+			return Schema.Array(elementSchema);
+		}
+		case "UnionPrimitive": return buildUnionSetSchema(primitive);
+		case "EitherPrimitive": return buildEitherSchema(primitive);
+		case "LazyPrimitive": {
+			var _resolve, _resolve2;
+			const lazyPrimitive = primitive;
+			return getBaseSchema((_resolve = (_resolve2 = lazyPrimitive._resolve) === null || _resolve2 === void 0 ? void 0 : _resolve2.call(lazyPrimitive)) !== null && _resolve !== void 0 ? _resolve : lazyPrimitive._thunk());
+		}
+		case "TreeNodePrimitive": return buildStructSetSchema(primitive.data);
+		case "TreePrimitive": return Schema.Array(TreeNodeStateSchema);
+		default: return Schema.Unknown;
+	}
+}
+/**
+* Build the set schema for a struct primitive.
+* Required fields (required=true, no default) are non-optional.
+* Other fields are wrapped with Schema.optional.
+*/
+function buildStructSetSchema(structPrimitive) {
+	const fields = structPrimitive.fields;
+	const schemaFields = {};
+	for (const key in fields) {
+		const fieldPrimitive = fields[key];
+		const baseSchema = getBaseSchema(fieldPrimitive);
+		if (isRequiredForSet(fieldPrimitive)) schemaFields[key] = baseSchema;
+		else schemaFields[key] = Schema.optional(baseSchema);
+	}
+	return Schema.Struct(schemaFields);
+}
+/**
+* Build the update schema for a struct primitive.
+* All fields are optional for partial updates.
+*/
+function buildStructUpdateSchema(structPrimitive) {
+	const fields = structPrimitive.fields;
+	const schemaFields = {};
+	for (const key in fields) {
+		const fieldPrimitive = fields[key];
+		let fieldSchema;
+		if (fieldPrimitive._tag === "StructPrimitive") fieldSchema = buildStructUpdateSchema(fieldPrimitive);
+		else fieldSchema = getBaseSchema(fieldPrimitive);
+		schemaFields[key] = Schema.optional(fieldSchema);
+	}
+	return Schema.Struct(schemaFields);
+}
+/**
+* Build the set schema for an array element.
+* For struct elements, uses the struct's set input schema.
+*/
+function buildElementSetSchema(elementPrimitive) {
+	if (elementPrimitive._tag === "StructPrimitive") return buildStructSetSchema(elementPrimitive);
+	return getBaseSchema(elementPrimitive);
+}
+/**
+* Build the set schema for a union primitive.
+* Creates a Schema.Union of all variant schemas.
+*/
+function buildUnionSetSchema(unionPrimitive) {
+	const variants = unionPrimitive.variants;
+	const variantSchemas = [];
+	for (const key in variants) {
+		const variantPrimitive = variants[key];
+		variantSchemas.push(buildStructSetSchema(variantPrimitive));
+	}
+	if (variantSchemas.length === 0) return Schema.Unknown;
+	if (variantSchemas.length === 1) return variantSchemas[0];
+	return Schema.Union(...variantSchemas);
+}
+/**
+* Build the schema for an either primitive.
+* Creates a Schema.Union of all scalar variant types.
+*/
+function buildEitherSchema(eitherPrimitive) {
+	const variants = eitherPrimitive.variants;
+	const variantSchemas = [];
+	for (const variant of variants) variantSchemas.push(getBaseSchema(variant));
+	if (variantSchemas.length === 0) return Schema.Unknown;
+	if (variantSchemas.length === 1) return variantSchemas[0];
+	return Schema.Union(...variantSchemas);
+}
+/**
+* Build the update schema for a union primitive.
+* Creates a Schema.Union of all variant update schemas.
+*/
+function buildUnionUpdateSchema(unionPrimitive) {
+	const variants = unionPrimitive.variants;
+	const variantSchemas = [];
+	for (const key in variants) {
+		const variantPrimitive = variants[key];
+		variantSchemas.push(buildStructUpdateSchema(variantPrimitive));
+	}
+	if (variantSchemas.length === 0) return Schema.Unknown;
+	if (variantSchemas.length === 1) return variantSchemas[0];
+	return Schema.Union(...variantSchemas);
+}
+/**
+* Get the update schema for a primitive.
+* For structs, all fields are optional (partial updates).
+* For simple primitives, same as set schema.
+*/
+function getUpdateSchema(primitive) {
+	switch (primitive._tag) {
+		case "StructPrimitive": return buildStructUpdateSchema(primitive);
+		case "UnionPrimitive": return buildUnionUpdateSchema(primitive);
+		case "TreeNodePrimitive": return buildStructUpdateSchema(primitive.data);
+		case "LazyPrimitive": {
+			var _resolve3, _resolve4;
+			const lazyPrimitive = primitive;
+			return getUpdateSchema((_resolve3 = (_resolve4 = lazyPrimitive._resolve) === null || _resolve4 === void 0 ? void 0 : _resolve4.call(lazyPrimitive)) !== null && _resolve3 !== void 0 ? _resolve3 : lazyPrimitive._thunk());
+		}
+		default: return getBaseSchema(primitive);
+	}
+}
+function toSetSchema(primitive) {
+	return getBaseSchema(primitive);
+}
+function toUpdateSchema(primitive) {
+	return getUpdateSchema(primitive);
+}
+
+//#endregion
+export { Document_exports as Document, EffectSchema_exports as EffectSchema, 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