@voidhash/mimic 0.0.2 → 0.0.4

package/dist/index.mjs

@@ -1,2968 +1,13 @@
-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
-//#region src/types/index.ts
-var types_exports = /* @__PURE__ */ __export({
-	TreeNodePrimitive: () => TreeNodePrimitive,
-	TreeNodeSelf: () => TreeNodeSelf
-});
-
-//#endregion
-//#region src/utils/tree-helpers.ts
-var tree_helpers_exports = /* @__PURE__ */ __export({
-	buildNodeTypeMap: () => buildNodeTypeMap,
-	canAddChildType: () => canAddChildType,
-	findNode: () => findNode,
-	findNodeById: () => findNodeById,
-	findNodeWithPath: () => findNodeWithPath,
-	findNodes: () => findNodes,
-	flattenTree: () => flattenTree,
-	getAllNodeTypes: () => getAllNodeTypes,
-	getAllowedChildTypes: () => getAllowedChildTypes,
-	getAllowedChildTypesForNode: () => getAllowedChildTypesForNode,
-	getAncestors: () => getAncestors,
-	getDescendants: () => getDescendants,
-	getNodeDepth: () => getNodeDepth,
-	getNodePrimitive: () => getNodePrimitive,
-	getNodeTypeByName: () => getNodeTypeByName,
-	getParent: () => getParent,
-	getSiblings: () => getSiblings,
-	getSubtree: () => getSubtree,
-	isAncestorOf: () => isAncestorOf,
-	isChildTypeAllowed: () => isChildTypeAllowed,
-	mapTree: () => mapTree,
-	traverse: () => traverse
-});
-/**
-* Find a node by ID in a tree snapshot.
-*
-* @param snapshot - The root tree snapshot
-* @param id - The node ID to find
-* @returns The node snapshot if found, undefined otherwise
-*/
-function findNodeById(snapshot, id) {
-	if (!snapshot) return void 0;
-	if (snapshot.id === id) return snapshot;
-	for (const child of snapshot.children) {
-		const found = findNodeById(child, id);
-		if (found) return found;
-	}
-}
-/**
-* Find a node by ID with full path information.
-*
-* @param snapshot - The root tree snapshot
-* @param id - The node ID to find
-* @returns NodeSearchResult with node, path, and depth, or undefined if not found
-*/
-function findNodeWithPath(snapshot, id) {
-	if (!snapshot) return void 0;
-	const search = (node, currentPath, depth) => {
-		const path = [...currentPath, node.id];
-		if (node.id === id) return {
-			node,
-			path,
-			depth
-		};
-		for (const child of node.children) {
-			const result = search(child, path, depth + 1);
-			if (result) return result;
-		}
-	};
-	return search(snapshot, [], 0);
-}
-/**
-* Get the parent node of a given node ID.
-*
-* @param snapshot - The root tree snapshot
-* @param nodeId - The ID of the node whose parent we want
-* @returns ParentSearchResult with parent node and child index, or undefined
-*/
-function getParent(snapshot, nodeId) {
-	if (!snapshot) return void 0;
-	for (let i = 0; i < snapshot.children.length; i++) {
-		const child = snapshot.children[i];
-		if (child && child.id === nodeId) return {
-			parent: snapshot,
-			childIndex: i
-		};
-	}
-	for (const child of snapshot.children) {
-		const result = getParent(child, nodeId);
-		if (result) return result;
-	}
-}
-/**
-* Get a subtree rooted at a specific node ID.
-*
-* @param snapshot - The root tree snapshot
-* @param nodeId - The ID of the node to use as new root
-* @returns The subtree snapshot, or undefined if node not found
-*/
-function getSubtree(snapshot, nodeId) {
-	return findNodeById(snapshot, nodeId);
-}
-/**
-* Get all ancestor nodes from a node up to the root.
-*
-* @param snapshot - The root tree snapshot
-* @param nodeId - The ID of the node
-* @returns Array of ancestor snapshots from immediate parent to root, or empty array
-*/
-function getAncestors(snapshot, nodeId) {
-	if (!snapshot) return [];
-	const result = findNodeWithPath(snapshot, nodeId);
-	if (!result || result.path.length <= 1) return [];
-	const ancestorIds = result.path.slice(0, -1);
-	const ancestors = [];
-	for (let i = ancestorIds.length - 1; i >= 0; i--) {
-		const id = ancestorIds[i];
-		if (id) {
-			const ancestor = findNodeById(snapshot, id);
-			if (ancestor) ancestors.push(ancestor);
-		}
-	}
-	return ancestors;
-}
-/**
-* Get all descendant nodes of a given node (flat array).
-*
-* @param snapshot - The root tree snapshot
-* @param nodeId - The ID of the node (if undefined, returns all descendants of root)
-* @returns Flat array of all descendant node snapshots
-*/
-function getDescendants(snapshot, nodeId) {
-	if (!snapshot) return [];
-	const startNode = nodeId ? findNodeById(snapshot, nodeId) : snapshot;
-	if (!startNode) return [];
-	const descendants = [];
-	const collect = (node) => {
-		for (const child of node.children) {
-			descendants.push(child);
-			collect(child);
-		}
-	};
-	collect(startNode);
-	return descendants;
-}
-/**
-* Get siblings of a node (nodes with the same parent).
-*
-* @param snapshot - The root tree snapshot
-* @param nodeId - The ID of the node
-* @param includeSelf - Whether to include the node itself (default: false)
-* @returns Array of sibling snapshots
-*/
-function getSiblings(snapshot, nodeId, includeSelf = false) {
-	if (!snapshot) return [];
-	const parentResult = getParent(snapshot, nodeId);
-	if (!parentResult) return [];
-	const siblings = parentResult.parent.children;
-	if (includeSelf) return siblings;
-	return siblings.filter((s) => s.id !== nodeId);
-}
-/**
-* Find the first node matching a predicate.
-*
-* @param snapshot - The root tree snapshot
-* @param predicate - Function to test each node
-* @returns First matching node snapshot, or undefined
-*/
-function findNode(snapshot, predicate) {
-	if (!snapshot) return void 0;
-	if (predicate(snapshot)) return snapshot;
-	for (const child of snapshot.children) {
-		const found = findNode(child, predicate);
-		if (found) return found;
-	}
-}
-/**
-* Find all nodes matching a predicate.
-*
-* @param snapshot - The root tree snapshot
-* @param predicate - Function to test each node
-* @returns Array of matching node snapshots
-*/
-function findNodes(snapshot, predicate) {
-	if (!snapshot) return [];
-	const results = [];
-	const search = (node) => {
-		if (predicate(node)) results.push(node);
-		for (const child of node.children) search(child);
-	};
-	search(snapshot);
-	return results;
-}
-/**
-* Get the depth of a specific node (0 = root).
-*
-* @param snapshot - The root tree snapshot
-* @param nodeId - The ID of the node
-* @returns The depth, or -1 if not found
-*/
-function getNodeDepth(snapshot, nodeId) {
-	if (!snapshot) return -1;
-	const result = findNodeWithPath(snapshot, nodeId);
-	return result ? result.depth : -1;
-}
-/**
-* Check if one node is an ancestor of another.
-*
-* @param snapshot - The root tree snapshot
-* @param ancestorId - Potential ancestor node ID
-* @param descendantId - Potential descendant node ID
-* @returns true if ancestorId is an ancestor of descendantId
-*/
-function isAncestorOf(snapshot, ancestorId, descendantId) {
-	if (!snapshot) return false;
-	const result = findNodeWithPath(snapshot, descendantId);
-	if (!result) return false;
-	return result.path.slice(0, -1).includes(ancestorId);
-}
-/**
-* Traverse the tree and call a visitor function for each node.
-* Return false from visitor to stop traversal.
-*
-* @param snapshot - The root tree snapshot
-* @param visitor - Function called for each node (return false to stop)
-* @param options - Traversal options (order: 'pre' | 'post')
-*/
-function traverse(snapshot, visitor, options = {}) {
-	if (!snapshot) return;
-	const { order = "pre" } = options;
-	const visit = (node, depth) => {
-		if (order === "pre") {
-			if (visitor(node, depth) === false) return false;
-		}
-		for (const child of node.children) if (!visit(child, depth + 1)) return false;
-		if (order === "post") {
-			if (visitor(node, depth) === false) return false;
-		}
-		return true;
-	};
-	visit(snapshot, 0);
-}
-/**
-* Flatten the tree into an array with parent information.
-*
-* @param snapshot - The root tree snapshot
-* @returns Array of { node, parentId, depth } objects
-*/
-function flattenTree(snapshot) {
-	if (!snapshot) return [];
-	const result = [];
-	const flatten = (node, parentId, depth) => {
-		result.push({
-			node,
-			parentId,
-			depth
-		});
-		for (const child of node.children) flatten(child, node.id, depth + 1);
-	};
-	flatten(snapshot, null, 0);
-	return result;
-}
-/**
-* Map over all nodes in the tree, transforming each node's data.
-* Preserves tree structure while transforming node content.
-*
-* @param snapshot - The root tree snapshot
-* @param mapper - Function to transform each node
-* @returns New tree structure with transformed nodes, or undefined
-*/
-function mapTree(snapshot, mapper) {
-	if (!snapshot) return void 0;
-	const map = (node, depth) => {
-		return {
-			value: mapper(node, depth),
-			children: node.children.map((child) => map(child, depth + 1))
-		};
-	};
-	return map(snapshot, 0);
-}
-/**
-* Build a lookup map from node type strings to their TreeNodePrimitive definitions.
-* Useful for resolving snapshot node types back to their schema definitions.
-*
-* @param tree - The TreePrimitive to analyze
-* @returns Map from type string to TreeNodePrimitive
-*
-* @example
-* ```ts
-* const typeMap = buildNodeTypeMap(fileTree);
-* const folderPrimitive = typeMap.get("folder"); // FolderNode
-* ```
-*/
-function buildNodeTypeMap(tree) {
-	const map = /* @__PURE__ */ new Map();
-	const visited = /* @__PURE__ */ new Set();
-	const visit = (node) => {
-		if (visited.has(node.type)) return;
-		visited.add(node.type);
-		map.set(node.type, node);
-		for (const child of node.children) visit(child);
-	};
-	visit(tree.root);
-	return map;
-}
-/**
-* Get the TreeNodePrimitive definition for a snapshot node.
-* Requires the tree schema to resolve the type string to its primitive.
-*
-* @param tree - The TreePrimitive schema
-* @param snapshot - The node snapshot to get the primitive for
-* @returns The TreeNodePrimitive, or undefined if not found
-*
-* @example
-* ```ts
-* const node = findNodeById(treeSnapshot, "some-id");
-* const primitive = getNodePrimitive(fileTree, node);
-* // primitive is FolderNode or FileNode depending on node.type
-* ```
-*/
-function getNodePrimitive(tree, snapshot) {
-	return getNodeTypeByName(tree, snapshot.type);
-}
-/**
-* Get the allowed child types for a snapshot node.
-* Combines schema lookup with the node's allowed children.
-*
-* @param tree - The TreePrimitive schema
-* @param snapshot - The node snapshot to get allowed children for
-* @returns Array of allowed child TreeNodePrimitives, or empty array if not found
-*
-* @example
-* ```ts
-* const node = findNodeById(treeSnapshot, "folder-id");
-* const allowedChildren = getAllowedChildTypesForNode(fileTree, node);
-* // Returns [FolderNode, FileNode] if the folder can contain both
-* ```
-*/
-function getAllowedChildTypesForNode(tree, snapshot) {
-	const primitive = getNodePrimitive(tree, snapshot);
-	if (!primitive) return [];
-	return primitive.children;
-}
-/**
-* Check if a child type is allowed for a specific snapshot node.
-*
-* @param tree - The TreePrimitive schema
-* @param parentSnapshot - The parent node snapshot
-* @param childTypeName - The type string of the potential child
-* @returns true if the child type is allowed
-*
-* @example
-* ```ts
-* const folder = findNodeById(treeSnapshot, "folder-id");
-* canAddChildType(fileTree, folder, "file"); // true
-* canAddChildType(fileTree, folder, "unknown"); // false
-* ```
-*/
-function canAddChildType(tree, parentSnapshot, childTypeName) {
-	const primitive = getNodePrimitive(tree, parentSnapshot);
-	if (!primitive) return false;
-	return primitive.isChildAllowed(childTypeName);
-}
-/**
-* Get all allowed child node types for a specific node type.
-*
-* @param nodeType - The TreeNodePrimitive to get children for
-* @returns Array of allowed child TreeNodePrimitives
-*
-* @example
-* ```ts
-* const FolderNode = TreeNode("folder", { ... });
-* const FileNode = TreeNode("file", { ... });
-*
-* // Get allowed children for FolderNode
-* const allowedChildren = getAllowedChildTypes(FolderNode);
-* // Returns [FolderNode, FileNode] if folder can contain both
-* ```
-*/
-function getAllowedChildTypes(nodeType) {
-	return nodeType.children;
-}
-/**
-* Get all unique node types reachable in a tree schema.
-* Recursively traverses the tree structure starting from the root.
-*
-* @param tree - The TreePrimitive to analyze
-* @returns Array of all unique TreeNodePrimitives in the tree schema
-*
-* @example
-* ```ts
-* const fileTree = Tree({ root: FolderNode });
-* const allNodeTypes = getAllNodeTypes(fileTree);
-* // Returns [FolderNode, FileNode] - all possible node types
-* ```
-*/
-function getAllNodeTypes(tree) {
-	const visited = /* @__PURE__ */ new Set();
-	const result = [];
-	const visit = (node) => {
-		if (visited.has(node.type)) return;
-		visited.add(node.type);
-		result.push(node);
-		for (const child of node.children) visit(child);
-	};
-	visit(tree.root);
-	return result;
-}
-/**
-* Get the node type primitive by its type string from a tree schema.
-*
-* @param tree - The TreePrimitive to search
-* @param typeName - The type string to find (e.g., "folder", "file")
-* @returns The matching TreeNodePrimitive, or undefined if not found
-*
-* @example
-* ```ts
-* const fileTree = Tree({ root: FolderNode });
-* const folderType = getNodeTypeByName(fileTree, "folder");
-* // Returns FolderNode
-* ```
-*/
-function getNodeTypeByName(tree, typeName) {
-	return getAllNodeTypes(tree).find((node) => node.type === typeName);
-}
-/**
-* Check if a child type is allowed under a parent type.
-*
-* @param parentType - The parent TreeNodePrimitive
-* @param childTypeName - The type string of the potential child
-* @returns true if the child type is allowed
-*
-* @example
-* ```ts
-* isChildTypeAllowed(FolderNode, "file"); // true if folder can contain files
-* isChildTypeAllowed(FileNode, "folder"); // false - files can't have children
-* ```
-*/
-function isChildTypeAllowed(parentType, childTypeName) {
-	return parentType.isChildAllowed(childTypeName);
-}
-
-//#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, tree_helpers_exports as TreeHelpers, types_exports as Types };
-//# sourceMappingURL=index.mjs.map
+import { OperationPath_exports } from "./OperationPath.mjs";
+import { Operation_exports } from "./Operation.mjs";
+import { Primitive_exports } from "./Primitive.mjs";
+import { ProxyEnvironment_exports } from "./ProxyEnvironment.mjs";
+import { Transaction_exports } from "./Transaction.mjs";
+import { Document_exports } from "./Document.mjs";
+import { Transform_exports } from "./Transform.mjs";
+import { Presence_exports } from "./Presence.mjs";
+import { EffectSchema_exports } from "./EffectSchema.mjs";
+import { types_exports } from "./types/index.mjs";
+import { tree_helpers_exports } from "./utils/tree-helpers.mjs";
+
+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, tree_helpers_exports as TreeHelpers, types_exports as Types };